Clay SDL3 Template

Using Template

Just use just

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();
}