feat: formatting rules changes

.clang-format

@@ -0,0 +1,204 @@
+---
+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,39 +4,10 @@
 #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,70 +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
+static void HandleRollSetButtonInteraction(Clay_ElementId element,
-void HandleRollSetButtonInteraction(Clay_ElementId element, Clay_PointerData pointer, intptr_t data) {
+	Clay_PointerData pointer,
-	if (pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
+	intptr_t data) {
+	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
 		Dice_RollActiveSet();
 	}
 }
 
-static
+static void HandleClearSetButtonInteraction(Clay_ElementId element,
-void HandleClearSetButtonInteraction(Clay_ElementId element, Clay_PointerData pointer, intptr_t data) {
+	Clay_PointerData pointer,
-	if (pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
+	intptr_t data) {
+	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
 		Dice_ClearActiveSet();
 	}
 }
 
-static
+static void HandleAddDieButtonInteraction(Clay_ElementId element,
-void HandleAddDieButtonInteraction(Clay_ElementId element, Clay_PointerData pointer, intptr_t die) {
+	Clay_PointerData pointer,
-	if (pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
+	intptr_t die) {
+	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
 		Dice_AddToActiveSet((enum Dice_Die)die);
 	}
 }
 
-static inline
+static inline void AddDieButton(enum Dice_Die die) {
-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, {
+		CLAY_TEXT(Dice_ToString(die), CLAY_TEXT_CONFIG(Header(2, {.textColor = TextColors(0), .textAlignment = CLAY_TEXT_ALIGN_CENTER})));
-			.textColor = TextColors(0),
-			.textAlignment = CLAY_TEXT_ALIGN_CENTER,
-		})));
 	}
 }
 
-static inline
+static inline void DiceSelectorContainer() {
-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,
+					.layoutDirection = CLAY_TOP_TO_BOTTOM,
 			},
 			.clip = {
-				false, true, Clay_GetScrollOffset(),
+					false,
-			},
+					true,
+					Clay_GetScrollOffset(),
+				},
 		})) {
 			AddDieButton(D4);
 			AddDieButton(D6);
@@ -78,23 +77,21 @@ void DiceSelectorContainer() {
 	}
 }
 
-static
+static void HandleRemoveDieButtonInteraction(Clay_ElementId element,
-void HandleRemoveDieButtonInteraction(Clay_ElementId element, Clay_PointerData pointer, intptr_t index) {
+	Clay_PointerData pointer,
-	if (pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
+	intptr_t index) {
+	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
 		Dice_RemoveFromActiveSet((size_t)index);
 	}
 }
 
-static inline
+static inline void RemoveDieButton(enum Dice_Die die, size_t index) {
-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;
@@ -102,56 +99,49 @@ void RemoveDieButton(enum Dice_Die die, size_t index) {
 		CLAY_TEXT(
 			UiData_StoreClayStr(Dice_ResultToString(result[index])),
 			CLAY_TEXT_CONFIG(Header(1, {
-					.textColor = TextColors(0),
+				.textColor = TextColors(0),
-					.textAlignment = CLAY_TEXT_ALIGN_CENTER,
+				.textAlignment = CLAY_TEXT_ALIGN_CENTER,
-				}
+			})));
-			))
-		);
 	}
 }
 
-static inline
+static inline void ActiveDiceContainer() {
-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 = {
+			.clip = { true, true, {Clay_GetScrollOffset().x, 0}}}
-				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(UiData_StoreClayStr(Dice_ResultToString({result, NONE})), CLAY_TEXT_CONFIG(Header(1, {
-				CLAY_TEXT_CONFIG(Header(1, {
+				.textColor = TextColors(0)
-					.textColor = TextColors(0),
+			})));
-				}))
-			);
 			TextButton(CLAY_STRING("Clear"), warningButton, &HandleClearSetButtonInteraction, 0);
 		}
 	}
