feat: setup template

feat: implemented game of life

feat: implemented automatic stepping

fix: operator< Cell Cell now sorts by y first, then x

fix: equalized scroll x/y

fix: removed unused code path

fix: marked simulation::living as static since it's no longer forward
declared

tweak: decreased number of cells on random initialization

feat: defined Toggle element

feat: added debug information toggle to UI

feat: implemented simulation multithreading

feat: improved simulation frame delta controls

feat: inverted direction of panel colours

fix: removed leftover die colors

feat: reorganized and cleaned up style namespace

chore: increased button border width

feat: added SDL3 submodule

feat: added SDL3_ttf submodule

feat: moved clay to vendor (rather than include)

feat: replaced premake5 with CMake to vendor SDL3

chore: translated more C stuff to C++ in main.cpp

fix: stepping being inconsistent while running

feat: fixed incorrect behaviour on simulation and added benchmarking
code

feat: minor adjustments to UI layout

feat: increased thread count for pool

feat: improved simulation benchmarking

feat: simulation tasks can now be subdivided into separate workloads for
separate threads

feat: improved task counting thread safety

chore: massively increased random field

fix: target delta time is now enforced

feat: added toggle for locked framerate

fix: replaced manual .lock()/.unlock() calls with std::scoped_lock

fix: benchmarking code was off by a magnitude of 1

feat: separated cell state checking into separate function in case
another algo is faster than .contains

chore: some comments on variables in simulation.cpp

feat: set task split to hardware_concurrency()

feat: added basic culling to cell renderer

feat: implemented simulation threading toggle

chore: lowered random button's field size

chore: reduced padding on panel containers

chore: minor formatting adjustment

feat: added README.md

fix: inverted x scroll

feat: converted project to template

feat: added .clangd

src/application.cpp

@@ -0,0 +1,28 @@
+#include "application.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();
+		}
+	}
+	return Clay_EndLayout();
+}
+
+void HandleEvent(SDL_Event event) {
+}
+}

src/application.h

@@ -0,0 +1,12 @@
+#ifndef APPLICATION_H
+#define APPLICATION_H
+
+#include <clay/clay.h>
+#include <SDL3/SDL_events.h>
+
+namespace application {
+Clay_RenderCommandArray RenderApplication();
+void HandleEvent(SDL_Event event);
+}
+
+#endif // !APPLICATION_H

src/elements.cpp

@@ -0,0 +1,84 @@
+#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_AUTO_ID({
+		.layout = {
+			.padding = style::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)
+		},
+	}) {
+		Clay_OnHover(onHovered, onHoveredData);
+		elements::Body(text, {
+			.textColor = style::TextColor(0),
+			.textAlignment = CLAY_TEXT_ALIGN_CENTER,
+		});
+	}
+}
+
+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

@@ -0,0 +1,14 @@
+#ifndef ELEMENTS_H
+#define ELEMENTS_H
+
+#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 = {});
+}
+
+#endif // !ELEMENTS_H

src/input.cpp

@@ -0,0 +1,39 @@
+#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

@@ -0,0 +1,15 @@
+#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

@@ -0,0 +1,144 @@
+#define SDL_MAIN_HANDLED
+
+#include "application.h"
+#include "input.h"
+#include "resources.h"
+#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>
+#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
+};
+
+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() {
+	int w, h;
+	SDL_GetCurrentRenderOutputSize(renderer, &w, &h);
+	SDL_Log("output size: %i, %d", w, h);
+}
+
+static inline
+void InitSDL() {
+	SDL_SetHint(SDL_HINT_RENDER_LINE_METHOD, "3");
+	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) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "SDL_CreateWindow failed: %s", SDL_GetError());
+		exit(2);
+	}
+	if ((renderer = SDL_CreateRenderer(window, NULL)) == nullptr) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "SDL_CreateRenderer failed: %s", SDL_GetError());
+		exit(3);
+	}
+	if (!TTF_Init()) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "TTF_Init failed: %s", SDL_GetError());
+		exit(4);
+	}
+	if ((resources::textEngine = TTF_CreateRendererTextEngine(renderer)) == nullptr) {
+		SDL_LogError(SDL_LOG_CATEGORY_ERROR, "TTF_CreateRendererTextEngine failed: %s", SDL_GetError());
+		exit(5);
+	}
+}
+
+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 };
+	SDL_GetMouseState(&x, &y);
+	Clay_SetPointerState((Clay_Vector2) { x, y }, false);
+}
+
+int main(int argc, char *argv[]) {
+	InitSDL();
+	resources::LoadResources();
+	LogOutputResolution();
+	InitClay();
+	backendData = { renderer, resources::textEngine, resources::fonts };
+	SDL_Event event;
+	uint64_t startFrameTime = SDL_GetTicksNS();
+	double deltaTime = 0.0;
+	while (running) {
+		std::srand(SDL_GetTicksNS());
+		deltaTime = SDL_GetTicksNS() - startFrameTime;
+		startFrameTime = SDL_GetTicksNS();
+		UiData_Clear();
+		input::FrameStart();
+		while (SDL_PollEvent(&event)) {
+			application::HandleEvent(event);
+			input::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
+					});
+					LogOutputResolution();
+					break;
+				default: break;
+			}
+		}
+		Clay_UpdateScrollContainers(true, input::scrollMotion, deltaTime);
+		SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+		SDL_RenderClear(renderer);
+		Clay_RenderCommandArray commands{ application::RenderApplication() };
+		SDL_Clay_RenderClayCommands(&backendData, &commands);
+		SDL_RenderPresent(renderer);
+		SDL_Delay(10);
+	}
+	SDL_DestroyRenderer(renderer);
+	SDL_DestroyWindow(window);
+	SDL_Quit();
+	return 0;
+}

