.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

.clangd

@@ -1,2 +1,2 @@
 CompileFlags:
-  Add: [ -Ivendor/, -Ivendor/SDL3/include, -Ivendor/SDL3_ttf/include ]
+  Add: [ -Wall, --std=c++23, -xc++, -Ivendor/ ]

.gitignore

@@ -3,5 +3,3 @@ build/
 Makefile
 .cache/
 compile_commands.json
-.kdev4
-game-of-life.kdev4

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "vendor/SDL3"]
-	path = vendor/SDL3
-	url = https://github.com/libsdl-org/SDL.git
-[submodule "vendor/SDL3_ttf"]
-	path = vendor/SDL3_ttf
-	url = https://github.com/libsdl-org/SDL_ttf.git
+[submodule "vendor/clay"]
+	path = vendor/clay
+	url = https://git.objectionable.solutions/Sara/clay.git

CMakeLists.txt

@@ -1,25 +0,0 @@
-cmake_minimum_required(VERSION 3.21)
-project(dice-gui)
-
-set(CMAKE_BINARY_DIR "${CMAKE_SOURCE_DIR}/bin")
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
-
-set(CMAKE_CXX_STANDARD 23)
-set(CMAKE_C_STANDARD 23)
-
-file(GLOB_RECURSE source_files . src/**.cpp src/**.c vendor/renderer/**.c)
-include_directories(vendor/)
-
-add_subdirectory(vendor/SDL3/ EXCLUDE_FROM_ALL)
-set(SDLTTF_VENDORED ON)
-add_subdirectory(vendor/SDL3_ttf/ EXCLUDE_FROM_ALL)
-
-add_executable(dice-gui ${source_files})
-target_link_libraries(dice-gui PRIVATE SDL3_ttf::SDL3_ttf SDL3::SDL3)
-
-add_custom_target(copy_assets
-    COMMAND ${CMAKE_COMMAND} -E
-	copy_directory ${CMAKE_SOURCE_DIR}/assets/ ${CMAKE_BINARY_DIR}/assets
-)
-add_dependencies(dice-gui copy_assets)

README.md

@@ -1,119 +0,0 @@
-# Clay SDL3 Template
-
-## Using Template
-
-### Just use [`just`](https://just.systems/man/en/)
-
-Run `just set-project-name {project name}` first.
-
-And remember to `git remote set-url origin {repo}`.
-
-### Otherwise
-
-Modify the CMakeLists.txt manually, just replace CHANGEME with whatever your binary should be called.
-
-## Compiling
-
-> Remember to `git submodule update --init --recursive`!
-
-### Just again
-
-`just configure` runs cmake configuration and generates a `compile_commands.json`.
-
-`just build` runs the cmake build.
-
-### CMake works too, I guess
-
-`cmake -S. -Bbuild`
-
-`cmake --build build`
-
-Same as always
-
-## Files
-
-### thread_pool.h/cpp
-
-Thread pool used for parallel GoL generation ticking.
-
-### application.h/cpp
-
-UI and layout logic.
-
-### style.h/cpp
-
-Reusable UI styling
-
-### resources.h/cpp
-
-Font loading.
-
-### elements.h/cpp
-
-Reusable UI elements
-
-### input.h/cpp
-
-Handling of input events.
-
-### main.cpp:
-
-Entrypoint, setup, and main application loop.
-
-## Prerequisites
-
-* CMake 3.21 or higher
-
-* Compiler capable of C++23 and C23.
-
-## Dependencies
-
-### SDL3
-
-Included as git submodule at `vendor/SDL3/` and dynamically linked.
-
-### SDL3_ttf
-
-Included as git submodule at `vendor/SDL3_ttf/` and dynamically linked.
-
-### Clay
-
-Included as files in `vendor/clay/clay.h`; Single header library.
-
-### Clay SDL3 renderer
-
-Included as files in `vendor/renderer/` and compiled as part of the project.
-
-> Note: Mildly modified from the official Clay_SDL3_renderer to enable more advanced styling.
-
-## Code Standards
-
-* Keep program structure as simple as possible. No `class Application {` class or other Java-isms. Prefer namespaces with static lifetime variables.
-
-* Use STL where possible. Don't reinvent the wheel.
-
-* K&R brackets. With notable exceptions(1)
-
-* camelCase for variables, PascalCase for types and functions (that's what SDL and Clay do).
-
-* In class member functions, always use `this->` to access member variables.
-
-* const applies to the name to it's left, so it goes after the type, not `const int x;` but `int const x`.
-
-* \* and & flush with the declaration name. `Type const &Function(Type &inRef)`
-
-> (1) Bracket exceptions:
-> * using scoped_lock in arbitrary blocks, prefer tailed lisp brackets
-
-```
-struct Data {
-    int x{ 0 }, y{ 0 };
-};
-void MyFunction(Data const &data) { // K&R here
-    DoAsynchronousThings();
-    { scoped_lock lock{ myMutex };
-        myVariable++;
-    } // not quite lisp, lisp with a tail
-    DoMoreAsynchronousThings();
-}
-```

TODO.txt

@@ -0,0 +1,11 @@
+Roll modifier editor
+
+Button to roll the active set
+
+Design representation of internal state of initiative tracker
+
+x Design representation of internal state of dice tray
+
+x Buttons for adding dice to active set
+
+x Buttons for removing dice from active set

justfile

@@ -1,19 +1,14 @@
 build:
 	# BUILDING
-	cmake --build build
+	bear -- make
 
 run:
-	cd bin/ && dice-gui
+	bin/DiceGui
 
 configure:
 	# CONFIGURING WITH PREMAKE
-	cmake -S. -Bbuild -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+	premake5 gmake
 
 clean:
-	# CLEANING BUILD ARTEFACTS
 	rm -r bin/**
 	rm -r build/**
-
-set-project-name projectname: clean
-	git remote set-url origin ""
-	sed -i "s/dice-gui/{{projectname}}/g" ./CMakeLists.txt ./justfile

premake5.lua

@@ -0,0 +1,26 @@
+workspace "DiceGui"
+  configurations { "debug", "release" }
+  location "."
+
+project "Dice"
+  kind "ConsoleApp"
+  language "C++"
+  cppdialect "c++23"
+  location "build/"
+  files { "src/**.cpp", "src/**.c" }
+  includedirs { "include/" }
+  links { "m", "stdc++", "SDL3", "SDL3_ttf", "SDL3_image" }
+  buildoptions { "-Wall" }
+  targetdir "bin/"
+  postbuildcommands {
+    "{RMDIR} %{cfg.targetdir}/assets",
+    "{COPYDIR} %{wks.location}/assets/ %{cfg.targetdir}/assets/"
+  }
+  filter "configurations:debug"
+    defines { "DEBUG" }
+    symbols "On"
+    optimize "Off"
+  filter "configurations:release"
+    defines { "NDEBUG" }
+    optimize "On"
+    symbols "Off"

src/application.cpp

@@ -1,28 +1,16 @@
 #include "application.h"
+#include "dice_container.h"
 #include "style.h"
-#include "elements.h"
 #include <SDL3/SDL.h>
 #include <clay/clay.h>
 
-namespace application {
-static void SampleHeader() {
-	elements::Header(CLAY_STRING("Left Panel"), 2, {
-		.textColor = style::color::white
-	});
-}
-
 Clay_RenderCommandArray RenderApplication() {
 	Clay_BeginLayout();
-	CLAY(CLAY_ID("OuterContainer"), style::Window()) {
-		CLAY_AUTO_ID(style::PanelContainer(0, {
-			.layout = { .sizing = { CLAY_SIZING_PERCENT(0.15), CLAY_SIZING_GROW() } }
-		})) {
-			SampleHeader();
-		}
+	CLAY(CLAY_ID("OuterContainer"), WindowStyle()) {
+		DiceContainer();
 	}
 	return Clay_EndLayout();
 }
 
 void HandleEvent(SDL_Event event) {
 }
-}

src/application.h

@@ -4,9 +4,7 @@
 #include <clay/clay.h>
 #include <SDL3/SDL_events.h>
 
-namespace application {
-Clay_RenderCommandArray RenderApplication();
-void HandleEvent(SDL_Event event);
-}
+extern Clay_RenderCommandArray RenderApplication();
+extern void HandleEvent(SDL_Event evt);
 
 #endif // !APPLICATION_H

src/defs.h

@@ -0,0 +1,13 @@
+#ifndef DEFS_H
+#define DEFS_H
+
+#include <clay/clay.h>
+
+#include <SDL3/SDL.h>
+#include <SDL3_ttf/SDL_ttf.h>
+
+
+extern SDL_Window *window;
+extern SDL_Renderer *renderer;
+
+#endif // !DEFS_H

src/dice.cpp

@@ -0,0 +1,103 @@
+#include "dice.h"
+#include <memory.h>
+
+static size_t activeDiceCount = 0;
+static enum Dice_Die activeDice[MAX_ACTIVE_DICE];
+
+static struct Dice_ResultType rollResult[MAX_ACTIVE_DICE];
+
+int Dice_Roll(enum Dice_Die die) {
+	if (die == COIN) {
+		return (rand() % 2);
+	} else {
+		int const max = die;
+		return (rand() % max) + 1;
+	}
+}
+
+static
+struct Dice_ResultType Dice_RollToResultType(int roll, enum Dice_Die die) {
+	struct Dice_ResultType result = { };
+	result.roll = roll;
+	result.die = die;
+	return result;
+}
+
+enum Dice_Die const *Dice_GetActiveSet(size_t *out_length) {
+	if (out_length != nullptr) {
+		*out_length = activeDiceCount;
+	}
+	return activeDice;
+}
+
+size_t Dice_AddToActiveSet(enum Dice_Die die) {
+	if (activeDiceCount >= MAX_ACTIVE_DICE) {
+		return MAX_ACTIVE_DICE;
+	}
+	activeDice[activeDiceCount] = die;
+	rollResult[activeDiceCount] = Dice_RollToResultType(die, die);
+	return activeDiceCount++;
+}
+
+void Dice_RemoveFromActiveSet(size_t index) {
+	if (index >= MAX_ACTIVE_DICE) {
+		return;
+	} else for (size_t i = index; i < activeDiceCount; ++i) {
+		rollResult[i] = rollResult[i+1];
+	}
+	--activeDiceCount;
+}
+
+void Dice_ClearActiveSet() {
+	activeDiceCount = 0;
+}
+
+void Dice_RollActiveSet() {
+	for (size_t i = 0; i < activeDiceCount; ++i) {
+		rollResult[i] = Dice_RollToResultType(Dice_Roll(activeDice[i]), activeDice[i]);
+	}
+}
+
+struct Dice_ResultType *Dice_GetLastResult(size_t *out_length) {
+	if (out_length != nullptr) {
+		*out_length = activeDiceCount;
+	}
+	return rollResult;
+}
+
+int Dice_GetLastResultTotal() {
+	int result = 0;
+	for (size_t i = 0; i < activeDiceCount; ++i) {
+		result += rollResult[i].roll;
+	}
+	return result;
+}
+
+Clay_String Dice_ToString(enum Dice_Die die) {
+	switch (die) {
+		case NONE: return CLAY_STRING("N/A");
+		case COIN: return CLAY_STRING("C");
+		case D4: return CLAY_STRING("4");
+		case D6: return CLAY_STRING("6");
+		case D8: return CLAY_STRING("8");
+		case D10: return CLAY_STRING("10");
+		case D12: return CLAY_STRING("12");
+		case D20: return CLAY_STRING("20");
+		case D100: return CLAY_STRING("100");
+	}
+	return CLAY_STRING("INVALID");
+}
+
+Clay_String Dice_ResultToString(Dice_ResultType const &result) {
+	static char chars[MAX_ROLL_STR_LEN];
+	Clay_String string = {
+		false, 0, chars,
+	};
+	if (result.die == COIN) {
+		string.length = SDL_snprintf(chars, MAX_ROLL_STR_LEN, result.roll == 1 ? "H" : "T");
+	} else {
+		string.length = SDL_snprintf(chars, MAX_ROLL_STR_LEN, "%d", result.roll);
+	}
+	string.chars = chars;
+	return string;
+}

src/dice.h

@@ -0,0 +1,47 @@
+#ifndef DICE_H
+#define DICE_H
+
+#include "renderer/clay_renderer_SDL3.h"
+#include <stdlib.h>
+
+enum Dice_Die {
+	NONE,
+	COIN = 1,
+	D4 = 4,
+	D6 = 6,
+	D8 = 8,
+	D10 = 10,
+	D12 = 12,
+	D20 = 20,
+	D100 = 100
+};
+
+#ifndef MAX_ROLL_STR_LEN
+#define MAX_ROLL_STR_LEN 10
+#endif
+struct Dice_ResultType {
+	int roll;
+	enum Dice_Die die;
+};
+
+#ifndef MAX_ACTIVE_DICE
+#define MAX_ACTIVE_DICE 20
+#endif
+
+extern int Dice_Roll(enum Dice_Die die);
+
+extern enum Dice_Die const *Dice_GetActiveSet(size_t *out_length);
+extern size_t Dice_AddToActiveSet(Dice_Die die);
+extern void Dice_RemoveFromActiveSet(size_t index);
+extern void Dice_ClearActiveSet();
+extern Clay_String Dice_RollToString(Dice_ResultType &type);
+
+extern struct Dice_ResultType *Dice_GetLastResult(size_t *out_length);
+extern int Dice_GetLastResultTotal();
+
+extern void Dice_RollActiveSet();
+
+extern Clay_String Dice_ToString(enum Dice_Die die);
+extern Clay_String Dice_ResultToString(Dice_ResultType const &result);
+
+#endif // !DICE_H

src/dice_container.cpp

@@ -0,0 +1,161 @@
+#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>
+
+static void HandleRollSetButtonInteraction(Clay_ElementId element,
+	Clay_PointerData pointer,
+	intptr_t data) {
+	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
+		Dice_RollActiveSet();
+	}
+}
+
+static void HandleClearSetButtonInteraction(Clay_ElementId element,
+	Clay_PointerData pointer,
+	intptr_t data) {
+	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
+		Dice_ClearActiveSet();
+	}
+}
+
+static void HandleAddDieButtonInteraction(Clay_ElementId element,
+	Clay_PointerData pointer,
+	intptr_t die) {
+	if(pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
+		Dice_AddToActiveSet((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)},
+			.childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER},
+		},
+		.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})));
+	}
+}
+
+static inline void DiceSelectorContainer() {
+	CLAY(CLAY_ID("DiceSelector"),
+		PanelContainer(0, (Clay_ElementDeclaration){
+			.layout = {
+				.sizing = {CLAY_SIZING_FIT(), CLAY_SIZING_GROW()}
+			}}
+		)) {
+		CLAY_AUTO_ID(ListContainer(0, {
+			.layout = {
+					.sizing = {CLAY_SIZING_GROW(), CLAY_SIZING_GROW()},
+					.padding = {2, 2, 5, 5},
+					.childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_TOP},
+					.layoutDirection = CLAY_TOP_TO_BOTTOM,
+			},
+			.clip = {
+					false,
+					true,
+					Clay_GetScrollOffset(),
+				},
+		})) {
+			AddDieButton(D4);
+			AddDieButton(D6);
+			AddDieButton(D8);
+			AddDieButton(D10);
+			AddDieButton(D12);
+			AddDieButton(D20);
+			AddDieButton(D100);
+			AddDieButton(COIN);
+		}
+	}
+}
+
+static void HandleRemoveDieButtonInteraction(Clay_ElementId element,
+	Clay_PointerData pointer,
+	intptr_t index) {
+	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) {
+	CLAY(CLAY_IDI("RemoveDieButton", index), {
+		.layout = {
+				.sizing = {CLAY_SIZING_FIXED(200), CLAY_SIZING_FIXED(200)},
+				.childAlignment = {CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER},
+		},
+		.image = {GetDiceImage(die, Clay_Hovered())},
+	}) {
+		Clay_OnHover(&HandleRemoveDieButtonInteraction, (intptr_t)index);
+		size_t result_length;
+		struct Dice_ResultType const *result = Dice_GetLastResult(&result_length);
+		CLAY_TEXT(
+			UiData_StoreClayStr(Dice_ResultToString(result[index])),
+			CLAY_TEXT_CONFIG(Header(1, {
+				.textColor = TextColors(0),
+				.textAlignment = CLAY_TEXT_ALIGN_CENTER,
+			})));
+	}
+}
+
+static inline void ActiveDiceContainer() {
+	CLAY(CLAY_ID("ActiveDice"), PanelContainer(0, {
+		.layout = {
+			.sizing = {CLAY_SIZING_GROW(), CLAY_SIZING_GROW()},
+			.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()},
+				.padding = {100, 100, 0, 0},
+				.childGap = 16,
+				.childAlignment = {CLAY_ALIGN_X_LEFT, CLAY_ALIGN_Y_CENTER},
+				.layoutDirection = CLAY_LEFT_TO_RIGHT,
+			},
+			.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) {
+				RemoveDieButton(dice[i], i);
+			}
+		}
+		CLAY(CLAY_ID("ActiveDiceControls"), {
+			.layout = {
+				.padding = {0, 0, 0, 10},
+				.childGap = 20,
+				.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, {
+				.textColor = TextColors(0)
+			})));
+			TextButton(CLAY_STRING("Clear"), warningButton, &HandleClearSetButtonInteraction, 0);
+		}
+	}
+}
+
+void DiceContainer() {
+	CLAY(CLAY_ID("DiceContainer"), {
+		.layout = {
+			.sizing = {CLAY_SIZING_GROW(), CLAY_SIZING_GROW()},
+			.childGap = containerGap,
+			.layoutDirection = CLAY_LEFT_TO_RIGHT,
+		}
+	}) {
+		DiceSelectorContainer();
+		ActiveDiceContainer();
+	}
+}

src/dice_container.h

@@ -0,0 +1,6 @@
+#ifndef DICE_CONTAINER_H
+#define DICE_CONTAINER_H
+
+extern void DiceContainer();
+
+#endif // !DICE_CONTAINER_H

src/elements.cpp

@@ -1,84 +1,22 @@
 #include "elements.h"
 #include "style.h"
-#include "resources.h"
 
-namespace elements {
 void TextButton(Clay_String text, Clay_Color color, OnHoveredFn onHovered, intptr_t onHoveredData) {
-	Clay_Color hovered{ style::ToHoveredColor(color) };
+	Clay_Color hovered = ToHoveredColor(color);
 	CLAY_AUTO_ID({
 		.layout = {
-			.padding = style::buttonPadding,
+			.padding = buttonPadding,
 			.childAlignment = { CLAY_ALIGN_X_CENTER, CLAY_ALIGN_Y_CENTER },
 		},
-		.backgroundColor = Clay_Hovered()
-			? hovered
-			: color,
-		.cornerRadius = style::buttonRadii,
-		.border = {
-			style::ToHoveredColor(Clay_Hovered() ? hovered : color),
-			CLAY_BORDER_ALL(2)
-		},
+		.backgroundColor = Clay_Hovered() ? hovered : color,
+		.cornerRadius = buttonRadii,
+		.border = { ToHoveredColor(Clay_Hovered() ? hovered : color), CLAY_BORDER_ALL(1) },
 	}) {
-		Clay_OnHover(onHovered, onHoveredData);
-		elements::Body(text, {
-			.textColor = style::TextColor(0),
+		CLAY_TEXT(text, CLAY_TEXT_CONFIG(BodyText({
+			.textColor = TextColors(0),
 			.textAlignment = CLAY_TEXT_ALIGN_CENTER,
-		});
+		})));
+		Clay_OnHover(onHovered, onHoveredData);
 	}
 }
 
-void ToggleHovered(Clay_ElementId element, Clay_PointerData pointer, intptr_t data) {
-	bool *hovered{ (bool*)data };
-	if (pointer.state == CLAY_POINTER_DATA_PRESSED_THIS_FRAME) {
-		*hovered = !(*hovered);
-	}
-}
-
-
-void Toggle(Clay_String label, Clay_Color selected, bool &state) {
-	CLAY_AUTO_ID({
-		.layout = {
-			.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() },
-			.childGap = 10,
-			.childAlignment = { CLAY_ALIGN_X_LEFT, CLAY_ALIGN_Y_CENTER },
-		},
-	}) {
-		Clay_Color color{Clay_Hovered()
-					? style::ToHoveredColor(selected)
-					: selected
-		};
-		Clay_OnHover(&ToggleHovered, (intptr_t)(&state));
-		CLAY_AUTO_ID({
-			.layout = {
-				.sizing = {
-					CLAY_SIZING_FIXED(20), CLAY_SIZING_FIXED(20)
-				}
-			},
-			.backgroundColor = (state
-				? selected
-				: style::color::transparent
-			),
-			.cornerRadius = style::buttonRadii,
-			.border = {
-				color,
-				CLAY_BORDER_OUTSIDE(3)
-			},
-		}) { }
-		Body(label, {
-			.textColor = style::TextColor(0)
-		});
-	}
-}
-
-void Body(Clay_String string, Clay_TextElementConfig baseCfg) {
-	baseCfg.fontId = resources::FONT_DEFAULT;
-	baseCfg.fontSize = style::baseFontSize;
-	CLAY_TEXT(string, CLAY_TEXT_CONFIG(baseCfg));
-}
-
-void Header(Clay_String string, size_t header, Clay_TextElementConfig baseCfg) {
-	baseCfg.fontId = resources::FONT_BOLD;
-	baseCfg.fontSize = style::headerSizes[(header)-1];
-	CLAY_TEXT(string, CLAY_TEXT_CONFIG(baseCfg));
-}
-}

src/elements.h

@@ -3,12 +3,8 @@
 
 #include <clay/clay.h>
 
-namespace elements {
 typedef void(*OnHoveredFn)(Clay_ElementId element, Clay_PointerData pointer, intptr_t data);
-void TextButton(Clay_String text, Clay_Color color, OnHoveredFn onHovered, intptr_t onHoveredData = 0);
-void Toggle(Clay_String label, Clay_Color selected, bool &state);
-void Body(Clay_String string, Clay_TextElementConfig baseCfg = {});
-void Header(Clay_String string, size_t header, Clay_TextElementConfig baseCfg = {});
-}
+
+extern void TextButton(Clay_String text, Clay_Color color, OnHoveredFn onHovered, intptr_t onHoveredData);
 
 #endif // !ELEMENTS_H

src/input.cpp

@@ -1,39 +0,0 @@
-#include "input.h"
-
-namespace input {
-Clay_Vector2 scrollMotion{ 0, 0 };
-bool shiftDown{ false };
-bool mouseButtonDown{ false };
-
-void FrameStart() {
-	scrollMotion = { 0, 0 };
-}
-
-void HandleEvent(SDL_Event const &event) {
-	switch (event.type) {
-		case SDL_EVENT_MOUSE_WHEEL:
-			if (shiftDown) {
-				scrollMotion = (Clay_Vector2) { event.wheel.y * 4.f, -event.wheel.x * -4.f };
-			} else {
-				scrollMotion = (Clay_Vector2) { -event.wheel.x * -4.f, event.wheel.y * 4.f };
-			}
-			break;
-		case SDL_EVENT_MOUSE_MOTION:
-			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) {
-				mouseButtonDown = event.button.down;
-				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) {
-				shiftDown = event.key.down;
-			}
-			break;
-	}
-}
-}

src/input.h

@@ -1,15 +0,0 @@
-#ifndef INPUT_H
-#define INPUT_H
-
-#include <SDL3/SDL_events.h>
-#include <clay/clay.h>
-
-namespace input {
-extern Clay_Vector2 scrollMotion;
-extern bool shiftDown;
-extern bool mouseButtonDown;
-void FrameStart();
-void HandleEvent(SDL_Event const &event);
-}
-
-#endif // !INPUT_H

src/main.cpp

@@ -1,22 +1,25 @@
-#define SDL_MAIN_HANDLED
+#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 "application.h"
-#include "input.h"
+#include "defs.h"
 #include "resources.h"
+#include "ui_data.h"
+
+#define SDL_MAIN_HANDLED
 #include <SDL3/SDL.h>
 #include <SDL3/SDL_error.h>
 #include <SDL3/SDL_events.h>
-#include <SDL3/SDL_hints.h>
 #include <SDL3/SDL_init.h>
-#include <SDL3/SDL_keycode.h>
 #include <SDL3/SDL_log.h>
 #include <SDL3/SDL_mouse.h>
 #include <SDL3/SDL_render.h>
 #include <SDL3/SDL_video.h>
 #include <SDL3_ttf/SDL_ttf.h>
-#include <clay/clay.h>
-#include <renderer/clay_renderer_SDL3.h>
-#include <renderer/ui_data.h>
+
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -26,114 +29,138 @@ constexpr SDL_InitFlags sdlInitFlags = SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIGH_PI
 
 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
-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)) {
-		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "MeasureText failed to measure text %s", SDL_GetError());
-	}
-	return (Clay_Dimensions) { (float)width, (float)height };
-}
-
-static
-void HandleClayErrors(Clay_ErrorData data) {
-	SDL_LogError(SDL_LOG_CATEGORY_ERROR, "%s", data.errorText.chars);
-}
-
-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 inline
-void InitSDL() {
+static 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)) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "MeasureText failed to measure text %s", SDL_GetError());
+	}
+	return (Clay_Dimensions){(float)width, (float)height};
+}
+
+static void HandleClayErrors(Clay_ErrorData data) {
+	SDL_LogError(SDL_LOG_CATEGORY_ERROR, "%s", data.errorText.chars);
+}
+
+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);
 	}
-	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 ((resources::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));
-	Clay_Initialize(clayPrimaryArena, { (float)screenWidth, (float)screenHeight }, { HandleClayErrors });
-	Clay_SetMeasureTextFunction(MeasureText, resources::fonts);
-	Clay_SetLayoutDimensions({ (float)screenWidth, (float)screenHeight });
-	float x{ 0 }, y{ 0 };
+	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});
+	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();
+extern void HandleEvent(SDL_Event event);
+
 int main(int argc, char *argv[]) {
 	InitSDL();
-	resources::LoadResources();
+	LoadResources();
 	LogOutputResolution();
 	InitClay();
-	backendData = { renderer, resources::textEngine, resources::fonts };
+	backendData = (Clay_SDL3RendererData){renderer, textEngine, fonts};
 	SDL_Event event;
 	uint64_t startFrameTime = SDL_GetTicksNS();
 	double deltaTime = 0.0;
-	while (running) {
-		std::srand(SDL_GetTicksNS());
+	bool mouseButtonDown = false;
+	bool shiftDown = false;
+	while(running) {
 		deltaTime = SDL_GetTicksNS() - startFrameTime;
 		startFrameTime = SDL_GetTicksNS();
+		Clay_Vector2 scrollMotion = {0, 0};
 		UiData_Clear();
-		input::FrameStart();
-		while (SDL_PollEvent(&event)) {
-			application::HandleEvent(event);
-			input::HandleEvent(event);
-			switch (event.type) {
+		while(SDL_PollEvent(&event)) {
+			HandleEvent(event);
+			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;
-				default: break;
+			case SDL_EVENT_MOUSE_WHEEL:
+				if(shiftDown) {
+					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};
+				}
+				break;
+			case SDL_EVENT_MOUSE_MOTION:
+				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) {
+					mouseButtonDown = event.button.down;
+					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) {
+					shiftDown = event.key.down;
+				}
+				break;
+			default:
+				break;
 			}
 		}
-		Clay_UpdateScrollContainers(true, input::scrollMotion, deltaTime);
-		SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+		Clay_UpdateScrollContainers(true, scrollMotion, deltaTime);
+		SDL_SetRenderDrawColor(renderer, 10, 10, 10, 255);
 		SDL_RenderClear(renderer);
-		Clay_RenderCommandArray commands{ application::RenderApplication() };
-		SDL_Clay_RenderClayCommands(&backendData, &commands);
+		Clay_RenderCommandArray array = RenderApplication();
+		SDL_Clay_RenderClayCommands(&backendData, &array);
 		SDL_RenderPresent(renderer);
 		SDL_Delay(10);
 	}

src/renderer/clay_renderer_SDL3.c

@@ -20,7 +20,7 @@ static void SDL_Clay_GenerateRoundedRectCorner(SDL_Vertex *vertices, size_t begi
     if (count == 1) {
         vertices[begin] = (SDL_Vertex){ { origin.x, origin.y }, color, texel };
     } else {
-        const double quarterCircleRadians = SDL_PI_D / 2.0;
+        constexpr double quarterCircleRadians = SDL_PI_D / 2.0;
         for (size_t i = 0; i < count; ++i) {
             double const angle = (quarterCircleRadians / ((double)count-1)) * i;
             vertices[begin + i] = (SDL_Vertex) { .position = {
@@ -35,10 +35,10 @@ static void SDL_Clay_GenerateRoundedRectCorner(SDL_Vertex *vertices, size_t begi
 
 //all rendering is performed by a single SDL call, avoiding multiple RenderRect + plumbing choice for circles.
 static void SDL_Clay_RenderFillRoundedRect(Clay_SDL3RendererData *rendererData, const SDL_FRect rect, const Clay_CornerRadius cornerRadius, const Clay_Color clayColor) {
-    static const SDL_FPoint topLeftTexel = { 0, 0 };
-    static const SDL_FPoint topRightTexel = { 1, 0 };
-    static const SDL_FPoint bottomRightTexel = { 1, 1 };
-    static const SDL_FPoint bottomLeftTexel = { 0, 1 };
+    static constexpr SDL_FPoint topLeftTexel = { 0, 0 };
+    static constexpr SDL_FPoint topRightTexel = { 1, 0 };
+    static constexpr SDL_FPoint bottomRightTexel = { 1, 1 };
+    static constexpr SDL_FPoint bottomLeftTexel = { 0, 1 };
     SDL_FColor const color = { clayColor.r/255, clayColor.g/255, clayColor.b/255, clayColor.a/255 };
 
     const float maxRadius = SDL_min(rect.w, rect.h) / 2.0f;

src/resources.cpp

@@ -1,32 +1,99 @@
 #include "resources.h"
+#include "defs.h"
 #include "style.h"
-#include <clay/clay.h>
 #include <SDL3/SDL_log.h>
 #include <SDL3/SDL_render.h>
 #include <SDL3_image/SDL_image.h>
 
-namespace resources {
 TTF_Font *fonts[FONT_MAX];
+SDL_Texture *diceImages[DICE_IMAGE_MAX];
+SDL_Texture *diceImagesSelected[DICE_IMAGE_MAX];
 TTF_TextEngine *textEngine = nullptr;
 
-static inline void LoadFonts() {
-	fonts[FONT_DEFAULT] = TTF_OpenFont("assets/AdwaitaSans-Regular.ttf", style::baseFontSize * 5);
+static inline
+void LoadFonts() {
+	fonts[FONT_DEFAULT] = TTF_OpenFont("assets/AdwaitaSans-Regular.ttf", baseFontSize * 5);
 	if (fonts[FONT_DEFAULT] == nullptr) {
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "TTF_OpenFont failed: Failed to load adwaita sans: %s", SDL_GetError());
 		exit(6);
 	}
 	TTF_SetFontHinting(fonts[FONT_DEFAULT], TTF_HINTING_LIGHT_SUBPIXEL);
-	fonts[FONT_BOLD] = TTF_OpenFont("assets/AdwaitaSans-Regular.ttf", style::baseFontSize * 5);
+	fonts[FONT_BOLD] = TTF_OpenFont("assets/AdwaitaSans-Regular.ttf", baseFontSize * 5);
 	if (fonts[FONT_BOLD] == nullptr) {
 		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "TTF_OpenFont failed: Failed to load adwaita sans bold: %s", SDL_GetError());
 		exit(6);
 	}
 	TTF_SetFontHinting(fonts[FONT_BOLD], TTF_HINTING_LIGHT_SUBPIXEL);
 	TTF_SetFontStyle(fonts[FONT_BOLD], TTF_STYLE_BOLD);
-	SDL_Log("LoadFonts: Success");
+}
+
+static inline
+void LoadDiceImages() {
+	if(!(diceImages[COIN_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d2.svg"))) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "IMG_LoadTexture Failed to load die texture: %s", SDL_GetError());
+		exit(7);
+	}
+	diceImagesSelected[COIN_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d2.svg");
+	if(!(diceImages[D4_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d4.svg"))) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "IMG_LoadTexture Failed to load die texture: %s", SDL_GetError());
+		exit(7);
+	}
+	diceImagesSelected[D4_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d4.svg");
+	if(!(diceImages[D6_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d6.svg"))) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "IMG_LoadTexture Failed to load die texture: %s", SDL_GetError());
+		exit(7);
+	}
+	diceImagesSelected[D6_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d6.svg");
+	if(!(diceImages[D8_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d8.svg"))) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "IMG_LoadTexture Failed to load die texture: %s", SDL_GetError());
+		exit(7);
+	}
+	diceImagesSelected[D8_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d8.svg");
+	if(!(diceImages[D10_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d10.svg"))) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "IMG_LoadTexture Failed to load die texture: %s", SDL_GetError());
+		exit(7);
+	}
+	diceImagesSelected[D10_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d10.svg");
+	if(!(diceImages[D12_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d12.svg"))) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "IMG_LoadTexture Failed to load die texture: %s", SDL_GetError());
+		exit(7);
+	}
+	diceImagesSelected[D12_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d12.svg");
+	if(!(diceImages[D20_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d20.svg"))) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "IMG_LoadTexture Failed to load die texture: %s", SDL_GetError());
+		exit(7);
+	}
+	diceImagesSelected[D20_IMAGE] = IMG_LoadTexture(renderer, "assets/icons/d20.svg");
+	for (size_t i = 0; i < DICE_IMAGE_MAX; ++i) {
+		Clay_Color color = dieColors[i];
+		SDL_SetTextureColorMod(diceImages[i], color.r, color.g, color.b);
+		color = ToHoveredColor(dieColors[i]);
+		SDL_SetTextureColorMod(diceImagesSelected[i], color.r, color.g, color.b);
+	}
 }
 
 void LoadResources() {
 	LoadFonts();
+	LoadDiceImages();
 }
+
+SDL_Texture *GetDiceImage(enum Dice_Die die, bool selected) {
+	switch (die) {
+		default:
+		case COIN:
+			return selected ? diceImagesSelected[COIN_IMAGE] : diceImages[COIN_IMAGE];
+		case D4:
+			return selected ? diceImagesSelected[D4_IMAGE] : diceImages[D4_IMAGE];
+		case D6:
+			return selected ? diceImagesSelected[D6_IMAGE] : diceImages[D6_IMAGE];
+		case D8:
+			return selected ? diceImagesSelected[D8_IMAGE] : diceImages[D8_IMAGE];
+		case D10:
+		case D100:
+			return selected ? diceImagesSelected[D10_IMAGE] : diceImages[D10_IMAGE];
+		case D12:
+			return selected ? diceImagesSelected[D12_IMAGE] : diceImages[D12_IMAGE];
+		case D20:
+			return selected ? diceImagesSelected[D20_IMAGE] : diceImages[D20_IMAGE];
+	}
 }

src/resources.h

@@ -1,19 +1,35 @@
 #ifndef RESOURCES_H
 #define RESOURCES_H
 
+#include "dice.h"
+#include <SDL3/SDL_render.h>
 #include <SDL3_ttf/SDL_ttf.h>
 
-namespace resources {
 enum Font {
 	FONT_DEFAULT = 0,
 	FONT_BOLD = 1,
 	FONT_MAX
 };
 
+enum DiceImages {
+	COIN_IMAGE = 0,
+	D4_IMAGE = 1,
+	D6_IMAGE,
+	D8_IMAGE,
+	D10_IMAGE,
+	D12_IMAGE,
+	D20_IMAGE,
+
+	DICE_IMAGE_MAX
+};
+
 extern TTF_TextEngine *textEngine;
 extern TTF_Font *fonts[FONT_MAX];
+extern SDL_Texture *diceImages[DICE_IMAGE_MAX];
+extern SDL_Texture *diceImagesSelected[DICE_IMAGE_MAX];
 
-void LoadResources();
-}
+extern void LoadResources();
+
+extern SDL_Texture *GetDiceImage(enum Dice_Die die, bool selected);
 
 #endif // !RESOURCES_H

src/style.cpp

@@ -1,46 +1,29 @@
 #include "style.h"
-#include "resources.h"
+#include "defs.h"
+#include "dice.h"
 #include <clay/clay.h>
 
-namespace style {
-Clay_ElementDeclaration ListContainer(size_t depth, Clay_ElementDeclaration baseCfg) {
-	baseCfg.border = {
+Clay_ElementDeclaration ListContainer(size_t depth, Clay_ElementDeclaration source) {
+	source.border = (Clay_BorderElementConfig) {
 		PanelBorder(depth),
 		CLAY_BORDER_ALL(2)
 	};
-	baseCfg.cornerRadius = defaultRadiusAll;
-	return baseCfg;
+	source.cornerRadius = defaultRadiusAll;
+	return source;
 }
 
-Clay_ElementDeclaration PanelContainer(size_t depth, Clay_ElementDeclaration baseCfg) {
-	baseCfg.backgroundColor = PanelBackground(depth);
-	baseCfg.border = {
+Clay_ElementDeclaration PanelContainer(size_t depth, Clay_ElementDeclaration source) {
+	source.backgroundColor = PanelBackground(depth);
+	source.border = (Clay_BorderElementConfig) {
 		PanelBorder(depth),
 		CLAY_BORDER_OUTSIDE(2)
 	};
-	baseCfg.cornerRadius = defaultRadiusAll;
-	baseCfg.layout.padding = CLAY_PADDING_ALL(8);
-	return baseCfg;
-}
-
-Clay_ElementDeclaration LeftPanelContainer(size_t depth, Clay_ElementDeclaration baseCfg) {
-	baseCfg = PanelContainer(depth, baseCfg);
-	baseCfg.border.width = { 0, 2, 2, 2, 0 };
-	baseCfg.cornerRadius = { 0, defaultRadius, 0, defaultRadius };
-	baseCfg.layout.sizing.height = CLAY_SIZING_GROW();
-	return baseCfg;
-}
-
-Clay_ElementDeclaration RightPanelContainer(size_t depth, Clay_ElementDeclaration baseCfg) {
-	baseCfg = PanelContainer(depth, baseCfg);
-	baseCfg.border.width = { 2, 0, 2, 2, 0 };
-	baseCfg.cornerRadius = { defaultRadius, 0, defaultRadius, 0 };
-	baseCfg.layout.sizing.height = CLAY_SIZING_GROW();
-	return baseCfg;
+	source.cornerRadius = defaultRadiusAll;
+	return source;
 }
 
 Clay_Color PanelBackground(size_t idx) {
-	return {
+	return (Clay_Color) {
 		255*panelBackground[idx],
 		255*panelBackground[idx],
 		255*panelBackground[idx],
@@ -48,8 +31,20 @@ Clay_Color PanelBackground(size_t idx) {
 	};
 }
 
+Clay_TextElementConfig BodyText(Clay_TextElementConfig base) {
+	base.fontId = FONT_DEFAULT;
+	base.fontSize = baseFontSize;
+	return base;
+}
+
+Clay_TextElementConfig Header(size_t header, Clay_TextElementConfig base) {
+	base.fontId = FONT_BOLD;
+	base.fontSize = headerSizes[(header)-1];
+	return base;
+}
+
 Clay_Color PanelBorder(size_t idx) {
-	return {
+	return (Clay_Color) {
 		255*panelBorder[idx],
 		255*panelBorder[idx],
 		255*panelBorder[idx],
@@ -57,8 +52,8 @@ Clay_Color PanelBorder(size_t idx) {
 	};
 }
 
-Clay_Color TextColor(size_t idx) {
-	return {
+Clay_Color TextColors(size_t idx) {
+	return (Clay_Color) {
 		255*textColorsP[idx],
 		255*textColorsP[idx],
 		255*textColorsP[idx],
@@ -66,17 +61,45 @@ Clay_Color TextColor(size_t idx) {
 	};
 }
 
-Clay_ElementDeclaration Window() {
-	return {
+Clay_Color WindowBackground() {
+	return (Clay_Color) {
+		255*windowBackground,
+		255*windowBackground,
+		255*windowBackground,
+		255
+	};
+}
+
+Clay_ElementDeclaration WindowStyle() {
+	return (Clay_ElementDeclaration) {
 		.layout = {
-			.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() },
-			.padding = CLAY_PADDING_ALL(0),
-			.childGap = 0,
-			.layoutDirection = CLAY_LEFT_TO_RIGHT,
+			.sizing = layoutExpand,
+			.padding = CLAY_PADDING_ALL(windowPadding),
+			.childGap = containerGap,
+			.layoutDirection = CLAY_TOP_TO_BOTTOM,
 		},
+		.backgroundColor = WindowBackground()
 	};
 }
 
+Clay_Color DieColor(enum Dice_Die die) {
+	switch(die) {
+		case COIN: return dieColors[0];
+		case D4: return dieColors[1];
+		case D6: return dieColors[2];
+		case D8: return dieColors[3];
+		case D10: return dieColors[4];
+		case D12: return dieColors[5];
+		case D20: return dieColors[6];
+		case D100: return dieColors[7];
+		default: return (Clay_Color) { 0, 0, 0, 255 };
+	}
+}
+
+Clay_Color DieButtonColor(enum Dice_Die die, bool selected) {
+	return selected ? ToHoveredColor(DieColor(die)) : DieColor(die);
+}
+
 Clay_Color ToHoveredColor(Clay_Color color) {
 	float avg = (color.r + color.g + color.b) / 3.f;
 	color.r = (color.r - avg) * 0.8f + avg - 30;
@@ -84,4 +107,3 @@ Clay_Color ToHoveredColor(Clay_Color color) {
 	color.b = (color.b - avg) * 0.8f + avg - 30;
 	return color;
 }
-}

src/style.h

@@ -1,28 +1,34 @@
 #ifndef STYLE_H
 #define STYLE_H
 
+#include "defs.h"
+#include "resources.h" // needed for macros
 #include <clay/clay.h>
 #include <stdint.h>
 
-namespace style {
 ////////////////////////////////////
 // WINDOW STYLE
 ////////////////////////////////////
 
-constexpr uint16_t windowPadding{ 10 };
+constexpr uint16_t windowPadding = 10;
+constexpr float windowBackground = 0.15f;
 
 ////////////////////////////////////
 // CONTAINER STYLE
 ////////////////////////////////////
 
-constexpr uint16_t containerGap{ 10 };
-constexpr double defaultRadius{ 5.0 };
+constexpr uint16_t containerGap = 10;
+constexpr double defaultRadius = 5.0;
 
 constexpr float panelBackground[] = {
-	.4f, .3f, .2f
+	.2f,
+	.3f,
+	.4f
 };
 constexpr float panelBorder[] = {
-	.5f, .4f, .3f
+	.3f,
+	.4f,
+	.5f
 };
 
 constexpr Clay_Padding panelPadding = {
@@ -30,13 +36,8 @@ constexpr Clay_Padding panelPadding = {
 	24, 24,
 };
 
-Clay_ElementDeclaration ListContainer(size_t depth, Clay_ElementDeclaration baseCfg);
-Clay_ElementDeclaration PanelContainer(size_t depth, Clay_ElementDeclaration baseCfg);
-Clay_ElementDeclaration LeftPanelContainer(size_t depth, Clay_ElementDeclaration baseCfg);
-Clay_ElementDeclaration RightPanelContainer(size_t depth, Clay_ElementDeclaration baseCfg);
-Clay_Color PanelBackground(size_t idx);
-Clay_Color PanelBorder(size_t idx);
-Clay_ElementDeclaration Window();
+extern Clay_ElementDeclaration ListContainer(size_t depth, Clay_ElementDeclaration source);
+extern Clay_ElementDeclaration PanelContainer(size_t depth, Clay_ElementDeclaration source);
 
 ////////////////////////////////////
 // TEXT STYLE
@@ -45,7 +46,9 @@ Clay_ElementDeclaration Window();
 constexpr float paragraphGap = 10;
 constexpr uint16_t baseFontSize = 16;
 constexpr float textColorsP[] = {
-	0.9f, 0.9f, 0.9f
+	0.9f,
+	0.9f,
+	0.9f
 };
 
 constexpr uint16_t headerSizes[] = {
@@ -53,7 +56,8 @@ constexpr uint16_t headerSizes[] = {
 	28, 16
 };
 
-Clay_Color TextColor(size_t idx);
+extern Clay_TextElementConfig BodyText(Clay_TextElementConfig base);
+extern Clay_TextElementConfig Header(size_t header, Clay_TextElementConfig base);
 
 ////////////////////////////////////
 // BUTTONS
@@ -65,10 +69,6 @@ constexpr Clay_Color warningButton = {
 constexpr Clay_Color proceedButton = {
 	49, 181, 99, 255
 };
-constexpr Clay_Color actionButton = {
-	49, 142, 181, 255
-};
-
 constexpr Clay_Padding buttonPadding = {
 	24, 24,
 	4, 4,
@@ -77,7 +77,16 @@ constexpr Clay_CornerRadius buttonRadii = {
 	3, 3, 3, 3
 };
 
-Clay_Color ToHoveredColor(Clay_Color color);
+constexpr Clay_Color dieColors[] = {
+	{ 230, 184, 48, 255 },
+	{ 177, 56, 52, 255 },
+	{ 115, 177, 52, 255 },
+	{ 52, 177, 125, 255 },
+	{ 52, 177, 176, 255 },
+	{ 52, 93, 177, 255 },
+	{ 177, 52, 140, 255 },
+	{ 95, 52, 177, 255 },
+};
 
 ////////////////////////////////////
 // COMPILATIONS
@@ -94,11 +103,13 @@ constexpr Clay_CornerRadius defaultRadiusAll = {
 	defaultRadius, defaultRadius
 };
 
-namespace color {
-constexpr Clay_Color transparent{ 255, 255, 255, 0 };
-constexpr Clay_Color black{ 0, 0, 0, 255 };
-constexpr Clay_Color white{ 255, 255, 255, 255 };
-}
-}
+extern Clay_Color PanelBackground(size_t idx);
+extern Clay_Color PanelBorder(size_t idx);
+extern Clay_Color TextColors(size_t idx);
+extern Clay_Color WindowBackground();
+extern Clay_ElementDeclaration WindowStyle();
+extern Clay_Color DieColor(enum Dice_Die die);
+extern Clay_Color DieButtonColor(enum Dice_Die die, bool selected);
+extern Clay_Color ToHoveredColor(Clay_Color color);
 
 #endif // !STYLE_H

src/thread_pool.cpp

@@ -1,54 +0,0 @@
-#include "thread_pool.h"
-#include <algorithm>
-#include <thread>
-#include <utility>
-
-namespace threading {
-ThreadPool::ThreadPool() {
-	size_t const thread_count{ std::max(std::thread::hardware_concurrency() - 1, 1u) };
-	this->threads.reserve(thread_count);
-	for (size_t i{ 0 }; i < thread_count; ++i) {
-		this->threads.emplace_back(std::bind(&ThreadPool::ThreadFn, this));
-	}
-}
-
-ThreadPool::~ThreadPool() {
-	{ std::scoped_lock lock{ this->lock };
-		this->shutdown = true;
-		this->threadNotifier.notify_all();
-	}
-	for (std::thread &thread : this->threads) {
-		thread.join();
-	}
-}
-
-size_t ThreadPool::GetThreadCount() {
-	return this->threads.size();
-}
-
-void ThreadPool::ScheduleTask(TaskFunc fn) {
-	std::scoped_lock lock{ this->lock };
-	this->taskQueue.emplace(std::move(fn));
-	this->threadNotifier.notify_one();
-}
-
-void ThreadPool::ThreadFn() {
-	TaskFunc function;
-	for(;;) {
-		{ std::unique_lock<std::mutex> lock{ this->lock };
-			while (!this->shutdown && this->taskQueue.empty()) {
-				this->threadNotifier.wait(lock);
-			}
-			if (this->taskQueue.empty()) {
-				return;
-			}
-			function = std::move(this->taskQueue.front());
-			this->taskQueue.pop();
-		}
-
-		function.operator()();
-	}
-}
-
-ThreadPool tasks{};
-}

src/thread_pool.h

@@ -1,30 +0,0 @@
-#ifndef THREAD_POOL_H
-#define THREAD_POOL_H
-
-#include <condition_variable>
-#include <functional>
-#include <mutex>
-#include <queue>
-#include <thread>
-
-namespace threading {
-typedef std::function<void()> TaskFunc;
-
-class ThreadPool {
-public: ThreadPool();
-	~ThreadPool();
-	void ScheduleTask(TaskFunc jobs);
-	size_t GetThreadCount();
-private:
-	void ThreadFn();
-	std::queue<TaskFunc> taskQueue{};
-	std::vector<std::thread> threads{};
-	std::mutex lock{};
-	std::condition_variable threadNotifier{};
-	bool shutdown{ false };
-};
-
-extern ThreadPool tasks;
-}
-
-#endif // !THREAD_POOL_H

src/ui_data.c

@@ -2,10 +2,10 @@
 #include <stdint.h>
 #include <string.h>
 
-const size_t uiDataLength = UI_DATA_SIZE;
+constexpr size_t uiDataLength = UI_DATA_SIZE;
 
 static size_t utilized = 9;
-static char uiDataArena[UI_DATA_SIZE];
+static char uiDataArena[uiDataLength];
 static char *uiDataWriter = uiDataArena;
 
 Clay_String UiData_StoreString(char const *data, size_t amount) {

vendor/SDL3

@@ -1 +0,0 @@
-Subproject commit 137b0b2bee2bb9dd76e2c260970ccf7ff0621692

vendor/SDL3_ttf

@@ -1 +0,0 @@
-Subproject commit 6b6bd588e8646360b08f624fb601cc2ec75c6ada