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