src/resources.cpp

@@ -0,0 +1,32 @@
+#include "resources.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];
+TTF_TextEngine *textEngine = nullptr;
+
+static inline void LoadFonts() {
+	fonts[FONT_DEFAULT] = TTF_OpenFont("assets/AdwaitaSans-Regular.ttf", style::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);
+	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");
+}
+
+void LoadResources() {
+	LoadFonts();
+}
+}

src/resources.h

@@ -0,0 +1,19 @@
+#ifndef RESOURCES_H
+#define RESOURCES_H
+
+#include <SDL3_ttf/SDL_ttf.h>
+
+namespace resources {
+enum Font {
+	FONT_DEFAULT = 0,
+	FONT_BOLD = 1,
+	FONT_MAX
+};
+
+extern TTF_TextEngine *textEngine;
+extern TTF_Font *fonts[FONT_MAX];
+
+void LoadResources();
+}
+
+#endif // !RESOURCES_H

src/style.cpp

@@ -0,0 +1,87 @@
+#include "style.h"
+#include "resources.h"
+#include <clay/clay.h>
+
+namespace style {
+Clay_ElementDeclaration ListContainer(size_t depth, Clay_ElementDeclaration baseCfg) {
+	baseCfg.border = {
+		PanelBorder(depth),
+		CLAY_BORDER_ALL(2)
+	};
+	baseCfg.cornerRadius = defaultRadiusAll;
+	return baseCfg;
+}
+
+Clay_ElementDeclaration PanelContainer(size_t depth, Clay_ElementDeclaration baseCfg) {
+	baseCfg.backgroundColor = PanelBackground(depth);
+	baseCfg.border = {
+		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;
+}
+
+Clay_Color PanelBackground(size_t idx) {
+	return {
+		255*panelBackground[idx],
+		255*panelBackground[idx],
+		255*panelBackground[idx],
+		255
+	};
+}
+
+Clay_Color PanelBorder(size_t idx) {
+	return {
+		255*panelBorder[idx],
+		255*panelBorder[idx],
+		255*panelBorder[idx],
+		255
+	};
+}
+
+Clay_Color TextColor(size_t idx) {
+	return {
+		255*textColorsP[idx],
+		255*textColorsP[idx],
+		255*textColorsP[idx],
+		255
+	};
+}
+
+Clay_ElementDeclaration Window() {
+	return {
+		.layout = {
+			.sizing = { CLAY_SIZING_GROW(), CLAY_SIZING_GROW() },
+			.padding = CLAY_PADDING_ALL(0),
+			.childGap = 0,
+			.layoutDirection = CLAY_LEFT_TO_RIGHT,
+		},
+	};
+}
+
+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;
+	color.g = (color.g - avg) * 0.8f + avg - 30;
+	color.b = (color.b - avg) * 0.8f + avg - 30;
+	return color;
+}
+}

src/style.h

@@ -0,0 +1,104 @@
+#ifndef STYLE_H
+#define STYLE_H
+
+#include <clay/clay.h>
+#include <stdint.h>
+
+namespace style {
+////////////////////////////////////
+// WINDOW STYLE
+////////////////////////////////////
+
+constexpr uint16_t windowPadding{ 10 };
+
+////////////////////////////////////
+// CONTAINER STYLE
+////////////////////////////////////
+
+constexpr uint16_t containerGap{ 10 };
+constexpr double defaultRadius{ 5.0 };
+
+constexpr float panelBackground[] = {
+	.4f, .3f, .2f
+};
+constexpr float panelBorder[] = {
+	.5f, .4f, .3f
+};
+
+constexpr Clay_Padding panelPadding = {
+	24, 24,
+	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();
+
+////////////////////////////////////
+// TEXT STYLE
+////////////////////////////////////
+
+constexpr float paragraphGap = 10;
+constexpr uint16_t baseFontSize = 16;
+constexpr float textColorsP[] = {
+	0.9f, 0.9f, 0.9f
+};
+
+constexpr uint16_t headerSizes[] = {
+	64, 32,
+	28, 16
+};
+
+Clay_Color TextColor(size_t idx);
+
+////////////////////////////////////
+// BUTTONS
+////////////////////////////////////
+
+constexpr Clay_Color warningButton = {
+	177, 56, 52, 255
+};
+constexpr Clay_Color proceedButton = {
+	49, 181, 99, 255
+};
+constexpr Clay_Color actionButton = {
+	49, 142, 181, 255
+};
+
+constexpr Clay_Padding buttonPadding = {
+	24, 24,
+	4, 4,
+};
+constexpr Clay_CornerRadius buttonRadii = {
+	3, 3, 3, 3
+};
+
+Clay_Color ToHoveredColor(Clay_Color color);
+
+////////////////////////////////////
+// COMPILATIONS
+// | Functions and expressions that combine styling data from the settings above.
+////////////////////////////////////
+
+constexpr Clay_Sizing layoutExpand = {
+	.width = CLAY_SIZING_GROW(0),
+	.height = CLAY_SIZING_GROW(0)
+};
+
+constexpr Clay_CornerRadius defaultRadiusAll = {
+	defaultRadius, defaultRadius,
+	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 };
+}
+}
+
+#endif // !STYLE_H

src/thread_pool.cpp

@@ -0,0 +1,54 @@
+#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

@@ -0,0 +1,30 @@
+#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