@@ -160,10 +150,10 @@ void ActiveDiceContainer() {
 void DiceContainer() {
 	CLAY(CLAY_ID("DiceContainer"), {
 		.layout = {
-			.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_PERCENT(0.4) },
+			.sizing = {CLAY_SIZING_GROW(), CLAY_SIZING_GROW()},
 			.childGap = containerGap,
 			.layoutDirection = CLAY_LEFT_TO_RIGHT,
-		},
+		}
 	}) {
 		DiceSelectorContainer();
 		ActiveDiceContainer();

src/main.cpp

@@ -1,14 +1,13 @@
+#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 "style.h"
-#include "ui_data.h"
 #include "resources.h"
+#include "ui_data.h"
 
 #define SDL_MAIN_HANDLED
 #include <SDL3/SDL.h>
@@ -21,84 +20,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 = {
+Clay_SDL3RendererData backendData = {nullptr, nullptr, nullptr};
-	nullptr, nullptr, nullptr
-};
 
-static inline
+static inline void LogOutputResolution() {
-void LogOutputResolution() {
 	int w, h;
 	SDL_GetCurrentRenderOutputSize(renderer, &w, &h);
 	SDL_Log("output size: %i, %d", w, h);
 }
 
-static
+static Clay_Dimensions MeasureText(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData) {
-Clay_Dimensions MeasureText(Clay_StringSlice text, Clay_TextElementConfig *config, void *userData) {
+	TTF_Font **fonts = (TTF_Font **)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
+static void HandleClayErrors(Clay_ErrorData data) {
-void HandleClayErrors(Clay_ErrorData data) {
 	SDL_LogError(SDL_LOG_CATEGORY_ERROR, "%s", data.errorText.chars);
 }
 
-static inline
+static inline void InitSDL() {
-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);
 	}
-	if ((window = SDL_CreateWindow("Window", screenWidth, screenHeight, sdlInitFlags)) == nullptr) {
+	int screenWidth{1920}, screenHeight{1080};
+	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
+static void InitClay() {
-void InitClay() {
 	clayMemorySize = Clay_MinMemorySize();
 	clayPrimaryArena = Clay_CreateArenaWithCapacityAndMemory(clayMemorySize, SDL_malloc(clayMemorySize));
-	Clay_Initialize(clayPrimaryArena, { (float)screenWidth, (float)screenHeight }, { HandleClayErrors });
+	int screenWidth{}, screenHeight{};
+	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();
@@ -109,54 +108,52 @@ 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:
+			case SDL_EVENT_QUIT:
-					running = false;
+				running = false;
-					break;
+				break;
-				case SDL_EVENT_WINDOW_RESIZED:
+			case SDL_EVENT_WINDOW_RESIZED:
-					Clay_SetLayoutDimensions({
+				Clay_SetLayoutDimensions({(float)event.window.data1, (float)event.window.data2});
-						(float)event.window.data1,
+				LogOutputResolution();
-						(float)event.window.data2
+				break;
-					});
+			case SDL_EVENT_MOUSE_WHEEL:
-					LogOutputResolution();
+				if(shiftDown) {
-					break;
+					scrollMotion = (Clay_Vector2){event.wheel.y * 2.f, -event.wheel.x * 5.f};
-				case SDL_EVENT_MOUSE_WHEEL:
+				} else {
-					if (shiftDown) {
+					scrollMotion = (Clay_Vector2){-event.wheel.x * 2.f, event.wheel.y * 5.f};
-						scrollMotion = (Clay_Vector2) { event.wheel.y * 2.f, -event.wheel.x * 5.f };
+				}
-					} else {
+				break;
-						scrollMotion = (Clay_Vector2) { -event.wheel.x * 2.f, event.wheel.y * 5.f };
+			case SDL_EVENT_MOUSE_MOTION:
-					}
+				Clay_SetPointerState((Clay_Vector2){event.motion.x, event.motion.y}, mouseButtonDown);
-					break;
+				break;
-				case SDL_EVENT_MOUSE_MOTION:
+			case SDL_EVENT_MOUSE_BUTTON_DOWN:
-					Clay_SetPointerState((Clay_Vector2) { event.motion.x, event.motion.y }, mouseButtonDown);
+			case SDL_EVENT_MOUSE_BUTTON_UP:
-					break;
+				if(event.button.button == SDL_BUTTON_LEFT) {
-				case SDL_EVENT_MOUSE_BUTTON_DOWN:
+					mouseButtonDown = event.button.down;
-				case SDL_EVENT_MOUSE_BUTTON_UP:
+					Clay_SetPointerState((Clay_Vector2){event.button.x, event.button.y}, mouseButtonDown);
-					if (event.button.button == SDL_BUTTON_LEFT) {
+				}
-						mouseButtonDown = event.button.down;
+				break;
-						Clay_SetPointerState((Clay_Vector2) { event.button.x, event.button.y }, mouseButtonDown);
+			case SDL_EVENT_KEY_DOWN:
-					}
+			case SDL_EVENT_KEY_UP:
-					break;
+				if(event.key.key == SDLK_LSHIFT || event.key.key == SDLK_RSHIFT) {
-				case SDL_EVENT_KEY_DOWN:
+					shiftDown = event.key.down;
-				case SDL_EVENT_KEY_UP:
+				}
-					if (event.key.key == SDLK_LSHIFT || event.key.key == SDLK_RSHIFT) {
+				break;
-						shiftDown = event.key.down;
+			default:
-					}
+				break;
-					break;
-				default: break;
 			}
 		}
 		Clay_UpdateScrollContainers(true, scrollMotion, deltaTime);