.clang-format

@@ -1,204 +0,0 @@
----
-BasedOnStyle: Microsoft
-AccessModifierOffset: -4
-AlignAfterOpenBracket: DontAlign
-AlignArrayOfStructures: None
-AlignConsecutiveAssignments: None
-AlignConsecutiveBitFields: None
-AlignConsecutiveDeclarations: None
-AlignConsecutiveMacros: None
-AlignEscapedNewlines: Right
-AlignOperands: DontAlign
-AlignTrailingComments:
-  Kind: Always
-  OverEmptyLines: 0
-AllowAllArgumentsOnNextLine: true
-AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: Never
-AllowShortCaseLabelsOnASingleLine: false
-AllowShortEnumsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: None
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLambdasOnASingleLine: All
-AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: MultiLine
-AttributeMacros:
-  - __capability
-BinPackArguments: true
-BinPackParameters: true
-BitFieldColonSpacing: Both
-BreakAfterAttributes: Never
-BreakAfterJavaFieldAnnotations: false
-BreakArrays: false
-BreakBeforeBinaryOperators: None
-BreakBeforeBraces: Custom
-BraceWrapping:
-  AfterCaseLabel: false
-  AfterClass: false
-  AfterControlStatement: Never
-  AfterEnum: false
-  AfterFunction: false
-  AfterNamespace: false
-  AfterObjCDeclaration: false
-  AfterStruct: false
-  AfterUnion: false
-  AfterExternBlock: false
-  BeforeCatch: false
-  BeforeElse: false
-  BeforeLambdaBody: false
-  BeforeWhile: false
-  IndentBraces: false
-  SplitEmptyFunction: false
-  SplitEmptyRecord: false
-  SplitEmptyNamespace: false
-BreakBeforeConceptDeclarations: Always
-BreakBeforeInlineASMColon: OnlyMultiline
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializers: BeforeComma
-BreakInheritanceList: BeforeColon
-BreakStringLiterals: true
-ColumnLimit: 0
-CommentPragmas: "^ IWYU pragma:"
-CompactNamespaces: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat: false
-EmptyLineAfterAccessModifier: Never
-EmptyLineBeforeAccessModifier: LogicalBlock
-ExperimentalAutoDetectBinPacking: false
-FixNamespaceComments: true
-ForEachMacros:
-  - foreach
-  - Q_FOREACH
-  - BOOST_FOREACH
-IfMacros:
-  - KJ_IF_MAYBE
-IncludeBlocks: Preserve
-IncludeCategories:
-  - Regex: ^"(llvm|llvm-c|clang|clang-c)/
-    Priority: 2
-    SortPriority: 0
-    CaseSensitive: false
-  - Regex: ^(<|"(gtest|gmock|isl|json)/)
-    Priority: 3
-    SortPriority: 0
-    CaseSensitive: false
-  - Regex: .*
-    Priority: 1
-    SortPriority: 0
-    CaseSensitive: false
-IncludeIsMainRegex: (Test)?$
-IncludeIsMainSourceRegex: ""
-IndentAccessModifiers: false
-IndentCaseBlocks: false
-IndentCaseLabels: false
-IndentExternBlock: AfterExternBlock
-IndentGotoLabels: true
-IndentPPDirectives: None
-IndentRequiresClause: true
-IndentWidth: 4
-IndentWrappedFunctionNames: false
-InsertBraces: true
-InsertNewlineAtEOF: true
-InsertTrailingCommas: None
-IntegerLiteralSeparator:
-  Binary: 0
-  BinaryMinDigits: 0
-  Decimal: 0
-  DecimalMinDigits: 0
-  Hex: 0
-  HexMinDigits: 0
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
-LambdaBodyIndentation: Signature
-Language: Cpp
-LineEnding: DeriveLF
-MacroBlockBegin: ""
-MacroBlockEnd: ""
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBinPackProtocolList: Auto
-ObjCBlockIndentWidth: 4
-ObjCBreakBeforeNestedBlockParam: true
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PPIndentWidth: -1
-PackConstructorInitializers: BinPack
-PenaltyBreakAssignment: 2
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakOpenParenthesis: 0
-PenaltyBreakString: 1000
-PenaltyBreakTemplateDeclaration: 10
-PenaltyExcessCharacter: 1000000
-PenaltyIndentedWhitespace: 0
-PenaltyReturnTypeOnItsOwnLine: 1000
-PointerAlignment: Right
-QualifierAlignment: Leave
-ReferenceAlignment: Pointer
-ReflowComments: true
-RemoveBracesLLVM: false
-RemoveSemicolon: false
-RequiresClausePosition: OwnLine
-RequiresExpressionIndentation: OuterScope
-SeparateDefinitionBlocks: Leave
-ShortNamespaceLines: 1
-SortIncludes: CaseSensitive
-SortJavaStaticImport: Before
-SortUsingDeclarations: LexicographicNumeric
-SpaceAfterCStyleCast: false
-SpaceAfterLogicalNot: false
-SpaceAfterTemplateKeyword: true
-SpaceAroundPointerQualifiers: Default
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeCaseColon: false
-SpaceBeforeCpp11BracedList: false
-SpaceBeforeCtorInitializerColon: true
-SpaceBeforeInheritanceColon: true
-SpaceBeforeParens: Never
-SpaceBeforeParensOptions:
-  AfterControlStatements: true
-  AfterForeachMacros: true
-  AfterFunctionDeclarationName: false
-  AfterFunctionDefinitionName: false
-  AfterIfMacros: false
-  AfterOverloadedOperator: false
-  AfterRequiresInClause: false
-  AfterRequiresInExpression: false
-  BeforeNonEmptyParentheses: false
-SpaceBeforeRangeBasedForLoopColon: true
-SpaceBeforeSquareBrackets: false
-SpaceInEmptyBlock: false
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles: Never
-SpacesInCStyleCastParentheses: false
-SpacesInConditionalStatement: false
-SpacesInContainerLiterals: true
-SpacesInLineCommentPrefix:
-  Minimum: 1
-  Maximum: -1
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-Standard: Latest
-StatementAttributeLikeMacros:
-  - Q_EMIT
-StatementMacros:
-  - Q_UNUSED
-  - QT_REQUIRE_VERSION
-TabWidth: 4
-UseTab: Always
-WhitespaceSensitiveMacros:
-  - BOOST_PP_STRINGIZE
-  - CF_SWIFT_NAME
-  - NS_SWIFT_NAME
-  - PP_STRINGIZE
-  - STRINGIZE
-UseCRLF: false

src/application.cpp

@@ -4,10 +4,39 @@
 #include <SDL3/SDL.h>
 #include <clay/clay.h>
 
+static inline
+void DiceLogContainer() {
+	CLAY(CLAY_ID("LogContainer"), PanelContainer(0, (Clay_ElementDeclaration) {
+		.layout = {
+			.sizing = layoutExpand,
+			.padding = CLAY_PADDING_ALL(16),
+		},
+	})) {}
+}
+
+static inline
+void InitiativeListContainer() {
+	CLAY(CLAY_ID("InitiativeListContainer"), PanelContainer(0, (Clay_ElementDeclaration) {
+		.layout = {
+			.sizing = layoutExpand,
+			.padding = CLAY_PADDING_ALL(16),
+		},
+	})) {}
+}
+
 Clay_RenderCommandArray RenderApplication() {
 	Clay_BeginLayout();
 	CLAY(CLAY_ID("OuterContainer"), WindowStyle()) {
 		DiceContainer();
+		CLAY(CLAY_ID("LowerSplitContainer"), {
+			.layout = {
+				.sizing = layoutExpand,
+				.childGap = containerGap
+			},
+		}) {
+			DiceLogContainer();
+			InitiativeListContainer();
+		}
 	}
 	return Clay_EndLayout();
 }

src/dice_container.cpp

@@ -1,68 +1,69 @@
 #include "dice_container.h"
-#include "dice.h"
-#include "elements.h"
-#include "style.h"
-#include "ui_data.h"
 #include <SDL3/SDL_mouse.h>
 #include <SDL3_image/SDL_image.h>
 #include <clay/clay.h>
 #include <stdint.h>
+#include "elements.h"
+#include "style.h"
+#include "dice.h"
+#include "ui_data.h"
 
-static void HandleRollSetButtonInteraction(Clay_ElementId element,
+static
-	Clay_PointerData pointer,
+void HandleRollSetButtonInteraction(Clay_ElementId element, Clay_PointerData pointer, intptr_t data) {
-	intptr_t data) {
+	if (pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
-	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
 		Dice_RollActiveSet();
 	}
 }
 
-static void HandleClearSetButtonInteraction(Clay_ElementId element,
+static
-	Clay_PointerData pointer,
+void HandleClearSetButtonInteraction(Clay_ElementId element, Clay_PointerData pointer, intptr_t data) {
-	intptr_t data) {
+	if (pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
-	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
 		Dice_ClearActiveSet();
 	}
 }
 
-static void HandleAddDieButtonInteraction(Clay_ElementId element,
+static
-	Clay_PointerData pointer,
+void HandleAddDieButtonInteraction(Clay_ElementId element, Clay_PointerData pointer, intptr_t die) {
-	intptr_t die) {
+	if (pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
-	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
 		Dice_AddToActiveSet((enum Dice_Die)die);
 	}
 }
 
-static inline void AddDieButton(enum Dice_Die die) {
+static inline
+void AddDieButton(enum Dice_Die die) {
 	CLAY(CLAY_IDI("AddDieButton", die), {
 		.layout = {
-			.sizing = {CLAY_SIZING_FIXED(100), CLAY_SIZING_FIXED(100)},
+			.sizing = { CLAY_SIZING_FIXED(100), CLAY_SIZING_FIXED(100) },
-			.childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER},
+			.childAlignment = { CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER },
 		},
-		.image = {GetDiceImage(die, Clay_Hovered())},
+		.image = { GetDiceImage(die, Clay_Hovered()) },
 	}) {
 		Clay_OnHover(&HandleAddDieButtonInteraction, die);
-		CLAY_TEXT(Dice_ToString(die), CLAY_TEXT_CONFIG(Header(2, {.textColor = TextColors(0), .textAlignment = CLAY_TEXT_ALIGN_CENTER})));
+		CLAY_TEXT(Dice_ToString(die), CLAY_TEXT_CONFIG(Header(2, {
+			.textColor = TextColors(0),
+			.textAlignment = CLAY_TEXT_ALIGN_CENTER,
+		})));
 	}
 }
 
-static inline void DiceSelectorContainer() {
+static inline
+void DiceSelectorContainer() {
 	CLAY(CLAY_ID("DiceSelector"),
-		PanelContainer(0, (Clay_ElementDeclaration){
+		PanelContainer(0, (Clay_ElementDeclaration) {
 			.layout = {
-				.sizing = {CLAY_SIZING_FIT(), CLAY_SIZING_GROW()}
+				.sizing = { CLAY_SIZING_FIT(), CLAY_SIZING_GROW() },
-			}}
+			}
+		}
 	)) {
 		CLAY_AUTO_ID(ListContainer(0, {
 			.layout = {
-					.sizing = {CLAY_SIZING_GROW(), CLAY_SIZING_GROW()},
+				.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() },
-					.padding = {2, 2, 5, 5},
+				.padding = { 2, 2, 5, 5 },
-					.childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_TOP},
+				.childAlignment = { CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_TOP },
 				.layoutDirection = CLAY_TOP_TO_BOTTOM,
 			},
 			.clip = {
-					false,
+				false, true, Clay_GetScrollOffset(),
-					true,
-					Clay_GetScrollOffset(),
 			},
 		})) {
 			AddDieButton(D4);
@@ -77,21 +78,23 @@ static inline void DiceSelectorContainer() {
 	}
 }
 
-static void HandleRemoveDieButtonInteraction(Clay_ElementId element,
+static
-	Clay_PointerData pointer,
+void HandleRemoveDieButtonInteraction(Clay_ElementId element, Clay_PointerData pointer, intptr_t index) {
-	intptr_t index) {
+	if (pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
-	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
 		Dice_RemoveFromActiveSet((size_t)index);
 	}
 }
 
-static inline void RemoveDieButton(enum Dice_Die die, size_t index) {
+static inline
+void RemoveDieButton(enum Dice_Die die, size_t index) {
 	CLAY(CLAY_IDI("RemoveDieButton", index), {
 		.layout = {
-				.sizing = {CLAY_SIZING_FIXED(200), CLAY_SIZING_FIXED(200)},
+			.sizing = { CLAY_SIZING_FIXED(200), CLAY_SIZING_FIXED(200) },
-				.childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER},
+			.childAlignment = { CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER },
+		},
+		.image = {
+			GetDiceImage(die, Clay_Hovered())
 		},
-		.image = {GetDiceImage(die, Clay_Hovered())},
 	}) {
 		Clay_OnHover(&HandleRemoveDieButtonInteraction, (intptr_t)index);
 		size_t result_length;
@@ -101,47 +104,54 @@ static inline void RemoveDieButton(enum Dice_Die die, size_t index) {
 			CLAY_TEXT_CONFIG(Header(1, {
 					.textColor = TextColors(0),
 					.textAlignment = CLAY_TEXT_ALIGN_CENTER,
-			})));
+				}
+			))
+		);
 	}
 }
 
-static inline void ActiveDiceContainer() {
+static inline
+void ActiveDiceContainer() {
 	CLAY(CLAY_ID("ActiveDice"), PanelContainer(0, {
 		.layout = {
-			.sizing = {CLAY_SIZING_GROW(), CLAY_SIZING_GROW()},
+			.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() },
-			.childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER},
+			.childAlignment = { CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER },
 			.layoutDirection = CLAY_TOP_TO_BOTTOM,
 		},
 	})) {
 		CLAY(CLAY_ID("ActiveDiceInner"), {
 			.layout = {
-				.sizing = {CLAY_SIZING_FIT(), CLAY_SIZING_GROW()},
+				.sizing = { CLAY_SIZING_FIT(), CLAY_SIZING_GROW() },
-				.padding = {100, 100, 0, 0},
+				.padding = { 100, 100, 0, 0 },
 				.childGap = 16,
-				.childAlignment = {CLAY_ALIGN_X_LEFT, CLAY_ALIGN_Y_CENTER},
+				.childAlignment = { CLAY_ALIGN_X_LEFT, CLAY_ALIGN_Y_CENTER },
 				.layoutDirection = CLAY_LEFT_TO_RIGHT,
 			},
-			.clip = { true, true, {Clay_GetScrollOffset().x, 0}}}
+			.clip = {
-		) {
+				true, true, { Clay_GetScrollOffset().x, 0 }
+			}
+		}) {
 			size_t dice_count = 0;
 			enum Dice_Die const *dice = Dice_GetActiveSet(&dice_count);
-			for(size_t i = 0; i < dice_count; ++i) {
+			for (size_t i = 0; i < dice_count; ++i) {
 				RemoveDieButton(dice[i], i);
 			}
 		}
 		CLAY(CLAY_ID("ActiveDiceControls"), {
 			.layout = {
-				.padding = {0, 0, 0, 10},
+				.padding = { 0, 0, 0, 10 },
 				.childGap = 20,
-				.childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER},
+				.childAlignment = { CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER },
 				.layoutDirection = CLAY_LEFT_TO_RIGHT,
 			},
 		}) {
 			TextButton(CLAY_STRING("Roll"), proceedButton, &HandleRollSetButtonInteraction, 0);
 			int result = Dice_GetLastResultTotal();
-			CLAY_TEXT(UiData_StoreClayStr(Dice_ResultToString({result, NONE})), CLAY_TEXT_CONFIG(Header(1, {
+			CLAY_TEXT(UiData_StoreClayStr(Dice_ResultToString({ result, NONE })),
-				.textColor = TextColors(0)
+				CLAY_TEXT_CONFIG(Header(1, {
-			})));
+					.textColor = TextColors(0),
+				}))
+			);
 			TextButton(CLAY_STRING("Clear"), warningButton, &HandleClearSetButtonInteraction, 0);
 		}
 	}
@@ -150,10 +160,10 @@ static inline void ActiveDiceContainer() {
 void DiceContainer() {
 	CLAY(CLAY_ID("DiceContainer"), {
 		.layout = {
-			.sizing = {CLAY_SIZING_GROW(), CLAY_SIZING_GROW()},
+			.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_PERCENT(0.4) },
 			.childGap = containerGap,
 			.layoutDirection = CLAY_LEFT_TO_RIGHT,
-		}
+		},
 	}) {
 		DiceSelectorContainer();
 		ActiveDiceContainer();

src/main.cpp

@@ -1,13 +1,14 @@
-#include "renderer/clay_renderer_SDL3.h"
 #include <SDL3/SDL_hints.h>
 #include <SDL3/SDL_keycode.h>
 #include <SDL3/SDL_oldnames.h>
 #include <clay/clay.h>
+#include "renderer/clay_renderer_SDL3.h"
 
 #include "application.h"
 #include "defs.h"
-#include "resources.h"
+#include "style.h"
 #include "ui_data.h"
+#include "resources.h"
 
 #define SDL_MAIN_HANDLED
 #include <SDL3/SDL.h>
@@ -20,84 +21,84 @@
 #include <SDL3/SDL_video.h>
 #include <SDL3_ttf/SDL_ttf.h>
 
-#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 constexpr SDL_InitFlags sdlInitFlags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIGH_PIXEL_DENSITY;
 
 SDL_Window *window = nullptr;
 SDL_Renderer *renderer = nullptr;
+int screenWidth = 1920, screenHeight = 1080;
 bool running = true;
 uint64_t clayMemorySize = 0;
 
 Clay_Arena clayPrimaryArena;
 
-Clay_SDL3RendererData backendData = {nullptr, nullptr, nullptr};
+Clay_SDL3RendererData backendData = {
+	nullptr, nullptr, nullptr
+};
 
-static inline void LogOutputResolution() {
+static inline
+void LogOutputResolution() {
 	int w, h;
 	SDL_GetCurrentRenderOutputSize(renderer, &w, &h);
 	SDL_Log("output size: %i, %d", w, h);
 }
 
-static Clay_Dimensions MeasureText(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData) {
+static
-	TTF_Font **fonts = (TTF_Font **)userData;
+Clay_Dimensions MeasureText(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData) {
+	TTF_Font **fonts = (TTF_Font**)userData;
 	TTF_Font *font = fonts[config->fontId];
 	int width, height;
 	TTF_SetFontSize(font, config->fontSize);
-	if(!TTF_GetStringSize(font, text.chars, text.length, &width, &height)) {
+	if (!TTF_GetStringSize(font, text.chars, text.length, &width, &height)) {
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "MeasureText failed to measure text %s", SDL_GetError());
 	}
-	return (Clay_Dimensions){(float)width, (float)height};
+	return (Clay_Dimensions) { (float)width, (float)height };
 }
 
-static void HandleClayErrors(Clay_ErrorData data) {
+static
+void HandleClayErrors(Clay_ErrorData data) {
 	SDL_LogError(SDL_LOG_CATEGORY_ERROR, "%s", data.errorText.chars);
 }
 
-static inline void InitSDL() {
+static inline
+void InitSDL() {
 	SDL_SetHint(SDL_HINT_RENDER_LINE_METHOD, "3");
-	if(!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS)) {
+	if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTS)) {
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "SDL_Init failed: %s", SDL_GetError());
 		exit(1);
 	}
-	int screenWidth{1920}, screenHeight{1080};
+	if ((window = SDL_CreateWindow("Window", screenWidth, screenHeight, sdlInitFlags)) == nullptr) {
-	if(SDL_DisplayMode const *mode{SDL_GetDesktopDisplayMode(0)}) {
-		screenWidth = mode->w;
-		screenHeight = mode->h;
-	}
-
-	if((window = SDL_CreateWindow("Window", screenWidth, screenHeight, sdlInitFlags)) == nullptr) {
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "SDL_CreateWindow failed: %s", SDL_GetError());
 		exit(2);
 	}
-	if((renderer = SDL_CreateRenderer(window, NULL)) == nullptr) {
+	if ((renderer = SDL_CreateRenderer(window, NULL)) == nullptr) {
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "SDL_CreateRenderer failed: %s", SDL_GetError());
 		exit(3);
 	}
-	if(!TTF_Init()) {
+	if (!TTF_Init()) {
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "TTF_Init failed: %s", SDL_GetError());
 		exit(4);
 	}
-	if((textEngine = TTF_CreateRendererTextEngine(renderer)) == nullptr) {
+	if ((textEngine = TTF_CreateRendererTextEngine(renderer)) == nullptr) {
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "TTF_CreateRendererTextEngine failed: %s", SDL_GetError());
 		exit(5);
 	}
 }
 
-static void InitClay() {
+static
+void InitClay() {
 	clayMemorySize = Clay_MinMemorySize();
 	clayPrimaryArena = Clay_CreateArenaWithCapacityAndMemory(clayMemorySize, SDL_malloc(clayMemorySize));
-	int screenWidth{}, screenHeight{};
+	Clay_Initialize(clayPrimaryArena, { (float)screenWidth, (float)screenHeight }, { HandleClayErrors });
-	SDL_GetCurrentRenderOutputSize(renderer, &screenWidth, &screenHeight);
-	Clay_Initialize(clayPrimaryArena, {(float)screenWidth, (float)screenHeight}, {HandleClayErrors});
 	Clay_SetMeasureTextFunction(MeasureText, fonts);
-	Clay_SetLayoutDimensions({(float)screenWidth, (float)screenHeight});
+	Clay_SetLayoutDimensions({ (float)screenWidth, (float)screenHeight });
 	float x, y;
 	SDL_GetMouseState(&x, &y);
-	Clay_SetPointerState((Clay_Vector2){x, y}, false);
+	Clay_SetPointerState((Clay_Vector2) { x, y }, false);
 }
 
 extern Clay_RenderCommandArray RenderApplication();
@@ -108,52 +109,54 @@ int main(int argc, char *argv[]) {
 	LoadResources();
 	LogOutputResolution();
 	InitClay();
-	backendData = (Clay_SDL3RendererData){renderer, textEngine, fonts};
+	backendData = (Clay_SDL3RendererData) { renderer, textEngine, fonts };
 	SDL_Event event;
 	uint64_t startFrameTime = SDL_GetTicksNS();
 	double deltaTime = 0.0;
 	bool mouseButtonDown = false;
 	bool shiftDown = false;
-	while(running) {
+	while (running) {
 		deltaTime = SDL_GetTicksNS() - startFrameTime;
 		startFrameTime = SDL_GetTicksNS();
-		Clay_Vector2 scrollMotion = {0, 0};
+		Clay_Vector2 scrollMotion = { 0, 0 };
 		UiData_Clear();
-		while(SDL_PollEvent(&event)) {
+		while (SDL_PollEvent(&event)) {
 			HandleEvent(event);
-			switch(event.type) {
+			switch (event.type) {
 				case SDL_EVENT_QUIT:
 					running = false;
 					break;
 				case SDL_EVENT_WINDOW_RESIZED:
-				Clay_SetLayoutDimensions({(float)event.window.data1, (float)event.window.data2});
+					Clay_SetLayoutDimensions({
+						(float)event.window.data1,
+						(float)event.window.data2
+					});
 					LogOutputResolution();
 					break;
 				case SDL_EVENT_MOUSE_WHEEL:
-				if(shiftDown) {
+					if (shiftDown) {
-					scrollMotion = (Clay_Vector2){event.wheel.y * 2.f, -event.wheel.x * 5.f};
+						scrollMotion = (Clay_Vector2) { event.wheel.y * 2.f, -event.wheel.x * 5.f };
 					} else {
-					scrollMotion = (Clay_Vector2){-event.wheel.x * 2.f, event.wheel.y * 5.f};
+						scrollMotion = (Clay_Vector2) { -event.wheel.x * 2.f, event.wheel.y * 5.f };
 					}
 					break;
 				case SDL_EVENT_MOUSE_MOTION:
-				Clay_SetPointerState((Clay_Vector2){event.motion.x, event.motion.y}, mouseButtonDown);
+					Clay_SetPointerState((Clay_Vector2) { event.motion.x, event.motion.y }, mouseButtonDown);
 					break;
 				case SDL_EVENT_MOUSE_BUTTON_DOWN:
 				case SDL_EVENT_MOUSE_BUTTON_UP:
-				if(event.button.button == SDL_BUTTON_LEFT) {
+					if (event.button.button == SDL_BUTTON_LEFT) {
 						mouseButtonDown = event.button.down;
-					Clay_SetPointerState((Clay_Vector2){event.button.x, event.button.y}, mouseButtonDown);
+						Clay_SetPointerState((Clay_Vector2) { event.button.x, event.button.y }, mouseButtonDown);
 					}
 					break;
 				case SDL_EVENT_KEY_DOWN:
 				case SDL_EVENT_KEY_UP:
-				if(event.key.key == SDLK_LSHIFT || event.key.key == SDLK_RSHIFT) {
+					if (event.key.key == SDLK_LSHIFT || event.key.key == SDLK_RSHIFT) {
 						shiftDown = event.key.down;
 					}
 					break;
-			default:
+				default: break;
-				break;
 			}
 		}
 		Clay_UpdateScrollContainers(true, scrollMotion, deltaTime);