add ignore

Added some new maths types
Updated shaders to use new D_Rect structure
Added rect buffers to frames
Misc cleanup

.gitignore

@@ -1,3 +1,4 @@
 build/
 code/compile_commands.json
 code/.cache
+.vscode

code/.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug 'main.c' Project",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/../build/ldebug",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ],
+            "preLaunchTask": "Build" 
+        }
+    ]
+}

code/.vscode/tasks.json

@@ -0,0 +1,20 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Build",
+            "type": "shell",
+            "command": "/home/matt/Repos/ld58/linux",
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "presentation": {
+                "reveal": "never"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ]
+        }
+    ]
+}

code/core/arena.h

@@ -1,7 +1,7 @@
 #if !defined(LD_CORE_ARENA_H_)
 #define LD_CORE_ARENA_H_
 
-#define AlignUp(x, a) (((x) + ~((a) - 1)) & ~((a) - 1))
+#define AlignUp(x, a) (((x) + ((a) - 1)) & ~((a) - 1))
 #define AlignDown(x, a) (((x)) & ~((a) - 1))
 
 #define KB(x) ((U64) (x) << 10)
@@ -64,8 +64,8 @@ function void    *_M_ArenaPush(M_Arena *arena, U64 esize, M_ArenaPushOpts *opts)
 function void    *_M_ArenaPushCopy(M_Arena *arena, void *src, U64 esize, M_ArenaPushOpts *opts);
 
 #define M_ArenaAlloc(limit, ...) _M_ArenaAlloc(limit, &(M_ArenaOpts) { .initial = MB(1), .increment = KB(64), ##__VA_ARGS__ })
-#define M_ArenaPush(arena, T, ...) (T *) _M_ArenaPush(arena, sizeof(T), &(M_ArenaOpts) { .count = 1, .align = Alignof(T), ##__VA_ARGS__ })
+#define M_ArenaPush(arena, T, ...) (T *) _M_ArenaPush(arena, sizeof(T), &(M_ArenaPushOpts) { .count = 1, .align = Alignof(T), ##__VA_ARGS__ })
-#define M_ArenaPushCopy(arena, T, src, ...) (T *) _M_ArenaPush(arena, src, sizeof(T), &(M_ArenaOpts) { .count = 1, .align = Alignof(T), ##__VA_ARGS__ })
+#define M_ArenaPushCopy(arena, T, src, ...) (T *) _M_ArenaPush(arena, src, sizeof(T), &(M_ArenaPushOpts) { .count = 1, .align = Alignof(T), ##__VA_ARGS__ })
 
 function void M_ArenaReset(M_Arena *arena);
 function void M_ArenaRelease(M_Arena *arena);

code/core/core.c

@@ -1 +1,3 @@
 #include "impl/arena.c"
+#include "impl/string.c"
+#include "impl/math.c"

code/core/core.h

@@ -5,5 +5,7 @@
 #include "platform.h"
 #include "macros.h"
 #include "arena.h"
+#include "string.h"
+#include "math.h"
 
 #endif  // LD_CORE_CORE_H_

code/core/impl/math.c

@@ -0,0 +1,163 @@
+V2f V2F(F32 x, F32 y) {
+	V2f result = { x, y };
+	return result;
+}
+
+V3f V3F(F32 x, F32 y, F32 z) {
+	V3f result = { x, y, z };
+	return result;
+}
+
+V4f V4F(F32 x, F32 y, F32 z, F32 w) {
+	V4f result = { x, y, z, w };
+	return result;
+}
+
+R2f R2F(V2f min, V2f max) {
+	R2f result = { min, max };
+	return result;
+}
+
+V3f V3f_Neg(V3f x) {
+	V3f result = { -x.x, -x.y, -x.z };
+	return result;
+}
+
+V3f V3f_Scale(V3f x, F32 s) {
+	V3f result = { s * x.x, s * x.y, s * x.z };
+	return result;
+}
+
+F32 V3f_Dot(V3f a, V3f b) {
+	F32 result = (a.x * b.x) + (a.y * b.y) + (a.z * b.z);
+	return result;
+}
+
+F32 V4f_Dot(V4f a, V4f b) {
+	F32 result = (a.x * b.x) + (a.y * b.y) + (a.z * b.z) + (a.w * b.w);
+	return result;
+}
+
+Mat4x4F M4x4F_Rows(V3f x, V3f y, V3f z) {
+	Mat4x4F result = {
+		x.x, x.y, x.z, 0,
+		y.x, y.y, y.z, 0,
+		z.x, z.y, z.z, 0,
+		0,   0,   0,   1
+	};
+
+	return result;
+}
+
+Mat4x4F M4x4F_Columns(V3f x, V3f y, V3f z) {
+	Mat4x4F result = {
+		x.x, y.x, z.x, 0,
+		x.y, y.y, z.y, 0,
+		x.z, y.z, z.z, 0,
+		0,   0,   0,   1
+	};
+
+	return result;
+}
+
+Mat4x4F M4x4F_Mul(Mat4x4F a, Mat4x4F b) {
+	Mat4x4F result;
+
+	for (U32 r = 0; r < 4; ++r) {
+		for (U32 c = 0; c < 4; ++c) {
+			result.m[r][c] =
+				(a.m[r][0] * b.m[0][c]) + (a.m[r][1] * b.m[1][c]) +
+				(a.m[r][2] * b.m[2][c]) + (a.m[r][3] * b.m[3][c]);
+		}
+	}
+
+	return result;
+}
+
+V4f M4x4F_VMul4(Mat4x4F m, V4f v) {
+	V4f result;
+	result.x = V4f_Dot(m.r[0], v);
+	result.y = V4f_Dot(m.r[1], v);
+	result.z = V4f_Dot(m.r[2], v);
+	result.w = V4f_Dot(m.r[3], v);
+
+	return result;
+}
+
+V3f M4x4F_VMul3(Mat4x4F m, V3f v) {
+	V4f tx;
+	tx.xyz = v;
+	tx.w   = 1.0f;
+
+	V3f result = M4x4F_VMul4(m, tx).xyz;
+	return result;
+}
+
+Mat4x4FInv M4x4F_Perspective(F32 fov, F32 aspect, F32 nearp, F32 farp) {
+	F32 focal_length = 1.0f / tanf(0.5f * (PI_F32 * (fov / 360.0f)));
+
+	F32 a = focal_length;
+	F32 b = focal_length * aspect;
+
+	F32 c = -(nearp + farp) / (farp - nearp);
+	F32 d = -(2.0f * nearp * farp) / (farp - nearp);
+
+	Mat4x4FInv result = {
+		// fwd
+		{
+			a, 0,  0, 0,
+			0, b,  0, 0,
+			0, 0,  c, d,
+			0, 0, -1, 0
+		},
+		// inv
+		{
+			(1 / a),  0,       0,      0,
+			0,       (1 / b),  0,      0,
+			0,        0,       0,     -1,
+			0,        0,      (1/ d), (c / d)
+		}
+	};
+
+	return result;
+}
+
+Mat4x4FInv M4x4F_CameraView(V3f x, V3f y, V3f z, V3f p) {
+	Mat4x4FInv result;
+
+	// Construct orthonomal basis from axes
+	//
+	result.fwd = M4x4F_Rows(x, y, z);
+	V3f txp    = V3f_Neg(M4x4F_VMul3(result.fwd, p));
+
+	// Translate by txp
+	//
+	result.fwd.r[0].w += txp.x;
+	result.fwd.r[1].w += txp.y;
+	result.fwd.r[2].w += txp.z;
+
+	// Calculate inverse axes
+	//
+	V3f ix = V3f_Scale(x, 1.0f / V3f_Dot(x, x));
+	V3f iy = V3f_Scale(y, 1.0f / V3f_Dot(y, y));
+	V3f iz = V3f_Scale(z, 1.0f / V3f_Dot(z, y));
+
+	// Calculate inverse position
+	//
+	V3f ip;
+	ip.x = (txp.x * ix.x) + (txp.y * iy.x) + (txp.z * iz.x);
+	ip.y = (txp.x * ix.y) + (txp.y * iy.y) + (txp.z * iz.y);
+	ip.z = (txp.x * ix.z) + (txp.y * iy.z) + (txp.z * iz.z);
+
+	result.inv = M4x4F_Columns(ix, iy, iz);
+
+	// Translate by ip
+	//
+	result.inv.r[0].w -= ip.x;
+	result.inv.r[1].w -= ip.y;
+	result.inv.r[2].w -= ip.z;
+
+	return result;
+}
+
+

code/core/impl/string.c

@@ -0,0 +1,150 @@
+Str8 Str8_Wrap(S64 count, U8 *data) {
+	Str8 result;
+	result.data  = data;
+	result.count = count;
+
+	return result;
+}
+
+Str8 Str8_WrapRange(U8 *start, U8 *end) {
+	Str8 result;
+	result.data  = start;
+	result.count = cast(S64) (end - start);
+
+	return result;
+}
+
+internal S64 Str8_CountZ(U8 *data) {
+	S64 result = 0;
+	while (data[result] != 0) { result += 1; }
+
+	return result;
+}
+
+Str8 Str8_WrapZ(U8 *data) {
+	Str8 result;
+	result.data  = data;
+	result.count = Str8_CountZ(data);
+
+	return result;
+}
+
+Str8 Str8_Copy(M_Arena *arena, Str8 s) {
+	Str8 result;
+	result.count = s.count;
+	result.data  = M_ArenaPush(arena, U8, .count = s.count + 1);
+
+	M_CopySize(result.data, s.data, s.count);
+	return result;
+}
+
+Str8 Str8_Format(M_Arena *arena, const char *format, ...) {
+	va_list args;
+	va_start(args, format);
+
+	Str8 result = Str8_FormatArgs(arena, format, args);
+	va_end(args);
+
+	return result;
+}
+
+internal S64 Str8_ProcessFormat(Str8 out, const char *format, va_list args) {
+	S64 result = vsnprintf((char *) out.data, (int) out.count, format, args);
+	return result;
+}
+
+Str8 Str8_FormatArgs(M_Arena *arena, const char *format, va_list args) {
+	Str8 result;
+
+	va_list copy;
+	va_copy(copy, args);
+
+	U64 offset = M_ArenaOffset(arena);
+
+	result.count = KB(1);
+	result.data  = M_ArenaPush(arena, U8, .count = result.count);
+
+	S64 needed = Str8_ProcessFormat(result, format, args);
+	if (needed >= result.count) {
+		M_ArenaPop(arena, offset);
+
+		result.count = needed;
+		result.data  = M_ArenaPush(arena, U8, .count = result.count + 1);
+
+		Str8_ProcessFormat(result, format, copy);
+	}
+	else {
+		U64 size = result.count - needed - 1;
+		M_ArenaPopSize(arena, size);
+
+		result.count = needed;
+	}
+
+	return result;
+}
+
+B32 Str8_Equal(Str8 a, Str8 b, Str8_EqualFlags flags) {
+	B32 result = (a.count == b.count);
+
+	if (result) {
+		B32 ignore_case = (flags & STR8_EQUAL_IGNORE_CASE) != 0;
+
+		for (S64 it = 0; it < a.count; ++it) {
+			U8 ac = ignore_case ? Chr_ToLowercase(a.data[it]) : a.data[it];
+			U8 bc = ignore_case ? Chr_ToLowercase(b.data[it]) : b.data[it];
+
+			if (ac != bc) {
+				result = false;
+				break;
+			}
+		}
+	}
+
+	return result;
+}
+
+Str8 Str8_Prefix(Str8 s, S64 count) {
+	Str8 result;
+	result.data  = s.data;
+	result.count = Min(s.count, count);
+
+	return result;
+}
+
+Str8 Str8_Suffix(Str8 s, S64 count) {
+	Str8 result;
+	result.count = Min(s.count, count);
+	result.data  = s.data + (s.count - result.count);
+
+	return result;
+}
+
+Str8 Str8_RemoveAfterLast(Str8 s, U8 c) {
+	Str8 result;
+	result.data  = s.data;
+	result.count = s.count;
+
+	for (S64 it = s.count - 1; it >= 0; --it) {
+		if (result.data[it] == c) {
+			result.count = it;
+			break;
+		}
+	}
+
+	return result;
+}
+
+B32 Str8_EndsWith(Str8 s, Str8 suffix) {
+	B32 result = Str8_Equal(Str8_Suffix(s, suffix.count), suffix, 0);
+	return result;
+}
+
+U8 Chr_ToUppercase(U8 c) {
+	U8 result = (c >= 'a' && c <= 'z') ? (c - ('a' - 'A')) : c;
+	return result;
+}
+
+U8 Chr_ToLowercase(U8 c) {
+	U8 result = (c >= 'A' && c <= 'Z') ? (c + ('a' - 'A')) : c;
+	return result;
+}

code/core/macros.h

@@ -4,6 +4,7 @@
 #include <assert.h>
 
 #define Assert(exp) assert(exp)
+#define StaticAssert(exp) static_assert(exp, #exp)
 
 #define ArraySize(x) (sizeof(x) / sizeof((x)[0]))
 #define Min(a, b) ((a) < (b) ? (a) : (b))
@@ -34,6 +35,8 @@
 #define SLL_PushN(h, n, next) ((n)->next = (h), (h) = (n))
 #define SLL_PopN(h, next) (((h) != 0) ? (h) = (h)->next : 0)
 
+#define SLL_Enqueue(h, t, n) SLL_EnqueueN(h, t, n, next)
+
 #define function      static
 #define internal      static
 #define global_var    static

code/core/math.h

@@ -0,0 +1,117 @@
+#if !defined(LD_CORE_MATH_H_)
+#define LD_CORE_MATH_H_
+
+#define PI_F32  (3.14159265358979323846264338f)
+#define TAU_F32 (2.0f * PI_F32)
+
+typedef union V2f V2f;
+union V2f {
+	struct {
+		F32 x, y;
+	};
+
+	struct {
+		F32 u, v;
+	};
+
+	struct {
+		F32 w, h;
+	};
+
+	F32 e[2];
+};
+
+typedef union V2i V2i;
+union V2i {
+	struct {
+		U32 x, y;
+	};
+
+	struct {
+		U32 w, h;
+	};
+
+	U32 e[2];
+};
+
+typedef union V3f V3f;
+union V3f {
+	struct {
+		F32 x, y, z;
+	};
+
+	struct {
+		F32 r, g, b;
+	};
+
+	struct {
+		F32 w, h, d;
+	};
+
+	struct {
+		V2f xy;
+		F32 _z;
+	};
+
+	F32 e[3];
+};
+
+typedef union V4f V4f;
+union V4f {
+	struct {
+		F32 x, y, z, w;
+	};
+
+	struct {
+		F32 r, g, b, a;
+	};
+
+	struct {
+		V3f xyz;
+		F32 _w;
+	};
+
+	F32 e[4];
+};
+
+typedef union Mat4x4F Mat4x4F;
+union Mat4x4F {
+	F32 m[4][4];
+	F32 e[16];
+	V4f r[4];
+};
+
+typedef struct Mat4x4FInv Mat4x4FInv;
+struct Mat4x4FInv {
+	Mat4x4F fwd;
+	Mat4x4F inv;
+};
+
+typedef struct R2f R2f;
+struct R2f {
+	V2f min;
+	V2f max;
+};
+
+function V2f V2F(F32 x, F32 y);
+function V3f V3F(F32 x, F32 y, F32 z);
+function V4f V4F(F32 x, F32 y, F32 z, F32 w);
+
+function R2f R2F(V2f min, V2f max);
+
+function V3f V3f_Neg(V3f x);
+function V3f V3f_Scale(V3f x, F32 s);
+
+function F32 V3f_Dot(V3f a, V3f b);
+function F32 V4f_Dot(V4f a, V4f b);
+
+function Mat4x4F M4x4F_Rows(V3f x, V3f y, V3f z);
+function Mat4x4F M4x4F_Columns(V3f x, V3f y, V3f z);
+
+function V4f M4x4F_VMul4(Mat4x4F m, V4f v);
+function V3f M4x4F_VMul3(Mat4x4F m, V3f v);
+
+function Mat4x4FInv M4x4F_Perspective(F32 fov, F32 aspect, F32 nearp, F32 farp);
+function Mat4x4FInv M4x4F_CameraView(V3f x, V3f y, V3f z, V3f p);
+
+#endif  // LD_CORE_MATH_H_

code/core/platform.h

@@ -68,9 +68,17 @@
 #if OS_WINDOWS
 	#define WIN32_LEAN_AND_MEAN 1
 	#include <windows.h>
+	#include <shlobj_core.h>
 	#pragma warning(disable : 4201)
 #elif OS_LINUX
+	#include <sys/types.h>
 	#include <dlfcn.h>
+	#include <sys/mman.h>
+	#include <unistd.h>
+	#include <fcntl.h>
+	#include <sys/stat.h>
+	#include <errno.h>
+	#include <dirent.h>
 #endif
 
 #endif  // LD_CORE_PLATFORM_H_

code/core/string.h

@@ -0,0 +1,36 @@
+#if !defined(LD_CORE_STRING_H_)
+#define LD_CORE_STRING_H_
+
+#define S(x) Str8_Wrap(sizeof(x) - sizeof(*(x)), (U8 *) (x))
+#define Sz(x) Str8_WrapZ((U8 *) (x))
+
+#define Sv(x) (int) (x).count, (x).data
+#define Sf(arena, fmt, ...) Str8_Format(arena, fmt, ##__VA_ARGS__)
+
+function Str8 Str8_Wrap(S64 count, U8 *data);
+function Str8 Str8_WrapRange(U8 *start, U8 *end);
+function Str8 Str8_WrapZ(U8 *data);
+
+function Str8 Str8_Copy(M_Arena *arena, Str8 s);
+
+function Str8 Str8_Format(M_Arena *arena, const char *format, ...);
+function Str8 Str8_FormatArgs(M_Arena *arena, const char *format, va_list args);
+
+typedef U32 Str8_EqualFlags;
+enum {
+	STR8_EQUAL_IGNORE_CASE = (1 << 0)
+};
+
+function B32 Str8_Equal(Str8 a, Str8 b, Str8_EqualFlags flags);
+
+function Str8 Str8_Prefix(Str8 s, S64 count);
+function Str8 Str8_Suffix(Str8 s, S64 count);
+
+function Str8 Str8_RemoveAfterLast(Str8 s, U8 c);
+
+function B32 Str8_EndsWith(Str8 s, Str8 suffix);
+
+function U8 Chr_ToUppercase(U8 c);
+function U8 Chr_ToLowercase(U8 c);
+
+#endif  // LD_CORE_STRING_H_

code/core/types.h

@@ -29,4 +29,9 @@ struct Str8 {
 	U8 *data;
 };
 
+#define U8_MAX  ((U8)  -1)
+#define U16_MAX ((U16) -1)
+#define U32_MAX ((U32) -1)
+#define U64_MAX ((U64) -1)
+
 #endif  // LD_CORE_TYPES_H_

code/draw/core.c

@@ -0,0 +1,132 @@
+void D_Begin(D_Context *draw, Vk_Frame *frame, U32 max_rects) {
+	Vk_Buffer *rbo   = &frame->rbo;
+
+	draw->rbo       = rbo;
+	draw->n_rects   = 0;
+	draw->max_rects = max_rects;
+	draw->rects     = rbo->data;
+}
+
+void D_End(D_Context *draw, Vk_Frame *frame) {
+	VkCommandBuffer cmd = frame->cmd;
+	Vk_Pipeline *basic  = &draw->pipelines[0];
+
+	// We can probably stop doing this at some point
+	VkDescriptorSet set;
+	VkDescriptorSetAllocateInfo alloc_info = { 0 };
+	alloc_info.sType              = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+	alloc_info.descriptorPool     = frame->descriptors;
+	alloc_info.descriptorSetCount = 1;
+	alloc_info.pSetLayouts        = &basic->layout.set;
+
+	vk.AllocateDescriptorSets(vk.device, &alloc_info, &set);
+
+	// 'update' the descriptor sets for binding
+	M_TempScope(0, 0) {
+		VkWriteDescriptorSet writes[2] = { 0 };
+
+		VkDescriptorBufferInfo rbo_info = { 0 };
+		rbo_info.buffer = draw->rbo->handle;
+		rbo_info.offset = 0;
+		rbo_info.range  = VK_WHOLE_SIZE;
+
+		VkDescriptorImageInfo *image_info = M_ArenaPush(temp.arena, VkDescriptorImageInfo, .count = draw->n_images);
+
+		for (U32 it = 0; it < draw->n_images; ++it) {
+			image_info[it].imageView   = draw->images[it].image.view;
+			image_info[it].sampler     = vk.sampler;
+			image_info[it].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+		}
+
+		writes[0].sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		writes[0].dstSet          = set;
+		writes[0].dstBinding      = 0;
+		writes[0].descriptorCount = 1;
+		writes[0].descriptorType  = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+		writes[0].pBufferInfo     = &rbo_info;
+
+		writes[1].sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+		writes[1].dstSet          = set;
+		writes[1].dstBinding      = 1;
+		writes[1].descriptorCount = draw->n_images;
+		writes[1].descriptorType  = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+		writes[1].pImageInfo      = image_info;
+
+		vk.UpdateDescriptorSets(vk.device, ArraySize(writes), writes, 0, 0);
+	}
+
+	vk.CmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, basic->handle);
+	vk.CmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, basic->layout.pipeline, 0, 1, &set, 0, 0);
+	vk.CmdPushConstants(cmd, basic->layout.pipeline, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(Mat4x4F), &draw->camera->proj.fwd);
+
+	VkViewport viewport = { 0, 0, (F32) draw->window_width, (F32) draw->window_height, 0.0f, 1.0f };
+	VkRect2D   scissor  = { 0, 0, draw->window_width, draw->window_height };
+
+	vk.CmdSetViewport(cmd, 0, 1, &viewport);
+	vk.CmdSetScissor(cmd, 0, 1, &scissor);
+
+	vk.CmdDraw(cmd, 6, draw->n_rects, 0, 0);
+}
+
+internal U32 V4f_UnormColour(V4f c) {
+	// @Todo: SRGB handling
+	U32 result =
+		((U8) (255.0f * c.a)) << 24 |
+		((U8) (255.0f * c.r)) << 16 |
+		((U8) (255.0f * c.g)) <<  8 |
+		((U8) (255.0f * c.b)) <<  0;
+
+	return result;
+}
+
+void _D_Rect(D_Context *draw, D_RectOpts *opts) {
+	if (draw->n_rects < draw->max_rects) {
+		D_Rect *rect = &draw->rects[draw->n_rects];
+
+		rect->texture = opts->texture;
+
+		rect->x = opts->p.x;
+		rect->y = opts->p.y;
+
+		rect->uv[0] = opts->uv.min.x;
+		rect->uv[1] = opts->uv.min.y;
+		rect->uv[2] = opts->uv.max.x;
+		rect->uv[3] = opts->uv.max.y;
+
+		rect->angle = opts->angle;
+
+		if (opts->flags & D_RECT_PER_VERTEX_COLOUR) {
+			rect->c[0] = V4f_UnormColour(opts->vtxc[0]);
+			rect->c[1] = V4f_UnormColour(opts->vtxc[1]);
+			rect->c[2] = V4f_UnormColour(opts->vtxc[2]);
+			rect->c[3] = V4f_UnormColour(opts->vtxc[3]);
+		}
+		else {
+			U32 unorm = V4f_UnormColour(opts->c);
+
+			rect->c[0] = unorm;
+			rect->c[1] = unorm;
+			rect->c[2] = unorm;
+			rect->c[3] = unorm;
+		}
+
+		if (opts->flags & D_RECT_IGNORE_ASPECT) {
+			rect->w = opts->w;
+			rect->h = opts->h;
+		}
+		else {
+			Vk_Image *image = &draw->images[opts->texture].image;
+
+			if (image->width > image->height) {
+				rect->w = opts->scale * ((F32) image->width / (F32) image->height);
+				rect->h = opts->scale;
+			}
+			else {
+				rect->w = opts->scale;
+				rect->h = opts->scale * ((F32) image->height / (F32) image->width);
+			}
+		}
+
+		draw->n_rects += 1;
+	}
+}

code/draw/core.h

@@ -0,0 +1,85 @@
+#if !defined(LD_DRAW_CORE_H_)
+#define LD_DRAW_CORE_H_
+
+#define D_MAX_RECTS 1024
+
+typedef struct D_Image D_Image;
+struct D_Image {
+	Str8     name;
+	Vk_Image image;
+};
+
+typedef struct D_Rect D_Rect;
+struct D_Rect {
+	U32 texture;
+
+	U32  c[4]; // per-vertex colours
+	F32 uv[4];
+
+	F32 angle;
+	F32 x, y;
+	F32 w, h;
+
+	U32 p0, p1;
+};
+
+StaticAssert(sizeof(D_Rect) == 64);
+
+struct G_Camera;
+
+typedef struct D_Context D_Context;
+struct D_Context {
+	Vk_Buffer *rbo;
+
+	U32 n_pipelines;
+	Vk_Pipeline *pipelines;
+
+	U32 n_images;
+	D_Image *images;
+
+	U32 max_rects;
+	U32 n_rects;
+	D_Rect *rects;
+
+	U32 window_width;
+	U32 window_height;
+
+	struct G_Camera *camera;
+};
+
+typedef U32 D_RectFlags;
+enum D_RectFlags {
+	D_RECT_IGNORE_ASPECT     = (1 << 0), // by default only width is used as a "dimension"
+	D_RECT_PER_VERTEX_COLOUR = (1 << 1), // split colours per vertex
+};
+
+typedef struct D_RectOpts D_RectOpts;
+struct D_RectOpts {
+	D_RectFlags flags;
+
+	U32 texture;
+
+	R2f uv;
+	V2f p;
+
+	F32 angle;
+
+	union {
+		F32 w, h;
+		F32 scale, _h;
+		V2f dim;
+	};
+
+	union {
+		V4f c;
+		V4f vtxc[4];
+	};
+};
+
+function void D_Begin(D_Context *draw, Vk_Frame *frame, U32 max_rects);
+function void D_End(D_Context *draw, Vk_Frame *frame);
+
+function void _D_Rect(D_Context *draw, D_RectOpts *opts);
+#define D_Rect(draw, x, y, ...) _D_Rect(draw, &(D_RectOpts) { .p = V2F(x, y), .uv = R2F(V2F(0, 0), V2F(1, 1)), .scale = 1, .c = V4F(1, 1, 1, 1), ##__VA_ARGS__ })
+
+#endif  // LD_DRAW_CORE_H_

code/first.c

@@ -2,108 +2,154 @@
 #include <stdbool.h>
 #include <SDL3/SDL.h>
 
+#define STB_IMAGE_IMPLEMENTATION 1
+#include <stb_image.h>
+
 #include "core/core.h"
+#include "core/types.h"
+#include "game/npc.h"
 #include "os/core.h"
 
 #include "vulkan/core.h"
+#include "draw/core.h"
 
-int main(int argc, char **argv) {
+#include "game/core.h"
-	(void) argc;
-	(void) argv;
 
-	if (!SDL_Init(SDL_INIT_VIDEO)) {
+#include "game/impl/world.c"
+#include "game/impl/npc.c"
+#include "game/testnavmesh.h"
+
+int main(int argc, char **argv)
+{
+	(void)argc;
+	(void)argv;
+
+	if (!SDL_Init(SDL_INIT_VIDEO))
+	{
 		printf("[Error] :: Failed to initialise SDL3 (%s)\n", SDL_GetError());
 		return 1;
 	}
 
 	SDL_Window *window = SDL_CreateWindow("Ludum", 1280, 720, SDL_WINDOW_HIGH_PIXEL_DENSITY);
-	if (!window) {
+	if (!window)
+	{
 		printf("[Error] :: Failed to create window (%s)\n", SDL_GetError());
 		return 1;
 	}
 
 	Vk_Setup(window);
 
+	G_State *game = 0;
+	{
+		M_Arena *arena = M_ArenaAlloc(GB(64), .initial = MB(4));
+		game = M_ArenaPush(arena, G_State);
+
+		game->arena = arena;
+
+		G_ImagesLoad(game);
+		G_PipelinesLoad(game);
+
+		G_Camera *camera = &game->camera;
+
+		camera->x = V3F(1, 0, 0);
+		camera->y = V3F(0, 1, 0);
+		camera->z = V3F(0, 0, 1);
+		camera->p = V3F(0, 0, 48);
+
+		camera->fov = 60.0f;
+
+		camera->nearp = 0.01f;
+		camera->farp = 1000.0f;
+
+		game->draw.camera = camera;
+	}
+
+	Vk_Buffer rbo = {0};
+	rbo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+	rbo.size = KB(4);
+	rbo.host_visible = true;
+
+	Vk_BufferCreate(&rbo);
+
 	bool running = true;
-	while (running) {
+	World world = {
+		.npcCount = 2,
+		.npcs = {
+			{.collision = {{10, 10}, {10, 10}},
+			 .name = S("Matt"),
+			 .mode = NPC_ACTION_WAITING,
+			 .waitTime = 0,
+			 .maxWaitTime = 5,
+			 .currentNavNode = 87},
+			{.collision = {{15, 15}, {10, 10}},
+			 .name = S("James"),
+			 .mode = NPC_ACTION_WAITING,
+			 .waitTime = 0,
+			 .maxWaitTime = 10,
+			 .currentNavNode = 0}},
+		.navMesh = &TestNavMesh,
+		.npcPOI = {100},
+		.player = {.pos = {0, 0}}};
+
+	printf("%zu size in bytes\n", sizeof(TestNavMesh));
+
+	while (running)
+	{
 		SDL_Event e;
-		while (SDL_PollEvent(&e)) {
+		while (SDL_PollEvent(&e))
-			if (e.type == SDL_EVENT_QUIT) { running = false; }
+		{
+			if (e.type == SDL_EVENT_QUIT)
+			{
+				running = false;
+			}
+			ProcessEvents(&e, &world);
 		}
+		UpdateWorld(1.0 / 60.0, &world);
 
 		int w, h;
 		SDL_GetWindowSizeInPixels(window, &w, &h);
 
+		game->draw.window_width = w;
+		game->draw.window_height = h;
+
+		G_CalulateCamera(&game->camera, (F32)w / (F32)h);
+
 		Vk_Frame *frame = Vk_FrameBegin(window);
 		VkCommandBuffer cmd = frame->cmd;
 
-		VkImageMemoryBarrier2 colour_optimal = { 0 };
-		colour_optimal.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
-		colour_optimal.srcStageMask  = VK_PIPELINE_STAGE_2_NONE;
-		colour_optimal.srcAccessMask = VK_ACCESS_2_NONE;
-		colour_optimal.dstStageMask  = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
-		colour_optimal.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
-		colour_optimal.oldLayout     = VK_IMAGE_LAYOUT_UNDEFINED;
-		colour_optimal.newLayout     = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-		colour_optimal.image         = vk.swapchain.images[frame->image];
-
-		colour_optimal.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-		colour_optimal.subresourceRange.layerCount = 1;
-		colour_optimal.subresourceRange.levelCount = 1;
-
-		VkDependencyInfo colour_barrier = { 0 };
-		colour_barrier.sType                   = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
-		colour_barrier.imageMemoryBarrierCount = 1;
-		colour_barrier.pImageMemoryBarriers    = &colour_optimal;
-
-		vk.CmdPipelineBarrier2(cmd, &colour_barrier);
-
 		VkClearValue clear_colour;
 		clear_colour.color.float32[0] = 1.0f;
 		clear_colour.color.float32[1] = 0.0f;
 		clear_colour.color.float32[2] = 0.0f;
 		clear_colour.color.float32[3] = 1.0f;
 
-		VkRenderingAttachmentInfo colour_attachment = { 0 };
+		VkRenderingAttachmentInfo colour_attachment = {0};
-		colour_attachment.sType       = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+		colour_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
-		colour_attachment.imageView   = vk.swapchain.views[frame->image];
+		colour_attachment.imageView = vk.swapchain.views[frame->image];
 		colour_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-		colour_attachment.loadOp      = VK_ATTACHMENT_LOAD_OP_CLEAR;
+		colour_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
-		colour_attachment.storeOp     = VK_ATTACHMENT_STORE_OP_STORE;
+		colour_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-		colour_attachment.clearValue  = clear_colour;
+		colour_attachment.clearValue = clear_colour;
 
-		VkRenderingInfo rendering_info = { 0 };
+		VkRenderingInfo rendering_info = {0};
-		rendering_info.sType                = VK_STRUCTURE_TYPE_RENDERING_INFO;
+		rendering_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
-		rendering_info.renderArea           = (VkRect2D) { 0, 0, w, h };
+		rendering_info.renderArea = (VkRect2D){0, 0, w, h};
-		rendering_info.layerCount           = 1;
+		rendering_info.layerCount = 1;
 		rendering_info.colorAttachmentCount = 1;
-		rendering_info.pColorAttachments    = &colour_attachment;
+		rendering_info.pColorAttachments = &colour_attachment;
 
 		vk.CmdBeginRendering(cmd, &rendering_info);
 
+		D_Begin(&game->draw, frame, D_MAX_RECTS);
+
+		D_Rect(&game->draw, 0.0f, 0.0f, .texture = 1);
+		D_Rect(&game->draw, -8.0f, 0.0f, .texture = 2, .scale = 2.0f);
+		D_Rect(&game->draw, 6.0f, 0.0f, .texture = 3);
+
+		D_End(&game->draw, frame);
+
 		vk.CmdEndRendering(cmd);
 
-		VkImageMemoryBarrier2 present_src = { 0 };
-		present_src.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
-		present_src.srcStageMask  = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
-		present_src.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
-		present_src.dstStageMask  = VK_PIPELINE_STAGE_2_NONE;
-		present_src.dstAccessMask = VK_ACCESS_2_NONE;
-		present_src.oldLayout     = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-		present_src.newLayout     = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
-		present_src.image         = vk.swapchain.images[frame->image];
-
-		present_src.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-		present_src.subresourceRange.layerCount = 1;
-		present_src.subresourceRange.levelCount = 1;
-
-		VkDependencyInfo to_present = { 0 };
-		to_present.sType                   = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
-		to_present.imageMemoryBarrierCount = 1;
-		to_present.pImageMemoryBarriers    = &present_src;
-
-		vk.CmdPipelineBarrier2(cmd, &to_present);
-
 		Vk_FrameEnd();
 	}
 
@@ -116,3 +162,5 @@ int main(int argc, char **argv) {
 #include "core/core.c"
 #include "os/core.c"
 #include "vulkan/core.c"
+#include "draw/core.c"
+#include "game/core.c"

code/game/aabb.h

@@ -0,0 +1,17 @@
+#if !defined(LD_GAME_AABB_H_)
+#define LD_GAME_AABB_H_
+#include "../core/types.h"
+#include "../core/macros.h"
+
+typedef struct AABB AABB;
+struct AABB
+{
+  V2f pos;
+  V2f size;
+};
+
+function bool AABB_Collide(AABB a, AABB b);
+function bool AABB_Point(AABB a, V2f v);
+function bool AABB_Slab(V2f origin, V2f point, AABB a);
+
+#endif // LD_GAME_AABB_H_

code/game/bandit.h

@@ -0,0 +1,59 @@
+#if !defined(LD_GAME_BANDIT_H_)
+#define LD_GAME_BANDIT_H_
+
+typedef enum BANDIT_ACTION BANDIT_ACTION;
+enum BANDIT_ACTION {
+  BANDIT_WAITING,
+  BANDIT_WALKING,
+  BANDIT_RUNNING,
+  BANDIT_SHOOTOUT,
+};
+
+typedef struct Bandit Bandit;
+struct Bandit {
+  //// Personal
+  AABB collision;
+  Str8 name;
+
+  //// Actions
+  BANDIT_ACTION mode;
+  // How long they've been waiting.
+  F32 waitTime;
+  // How long they will wait in this location.
+  F32 maxWaitTime;
+
+  // Places the bandit walks to / from
+  // E.g. hide outs, home, saloon
+  U32 pointsOfInterest[12];
+  //// Navigation
+  // The bandits's current path
+  NavPath path;
+  // Which node the bandit is on in the path
+  U32 currentNavNode;
+  // The current index of the bandit's current node
+  U32 pathIndex;
+  // Target navNode index the bandit is walking to
+  U32 targetNavNode;
+  // How long the bandit has been walking to the next index
+  F32 walkTimer;
+
+  // How many shots they can take.
+  U32 health;
+  // How paranoid they are about being hunted,
+  // this will make them more trigger happy.
+  F32 paranoidLevel;
+  // Max 6?
+  U8 bullets;
+  // How long it its between shots.
+  F32 shootDelay;
+  // After each shot this is set to shootDelay;
+  F32 shootCooldownTimer;
+  // How long it takes them to reload.
+  F32 reloadTime;
+  // Accuracy, their shots can vary between this angle either side (rads)
+  F32 accuracyRange;
+  // A the circle around the bandit where they will trigger the quicktime reaction scene
+  F32 agroRadius;
+};
+
+#endif  // LD_GAME_BANDIT_H_

code/game/core.c

@@ -0,0 +1,303 @@
+// @Todo:  These should move to draw/core.c
+//
+void G_ImagesLoad(G_State *game) {
+	M_TempScope(0, 0) {
+		D_Context *draw = &game->draw;
+
+		Str8 exe_path = FS_SystemPath(temp.arena, FS_SYSTEM_PATH_EXE);
+		Str8 path     = Sf(temp.arena, "%.*s/assets", Sv(exe_path));
+
+		FS_List assets = FS_PathList(temp.arena, path);
+
+		Vk_Buffer staging = { 0 };
+		staging.size         = MB(256);
+		staging.usage        = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+		staging.host_visible = true;
+
+		Vk_BufferCreate(&staging);
+
+		U8 *base   = staging.data;
+		U64 offset = 0;
+
+		Vk_CommandBuffer *cmds = Vk_CommandBufferPush();
+
+		// We reserve the first texture for the "white" texture
+		draw->n_images = 1;
+
+		for (FS_Entry *it = assets.first; it != 0; it = it->next) {
+			if (Str8_EndsWith(it->basename, S("png"))) {
+				draw->n_images += 1;
+			}
+		}
+
+		VkBufferImageCopy copy = { 0 };
+		draw->images = M_ArenaPush(game->arena, D_Image, .count = draw->n_images);
+		draw->n_images = 1;
+
+		// Upload the white texture
+		{
+			D_Image *white   = &draw->images[0];
+			U32 white_data[] = { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF };
+
+			M_CopySize(base, white_data, sizeof(white_data));
+
+			copy.bufferOffset = offset;
+			copy.bufferRowLength = 0;
+			copy.bufferImageHeight = 0;
+
+			copy.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
+			copy.imageSubresource.mipLevel       = 0;
+			copy.imageSubresource.baseArrayLayer = 0;
+			copy.imageSubresource.layerCount     = 1;
+
+			copy.imageExtent.width  = 2;
+			copy.imageExtent.height = 2;
+			copy.imageExtent.depth  = 1;
+
+			base   += sizeof(white_data);
+			offset += sizeof(white_data);
+
+			white->name = S("_WHITE");
+
+			white->image.width  = 2;
+			white->image.height = 2;
+			white->image.format = VK_FORMAT_R8G8B8A8_SRGB;
+			white->image.usage  = VK_IMAGE_USAGE_SAMPLED_BIT;
+
+			Vk_ImageCreate(&white->image);
+
+			// We could combine all of these 'pre-transfer' and 'post-transfer' layers into one
+			// batch, it would simply mean doing three loops over the images and setting them all up
+			// and submitting them in one go. It doesn't really matter for now
+			//
+
+			VkImageMemoryBarrier2 transfer = { 0 };
+			VkImageMemoryBarrier2 shader_read = { 0 };
+
+			transfer.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+			transfer.srcStageMask  = VK_PIPELINE_STAGE_2_NONE;
+			transfer.srcAccessMask = VK_ACCESS_2_NONE;
+			transfer.dstStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
+			transfer.dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
+			transfer.oldLayout     = VK_IMAGE_LAYOUT_UNDEFINED;
+			transfer.newLayout     = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+			transfer.image         = white->image.handle;
+
+			transfer.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+			transfer.subresourceRange.layerCount = 1;
+			transfer.subresourceRange.levelCount = 1;
+
+			shader_read.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+			shader_read.srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
+			shader_read.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
+			shader_read.dstStageMask  = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
+			shader_read.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
+			shader_read.oldLayout     = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+			shader_read.newLayout     = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+			shader_read.image         = white->image.handle;
+
+			shader_read.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+			shader_read.subresourceRange.layerCount = 1;
+			shader_read.subresourceRange.levelCount = 1;
+
+			VkDependencyInfo dep = { 0 };
+			dep.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
+
+			dep.imageMemoryBarrierCount = 1;
+			dep.pImageMemoryBarriers    = &transfer;
+
+			vk.CmdPipelineBarrier2(cmds->handle, &dep);
+
+			vk.CmdCopyBufferToImage(cmds->handle, staging.handle, white->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+
+			dep.pImageMemoryBarriers = &shader_read;
+
+			vk.CmdPipelineBarrier2(cmds->handle, &dep);
+		}
+
+		// Image upload is sbi_load -> copy to staging -> upload to gpu texture
+
+		for (FS_Entry *it = assets.first; it != 0; it = it->next) {
+			if (Str8_EndsWith(it->basename, S("png"))) {
+				S32 w, h, c;
+				stbi_uc *data = stbi_load((const char *) it->path.data, &w, &h, &c, 4);
+
+				if (data) {
+					D_Image *image = &draw->images[draw->n_images];
+
+					U64 image_sz = 4 * w * h;
+
+					M_CopySize(base, data, image_sz);
+
+					copy.bufferOffset      = offset;
+					copy.bufferRowLength   = 0;
+					copy.bufferImageHeight = 0;
+
+					copy.imageSubresource.aspectMask     = VK_IMAGE_ASPECT_COLOR_BIT;
+					copy.imageSubresource.mipLevel       = 0;
+					copy.imageSubresource.baseArrayLayer = 0;
+					copy.imageSubresource.layerCount     = 1;
+
+					copy.imageExtent.width  = w;
+					copy.imageExtent.height = h;
+					copy.imageExtent.depth  = 1;
+
+					base   += image_sz;
+					offset += image_sz;
+
+					Assert(offset <= staging.size);
+
+					draw->n_images += 1;
+
+					image->name = Str8_Copy(game->arena, Str8_RemoveAfterLast(it->basename, '.'));
+
+					printf("[Info] :: Loaded %.*s from %.*s\n", Sv(image->name), Sv(it->basename));
+
+					image->image.width  = w;
+					image->image.height = h;
+
+					image->image.format = VK_FORMAT_R8G8B8A8_SRGB;
+					image->image.usage  = VK_IMAGE_USAGE_SAMPLED_BIT;
+
+					Vk_ImageCreate(&image->image);
+
+					VkImageMemoryBarrier2 transfer = { 0 };
+					VkImageMemoryBarrier2 shader_read = { 0 };
+
+					transfer.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+					transfer.srcStageMask  = VK_PIPELINE_STAGE_2_NONE;
+					transfer.srcAccessMask = VK_ACCESS_2_NONE;
+					transfer.dstStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
+					transfer.dstAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
+					transfer.oldLayout     = VK_IMAGE_LAYOUT_UNDEFINED;
+					transfer.newLayout     = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+					transfer.image         = image->image.handle;
+
+					transfer.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+					transfer.subresourceRange.layerCount = 1;
+					transfer.subresourceRange.levelCount = 1;
+
+					shader_read.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+					shader_read.srcStageMask  = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
+					shader_read.srcAccessMask = VK_ACCESS_2_TRANSFER_WRITE_BIT;
+					shader_read.dstStageMask  = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
+					shader_read.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
+					shader_read.oldLayout     = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+					shader_read.newLayout     = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+					shader_read.image         = image->image.handle;
+
+					shader_read.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+					shader_read.subresourceRange.layerCount = 1;
+					shader_read.subresourceRange.levelCount = 1;
+
+					VkDependencyInfo dep = { 0 };
+					dep.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
+
+					dep.imageMemoryBarrierCount = 1;
+					dep.pImageMemoryBarriers    = &transfer;
+
+					vk.CmdPipelineBarrier2(cmds->handle, &dep);
+
+					vk.CmdCopyBufferToImage(cmds->handle, staging.handle, image->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+
+					dep.pImageMemoryBarriers = &shader_read;
+
+					vk.CmdPipelineBarrier2(cmds->handle, &dep);
+
+					stbi_image_free(data);
+				}
+			}
+		}
+
+		Vk_CommandBufferSubmit(cmds, true /* wait */);
+	}
+}
+
+void G_PipelinesLoad(G_State *game) {
+	D_Context *draw = &game->draw;
+
+	draw->pipelines = M_ArenaPush(game->arena, Vk_Pipeline, .count = 1);
+
+	Vk_Pipeline *basic = &draw->pipelines[0];
+
+	VkShaderModule vshader = 0, fshader = 0;
+	M_TempScope(0, 0) {
+		Str8 exe_path = FS_SystemPath(temp.arena, FS_SYSTEM_PATH_EXE);
+		Str8 vshader_code = FS_ReadEntireFile(temp.arena, Sf(temp.arena, "%.*s/assets/shaders/basic.vert.spv", Sv(exe_path)));
+		Str8 fshader_code = FS_ReadEntireFile(temp.arena, Sf(temp.arena, "%.*s/assets/shaders/basic.frag.spv", Sv(exe_path)));
+
+		VkShaderModuleCreateInfo create_info = { 0 };
+		create_info.sType    = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+		create_info.pCode    = (U32 *) vshader_code.data;
+		create_info.codeSize = vshader_code.count;
+
+		vk.CreateShaderModule(vk.device, &create_info, 0, &vshader);
+
+		create_info.pCode    = (U32 *) fshader_code.data;
+		create_info.codeSize = fshader_code.count;
+
+		vk.CreateShaderModule(vk.device, &create_info, 0, &fshader);
+	}
+
+	// Create pipeline layout, its insane what you have to do for this because the ALREADY KNOW
+	// all of this information
+	{
+		VkDescriptorSetLayoutBinding bindings[2] = { 0 };
+
+		bindings[0].binding         = 0;
+		bindings[0].descriptorType  = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+		bindings[0].descriptorCount = 1;
+		bindings[0].stageFlags      = VK_SHADER_STAGE_VERTEX_BIT;
+
+		bindings[1].binding         = 1;
+		bindings[1].descriptorType  = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+		bindings[1].descriptorCount = game->draw.n_images;
+		bindings[1].stageFlags      = VK_SHADER_STAGE_FRAGMENT_BIT;
+
+		VkDescriptorSetLayoutCreateInfo set_info = { 0 };
+		set_info.sType        = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+		set_info.bindingCount = ArraySize(bindings);
+		set_info.pBindings    = bindings;
+
+		vk.CreateDescriptorSetLayout(vk.device, &set_info, 0, &basic->layout.set);
+
+		VkPushConstantRange push_range = { 0 };
+		push_range.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
+		push_range.offset     = 0;
+		push_range.size       = 128;
+
+		VkPipelineLayoutCreateInfo layout_create = { 0 };
+		layout_create.sType                  = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+		layout_create.setLayoutCount         = 1;
+		layout_create.pSetLayouts            = &basic->layout.set;
+		layout_create.pushConstantRangeCount = 1;
+		layout_create.pPushConstantRanges    = &push_range;
+
+		vk.CreatePipelineLayout(vk.device, &layout_create, 0, &basic->layout.pipeline);
+	}
+
+	basic->targets.items[0] = vk.swapchain.format.format;
+	basic->targets.count    = 1;
+
+	basic->shaders.count = 2;
+
+	basic->shaders.items[0].stage  = VK_SHADER_STAGE_VERTEX_BIT;
+	basic->shaders.items[0].handle = vshader;
+
+	basic->shaders.items[1].stage  = VK_SHADER_STAGE_FRAGMENT_BIT;
+	basic->shaders.items[1].handle = fshader;
+
+	Vk_PipelineCreate(basic);
+}
+
+void G_CalulateCamera(G_Camera *camera, F32 aspect) {
+	Mat4x4FInv proj = M4x4F_Perspective(camera->fov, aspect, camera->nearp, camera->farp);
+	Mat4x4FInv view = M4x4F_CameraView(camera->x, camera->y, camera->z, camera->p);
+
+	camera->proj.fwd = M4x4F_Mul(proj.fwd, view.fwd);
+	camera->proj.inv = M4x4F_Mul(view.inv, proj.inv);
+}
+
+#include "impl/aabb.c"
+#include "impl/nav.c"
+#include "impl/player.c"

code/game/core.h

@@ -0,0 +1,34 @@
+#if !defined(LD_GAME_CORE_H_)
+#define LD_GAME_CORE_H_
+
+typedef struct G_Camera G_Camera;
+struct G_Camera {
+	V3f x, y, z;
+	V3f p;
+
+	F32 fov;
+	F32 nearp, farp;
+
+	Mat4x4FInv proj;
+};
+
+typedef struct G_State G_State;
+struct G_State {
+	M_Arena *arena;
+
+	D_Context draw;
+	G_Camera camera;
+};
+
+function void G_ImagesLoad(G_State *game);
+function void G_PipelinesLoad(G_State *game);
+
+function void G_CalulateCamera(G_Camera *camera, F32 aspect);
+
+#include "aabb.h"
+#include "player.h"
+#include "nav.h"
+#include "npc.h"
+#include "world.h"
+
+#endif  // LD_GAME_CORE_H_

code/game/impl/aabb.c

@@ -0,0 +1,36 @@
+#include "game/aabb.h"
+#include <math.h>
+
+bool AABB_Collide(AABB a, AABB b)
+{
+  bool collision_x = a.pos.x + a.size.x >= b.pos.x && b.pos.x + b.size.x >= a.pos.x;
+  bool collision_y = a.pos.y + a.size.x >= b.pos.y && b.pos.y + b.size.y >= a.pos.y;
+  return collision_x && collision_y;
+}
+
+bool AABB_Point(AABB a, V2f v)
+{
+  bool collision_x = a.pos.x + a.size.x >= v.x && a.pos.x <= v.x;
+  bool collision_y = a.pos.x + a.size.y >= v.y && a.pos.y <= v.y;
+  return collision_x && collision_y;
+}
+
+bool AABB_Slab(V2f origin, V2f point, AABB a)
+{
+  V2f start = a.pos;
+  V2f finish = {a.pos.x + a.size.x, a.pos.y + a.size.y};
+  V2f invdirection = {1 / (origin.x - point.x), 1 / (origin.y - point.y)};
+  // x
+  F32 tLow = (start.x - origin.x) * invdirection.x;
+  F32 tHigh = (finish.x - origin.x) * invdirection.x;
+  F32 tMin = min(tLow, tHigh);
+  F32 tMax = max(tLow, tHigh);
+  // y
+  tLow = (start.y - origin.y) * invdirection.y;
+  tHigh = (finish.y - origin.y) * invdirection.y;
+
+  tMin = max(tMin, min(tLow, tHigh));
+  tMax = min(tMax, max(tLow, tHigh));
+
+  return tMax >= tMin;
+}

code/game/impl/nav.c

@@ -0,0 +1,119 @@
+#include "game/nav.h"
+#include "core/types.h"
+
+#include <stdio.h>
+
+#define MAX_UNFINISHED 128
+
+typedef struct navSearchNodeState navSearchNodeState;
+struct navSearchNodeState
+{
+  bool visited;
+  U64 distance;
+  U32 shortest;
+  bool addedToUnvisited;
+};
+
+typedef struct navSearchState navSearchState;
+struct navSearchState
+{
+  navSearchNodeState nodeStates[NAV_MAX_NODES];
+};
+
+navSearchState initState(U32 start, U32 meshSize)
+{
+  navSearchState state;
+  for (U32 i = 0; i < meshSize; i++)
+  {
+    state.nodeStates[i].visited = false;
+    state.nodeStates[i].addedToUnvisited = false;
+    state.nodeStates[i].distance = U64_MAX;
+    state.nodeStates[i].shortest = 0;
+  }
+  state.nodeStates[start].distance = 0;
+  return state;
+}
+
+U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchState state, U32 *offset)
+{
+  U32 lowest = U32_MAX;
+  U32 lowestI = U32_MAX;
+  bool startFound = false;
+  for (U32 i = *offset; i < unfinishedCount; i++)
+  {
+    navSearchNodeState checkNode = state.nodeStates[unfinishedIndexes[i]];
+    if (checkNode.visited)
+    {
+      if (!startFound)
+      {
+        *offset = i;
+      }
+      continue;
+    }
+    startFound = true;
+    if (lowest > checkNode.distance)
+    {
+      lowest = cast(U32) checkNode.distance;
+      lowestI = unfinishedIndexes[i];
+    }
+  }
+  return lowestI;
+}
+
+// Generate a path to follow between the start and end node.
+NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end)
+{
+  navSearchState state = initState(start, mesh->nodeCount);
+  U32 unfinishedCount = 1;
+  U32 unfinishedIndexes[NAV_MAX_NODES] = {start};
+  // I don't want to spend time removing items from
+  // the unfinished nodes, so when checking for a lowest
+  // if I find the first N items have been checked, I'll mark
+  // an offset to skip the first N items.
+  U32 unfinishedOffset = 0;
+  U32 lowestNodeIndex = start;
+  bool found = false;
+  while (!found)
+  {
+    for (int connectionI = 0; connectionI < mesh->nodes[lowestNodeIndex].connectionCount; connectionI++)
+    {
+      NavConnection *connection = &mesh->nodes[lowestNodeIndex].connections[connectionI];
+      navSearchNodeState *testNode = &state.nodeStates[connection->NodeIndex];
+      if (testNode->visited)
+      {
+        continue;
+      }
+      U32 distance = cast(U32)(state.nodeStates[lowestNodeIndex].distance + connection->Cost);
+      distance += cast(U32)(mesh->nodes[end].pos.x - mesh->nodes[connection->NodeIndex].pos.x);
+      distance += cast(U32)(mesh->nodes[end].pos.y - mesh->nodes[connection->NodeIndex].pos.y);
+      if (testNode->distance > distance)
+      {
+        testNode->distance = distance;
+        testNode->shortest = lowestNodeIndex;
+      }
+      if (!testNode->addedToUnvisited)
+      {
+        unfinishedIndexes[unfinishedCount] = connection->NodeIndex;
+        unfinishedCount++;
+        testNode->addedToUnvisited = true;
+      }
+    }
+    state.nodeStates[lowestNodeIndex].visited = true;
+    lowestNodeIndex = getLowestState(unfinishedIndexes, unfinishedCount, state, &unfinishedOffset);
+    if (lowestNodeIndex == end)
+    {
+      found = true;
+    }
+  }
+  NavPath res_path = {0};
+  U32 index = end;
+  while (index != start)
+  {
+    res_path.indexes[res_path.nodeCount] = index;
+    res_path.nodeCount++;
+    index = state.nodeStates[index].shortest;
+  }
+  res_path.indexes[res_path.nodeCount] = start;
+  res_path.nodeCount++;
+  return res_path;
+}

code/game/impl/npc.c

@@ -0,0 +1,43 @@
+#include "game/npc.h"
+#include "game/world.h"
+#include "core/types.h"
+
+#include <stdio.h>
+
+void updateNPC(F32 delta, NPC *npc, World *world) {
+  switch (npc->mode) {
+    case NPC_ACTION_WAITING:
+      npc->waitTime+=delta;
+      if(npc->waitTime > npc->maxWaitTime) {
+        npc->mode = NPC_ACTION_WALKING;
+        U32 next = npc->targetNavNode == 100 ? 20 : 100;
+        npc->targetNavNode = next; // TODO RANDOM
+        printf("Starting to nav path\n");
+        npc->path = Nav_Path(world->navMesh, npc->currentNavNode, npc->targetNavNode);
+        printf("done\n");
+        npc->walkTimer = 0;
+        printf("%.*s started walking to %d\n", Sv(npc->name), npc->targetNavNode);
+      }
+    break;
+    case NPC_ACTION_WALKING:
+      npc->walkTimer+=delta;
+      if(npc->walkTimer >= NPC_SPEED){
+        npc->walkTimer = 0;
+        if(npc->path.nodeCount == npc->pathIndex+1){
+          printf("Finished! so I'm waiting\n");
+          npc->mode = NPC_ACTION_WAITING;
+          npc->maxWaitTime = 20; // TODO RANDOM
+          npc->waitTime = 0;
+          npc->pathIndex = 0;
+          return;
+        }
+        npc->pathIndex+=1;
+        npc->currentNavNode = npc->path.indexes[npc->pathIndex];
+      }
+      NavNode cNav = world->navMesh->nodes[npc->currentNavNode];
+      NavNode tNav = world->navMesh->nodes[npc->pathIndex];
+      npc->collision.pos.x = cNav.pos.x * (1 - npc->walkTimer/NPC_SPEED) + tNav.pos.x * npc->walkTimer/NPC_SPEED;
+      npc->collision.pos.y = cNav.pos.y * (1 - npc->walkTimer/NPC_SPEED) + tNav.pos.y * npc->walkTimer/NPC_SPEED;
+    break;
+  }
+}

code/game/impl/player.c

@@ -0,0 +1,37 @@
+#include "../player.h"
+#include <SDL3/SDL_keycode.h>
+#include <stdio.h>
+
+void PlayerUpdate(SDL_Event *event, Player *player)
+{
+  SDL_KeyboardEvent key = event->key;
+  SDL_MouseButtonEvent mouseBtn = event->button;
+  switch (key.key)
+  {
+  case SDLK_W:
+  {
+    player->pos.y += 10;
+    break;
+  }
+  case SDLK_A:
+  {
+    player->pos.x -= 10;
+    break;
+  }
+  case SDLK_D:
+  {
+    player->pos.x += 10;
+    break;
+  }
+  case SDLK_S:
+  {
+    player->pos.y -= 10;
+    break;
+  }
+  }
+  if (mouseBtn.clicks == 1)
+  {
+    // shooting
+    player->bulletsLoaded -= 1;
+  }
+}

code/game/impl/world.c

@@ -0,0 +1,22 @@
+#include "../world.h"
+#include "../npc.h"
+#include "../player.h"
+#include <SDL3/SDL_events.h>
+
+void UpdateWorld(F32 delta, World *world)
+{
+  // UpdateNPCs(delta, world);
+}
+
+void UpdateNPCs(F32 delta, World *world)
+{
+  for (int i = 0; i < world->npcCount; i++)
+  {
+    updateNPC(delta, &world->npcs[i], world);
+  }
+}
+
+void ProcessEvents(SDL_Event *event, World *world)
+{
+  PlayerUpdate(event, &world->player);
+}

code/game/nav.h

@@ -0,0 +1,39 @@
+#if !defined(LD_GAME_NAV_H_)
+#define LD_GAME_NAV_H_
+
+#include "core/types.h"
+#include "core/macros.h"
+
+#define NAV_MAX_PATH 1024
+#define NAV_MAX_CONNECTIONS 8
+#define NAV_MAX_NODES 4096
+
+typedef struct NavNode NavNode;
+
+typedef struct NavConnection NavConnection;
+struct NavConnection{
+  F32 Cost;
+  U32 NodeIndex;
+};
+
+struct NavNode {
+  V2f pos;
+  U8 connectionCount;
+  NavConnection connections[NAV_MAX_CONNECTIONS];
+};
+
+typedef struct NavPath NavPath;
+struct NavPath {
+  U32 nodeCount;
+  U32 indexes[NAV_MAX_PATH];
+};
+
+typedef struct NavMesh NavMesh;
+struct NavMesh{
+  U32 nodeCount;
+  NavNode nodes[NAV_MAX_NODES];
+};
+
+function NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end);
+
+#endif

code/game/npc.h

@@ -0,0 +1,50 @@
+#if !defined(LD_GAME_NPC_H_)
+#define LD_GAME_NPC_H_
+#include "aabb.h"
+#include "nav.h"
+#include "npc_look.h"
+#include "../core/types.h"
+
+#define NPC_SPEED 0.2f
+
+typedef enum NPC_ACTION NPC_ACTION;
+enum NPC_ACTION {
+  // Waiting can be at any point of interest
+  NPC_ACTION_WAITING,
+  // Walking is when they are actively moving somewhere
+  NPC_ACTION_WALKING,
+};
+
+
+typedef struct NPC NPC;
+struct NPC {
+  //// Personal
+  AABB collision;
+  Str8 name;
+  NPC_LOOK look;
+
+  //// Actions
+  NPC_ACTION mode;
+  // How long they've been waiting
+  F32 waitTime;
+  // How long they will wait until changing action
+  F32 maxWaitTime;
+
+  //// Navigation
+  // The NPC's current path
+  NavPath path;
+  // Which node the NPC is on in the path
+  U32 currentNavNode;
+  // The current index of the NPC's current node
+  U32 pathIndex;
+  // Target navNode index the npc is walking to
+  U32 targetNavNode;
+  // How long the npc has been walking to the next index
+  F32 walkTimer;
+
+  //// Knowledge
+  // What the NPC knows about the bandit.
+  NPC_LOOK banditKnowledge;
+};
+
+#endif  // LD_GAME_NPC_H_

code/game/npc_look.h

@@ -0,0 +1,82 @@
+#if !defined(LD_GAME_NPC_LOOK_H_)
+#define LD_GAME_NPC_LOOK_H_
+
+typedef struct NPC_LOOK NPC_LOOK;
+typedef enum NPC_HAIR_COLOUR NPC_HAIR_COLOUR;
+typedef enum NPC_JACKET_COLOUR NPC_JACKET_COLOUR;
+typedef enum NPC_JEANS_COLOUR NPC_JEANS_COLOUR;
+typedef enum NPC_EYE_COLOUR NPC_EYE_COLOUR;
+typedef enum NPC_SKIN_TONE NPC_SKIN_TONE;
+typedef enum NPC_HAT NPC_HAT;
+typedef enum NPC_FACIAL_FEATURE NPC_FACIAL_FEATURE;
+
+enum NPC_HAIR_COLOUR {
+  NPC_HAIR_COLOUR_UNKNOWN,
+  NPC_HAIR_COLOUR_BLONDE,
+  NPC_HAIR_COLOUR_BLACK,
+  NPC_HAIR_COLOUR_BRUNETTE,
+  NPC_HAIR_COLOUR_GIGNER,
+};
+
+enum NPC_JACKET_COLOUR {
+  NPC_JACKET_COLOUR_UNKNOWN,
+  NPC_JACKET_COLOUR_TAN,
+  NPC_JACKET_COLOUR_BLUE,
+  NPC_JACKET_COLOUR_WHITE,
+};
+
+enum NPC_JEANS_COLOUR {
+  NPC_JEANS_COLOUR_UNKNOWN,
+  NPC_JEANS_COLOUR_TAN,
+  NPC_JEANS_COLOUR_BLACK,
+  NPC_JEANS_COLOUR_BLUE,
+  NPC_JEANS_COLOUR_WHITE,
+};
+
+enum NPC_EYE_COLOUR {
+  NPC_EYE_COLOUR_UNKNOWN,
+  NPC_EYE_COLOUR_GREEN,
+  NPC_EYE_COLOUR_BLUE,
+  NPC_EYE_COLOUR_BROWN,
+};
+
+enum NPC_SHOE_COLOUR {
+  NPC_SHOE_COLOUR_UNKNOWN,
+  NPC_SHOE_COLOUR_BLACK,
+  NPC_SHOE_COLOUR_BROWN,
+  NPC_SHOE_COLOUR_WHITE,
+  NPC_SHOE_COLOUR_NAVY,
+};
+
+enum NPC_SKIN_TONE {
+  NPC_SKIN_TONE_UNKNOWN,
+  NPC_SKIN_TONE_WHITE,
+  NPC_SKIN_TONE_BLACK,
+};
+
+enum NPC_FACIAL_FEATURE {
+  NPC_FACIAL_FEATURE_UNKNOWN,
+  NPC_FACIAL_FEATURE_BEARD,
+  NPC_FACIAL_FEATURE_MUSTACHE,
+  NPC_FACIAL_FEATURE_GLASSES,
+};
+
+enum NPC_HAT {
+  NPC_HAT_UNKNOWN,
+  NPC_HAT_TEN_GALLON,
+  NPC_TOP_HAT,
+  NPC_FLAT_CAP,
+  NPC_NONE,
+};
+
+struct NPC_LOOK {
+  NPC_HAIR_COLOUR hair;
+  NPC_JACKET_COLOUR jacket;
+  NPC_JEANS_COLOUR jeans;
+  NPC_EYE_COLOUR eyes;
+  NPC_SKIN_TONE skinTone;
+  NPC_HAT hat;
+  NPC_FACIAL_FEATURE facialFeature;
+};
+
+#endif  // LD_GAME_NPC_LOOK_H_

code/game/player.h

@@ -0,0 +1,18 @@
+#if !defined(LD_GAME_PLAYER_H_)
+#define LD_GAME_PLAYER_H_
+
+#include "../core/types.h"
+#include "../core/macros.h"
+
+#include <SDL3/SDL_events.h>
+
+typedef struct Player Player;
+struct Player
+{
+    V2f pos;
+    U32 bulletsLoaded;
+};
+
+function void PlayerUpdate(SDL_Event *event, Player *player);
+
+#endif  // LD_GAME_PLAYER_H_

code/game/world.h

@@ -0,0 +1,40 @@
+#if !defined(LD_GAME_WORLD_H_)
+#define LD_GAME_WORLD_H_
+
+#include "player.h"
+#include "npc.h"
+#include "bandit.h"
+
+// Areas are which
+typedef U32 World_Area;
+enum World_Area {
+  WORLD_AREA_OUTSIDE = (1 << 0),
+  WORLD_AREA_SALOON  = (1 << 1),
+};
+
+typedef struct World World;
+struct World {
+  //// Static stuff
+  NavMesh *navMesh;
+
+  //// Player
+	Player player;
+
+  //// NPCs
+  U32 npcCount;
+  NPC npcs[128];
+
+  ////Bandit
+  // The bandit the player is after. 
+  Bandit bandit;
+
+  // NPC points of interest, places to walk to.
+  U32 npcPOI[256];
+};
+
+function void UpdateWorld(F32 delta, World *world);
+function void ProcessEvents(SDL_Event *event, World *world);
+function void UpdateNPCs(F32 delta, World *world);
+function void updateNPC(F32 delta, NPC *npc, World *world);
+
+#endif  // LD_GAME_WORLD_H_

code/os/core.c

@@ -1,3 +1,21 @@
 #if OS_WINDOWS
 	#include "impl/windows/core.c"
+#elif OS_LINUX
+	#include "impl/linux/core.c"
 #endif
+
+
+Str8 FS_ReadEntireFile(M_Arena *arena, Str8 path) {
+	Str8 result = { 0 };
+
+	OS_Handle file = FS_FileOpen(path, FS_ACCESS_READ);
+	if (file.v[0]) {
+		result.count = FS_FileSize(file);
+		result.data  = M_ArenaPush(arena, U8, .count = result.count);
+
+		FS_FileRead(file, result.data, result.count, 0);
+		FS_FileClose(file);
+	}
+
+	return result;
+}

code/os/core.h

@@ -1,6 +1,11 @@
 #if !defined(LD_OS_CORE_H_)
 #define LD_OS_CORE_H_
 
+typedef struct OS_Handle OS_Handle;
+struct OS_Handle {
+	U64 v[1];
+};
+
 // Virtual memory
 
 function U64 VM_PageSize();
@@ -11,4 +16,6 @@ function B32   VM_Commit(void *base, U64 size);
 function void  VM_Decommit(void *base, U64 size);
 function void  VM_Release(void *base, U64 size);
 
+#include "filesystem.h"
+
 #endif  // LD_OS_CORE_H_

code/os/filesystem.h

@@ -0,0 +1,59 @@
+#if !defined(LD_OS_FILESYSTEM_H_)
+#define LD_OS_FILESYSTEM_H_
+
+typedef U32 FS_AccessFlags;
+enum {
+	FS_ACCESS_READ  = (1 << 0),
+	FS_ACCESS_WRITE = (1 << 1)
+};
+
+function OS_Handle FS_FileOpen(Str8 path, FS_AccessFlags access);
+function void      FS_FileClose(OS_Handle file);
+
+function void FS_FileRead(OS_Handle file, void *ptr, U64 size, U64 offset);
+function void FS_FileWrite(OS_Handle file, void *ptr, U64 size, U64 offset);
+
+function U64 FS_FileSize(OS_Handle file);
+
+typedef U32 FS_EntryType;
+enum {
+	FS_ENTRY_TYPE_FILE = 0,
+	FS_ENTRY_TYPE_DIR
+};
+
+typedef struct FS_Entry FS_Entry;
+struct FS_Entry {
+	FS_Entry *next;
+
+	FS_EntryType type;
+
+	Str8 path;
+	Str8 basename;
+
+	U64 time;
+	U64 size;
+};
+
+typedef struct FS_List FS_List;
+struct FS_List {
+	FS_Entry *first;
+	FS_Entry *last;
+
+	U32 count;
+};
+
+function FS_List FS_PathList(M_Arena *arena, Str8 path);
+
+function Str8 FS_ReadEntireFile(M_Arena *arena, Str8 path);
+
+typedef U32 FS_SystemPathType;
+enum {
+	FS_SYSTEM_PATH_EXE = 0,
+	FS_SYSTEM_PATH_WORKING,
+	FS_SYSTEM_PATH_USER,
+	FS_SYSTEM_PATH_TEMP
+};
+
+function Str8 FS_SystemPath(M_Arena *arena, FS_SystemPathType path);
+
+#endif  // LD_OS_FILESYSTEM_H_

code/os/impl/linux/core.c

@@ -0,0 +1,31 @@
+U64 VM_PageSize() {
+	U64 result = getpagesize();
+	return result;
+}
+
+U64 VM_AllocationGranularity() {
+	U64 result = getpagesize();
+	return result;
+}
+
+void *VM_Reserve(U64 size) {
+	void *addr = mmap(0, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
+
+	void *result = (addr == MAP_FAILED) ? 0 : addr;
+	return result;
+}
+
+B32 VM_Commit(void *base, U64 size) {
+	B32 result = mprotect(base, size, PROT_READ | PROT_WRITE) == 0;
+	return result;
+}
+
+void VM_Decommit(void *base, U64 size) {
+	mprotect(base, size, PROT_NONE);
+}
+
+void VM_Release(void *base, U64 size) {
+	munmap(base, size);
+}
+
+#include "filesystem.c"

code/os/impl/linux/filesystem.c

@@ -0,0 +1,215 @@
+OS_Handle FS_FileOpen(Str8 path, FS_AccessFlags access) {
+	OS_Handle result = { 0 };
+
+	M_TempScope(0, 0) {
+		Str8 zpath = Str8_Copy(temp.arena, path);
+
+		int mode  = 0644;
+		int flags = 0;
+		if (access & FS_ACCESS_READ) {
+			if (access & FS_ACCESS_WRITE) {
+				flags = O_RDWR | O_CREAT;
+			}
+			else {
+				flags = O_RDONLY;
+			}
+		}
+		else if (access & FS_ACCESS_WRITE) {
+			flags = O_WRONLY | O_CREAT;
+		}
+
+
+		int fd = open((const char *) zpath.data, flags, mode);
+		result.v[0] = (fd > 0) ? (U64) fd : 0;
+	}
+
+	return result;
+}
+void FS_FileClose(OS_Handle file) {
+	int fd = cast(int) file.v[0];
+	if (fd > 0) {
+		close(fd);
+	}
+}
+
+void FS_FileRead(OS_Handle file, void *ptr, U64 size, U64 offset) {
+	int fd = cast(int) file.v[0];
+	if (fd > 0) {
+		U8 *buffer    = ptr;
+		U64 current   = offset;
+		U64 remainder = size;
+
+		while (remainder != 0) {
+			S64 nread = pread(fd, buffer, remainder, current);
+			if (nread <= 0) {
+				break;
+			}
+
+			buffer    += nread;
+			current   += nread;
+			remainder -= nread;
+		}
+	}
+}
+
+void FS_FileWrite(OS_Handle file, void *ptr, U64 size, U64 offset) {
+	int fd = cast(int) file.v[0];
+	if (fd > 0) {
+		U8 *buffer    = ptr;
+		U64 current   = offset;
+		U64 remainder = size;
+
+		while (remainder != 0) {
+			S64 nwritten = pwrite(fd, buffer, remainder, current);
+			if (nwritten <= 0) {
+				break;
+			}
+
+			buffer    += nwritten;
+			current   += nwritten;
+			remainder -= nwritten;
+		}
+	}
+}
+
+U64 FS_FileSize(OS_Handle file) {
+	U64 result = 0;
+
+	int fd = cast(int) file.v[0];
+	if (fd > 0) {
+		struct stat sb;
+		fstat(fd, &sb);
+
+		result = sb.st_size;
+	}
+
+	return result;
+}
+
+FS_List FS_PathList(M_Arena *arena, Str8 path) {
+	FS_List result = { 0 };
+
+	M_TempScope(1, &arena) {
+		Str8 zpath = Str8_Copy(temp.arena, path);
+
+		DIR *dir = opendir((const char *) zpath.data);
+
+		struct dirent *ent = readdir(dir);
+		while (ent != 0) {
+			if (ent->d_name[0] != '.') {
+				FS_Entry *entry = M_ArenaPush(arena, FS_Entry);
+
+				entry->basename = Str8_Copy(arena, Sz(ent->d_name));
+				entry->path     = Sf(arena, "%.*s/%.*s", Sv(path), Sv(entry->basename));
+
+				struct stat sb;
+				stat((const char *) entry->path.data, &sb);
+
+				entry->type = ((sb.st_mode & S_IFMT) == S_IFDIR) ? FS_ENTRY_TYPE_DIR : FS_ENTRY_TYPE_FILE;
+				entry->time = (sb.st_mtim.tv_sec * 1e9) + sb.st_mtim.tv_nsec;
+				entry->size = sb.st_size;
+
+				SLL_Enqueue(result.first, result.last, entry);
+				result.count += 1;
+			}
+
+			ent = readdir(dir);
+		}
+	}
+
+	return result;
+}
+
+Str8 FS_SystemPath(M_Arena *arena, FS_SystemPathType path) {
+	Str8 result = { 0 };
+
+	switch (path) {
+		case FS_SYSTEM_PATH_EXE: {
+			U64 offset = M_ArenaOffset(arena);
+
+			Str8 buffer;
+			buffer.count = KB(1);
+			buffer.data  = M_ArenaPush(arena, U8, .count = buffer.count);
+
+			ssize_t nwritten = 0;
+			for (;;) {
+				nwritten = readlink("/proc/self/exe", cast(char *) buffer.data, buffer.count);
+				if (nwritten < buffer.count) {
+					break;
+				}
+
+				M_ArenaPop(arena, offset);
+
+				buffer.count *= 2;
+				buffer.data   = M_ArenaPush(arena, U8, .count = buffer.count);
+			}
+
+			if (nwritten > 0) {
+				// Walk back until the prevous slash, then null-terminate there
+				while (buffer.data[nwritten] != '/') { nwritten -= 1; }
+				buffer.data[nwritten] = 0;
+
+				M_ArenaPopSize(arena, buffer.count - nwritten - 1);
+
+				result.count = nwritten;
+				result.data  = buffer.data;
+			}
+			else {
+				M_ArenaPop(arena, offset);
+			}
+		}
+		break;
+
+		case FS_SYSTEM_PATH_WORKING: {
+			U64 offset = M_ArenaOffset(arena);
+
+			Str8 buffer;
+			buffer.count = KB(1);
+			buffer.data  = M_ArenaPush(arena, U8, .count = buffer.count);
+
+			char *wd;
+
+			for (;;) {
+				wd = getcwd((char *) buffer.data, buffer.count);
+				if (wd != 0) {
+					break;
+				}
+				else if (errno != ERANGE) {
+					break;
+				}
+
+				M_ArenaPop(arena, offset);
+
+				buffer.count *= 2;
+				buffer.data   = M_ArenaPush(arena, U8, .count = buffer.count);
+			}
+
+			if (wd) {
+				result = Sz(wd);
+				M_ArenaPopSize(arena, buffer.count - result.count - 1);
+			}
+		}
+		break;
+
+		case FS_SYSTEM_PATH_USER: {
+			char *home = getenv("HOME");
+			if (home) {
+				result = Sf(arena, "%s/.local/share", home);
+			}
+		}
+		break;
+
+		case FS_SYSTEM_PATH_TEMP: {
+			char *temp = getenv("TEMP");
+			if (temp) {
+				result = Str8_Copy(arena, Sz(temp));
+			}
+			else {
+				result = Str8_Copy(arena, S("/tmp"));
+			}
+		}
+		break;
+	}
+
+	return result;
+}

code/os/impl/windows/core.c

@@ -1,3 +1,32 @@
+// Windows utilities
+
+internal Str8 Win32_WideStr(M_Arena *arena, Str8 v) {
+	Str8 result = { 0 };
+
+	S32 nchars = MultiByteToWideChar(CP_UTF8, 0, (LPCCH) v.data, (int) v.count, 0, 0) + 1;
+	U64 nbytes = nchars << 1;
+
+	result.count = nbytes - 2; // -2 because we don't include the null-terminator in the count
+	result.data  = M_ArenaPush(arena, U8, .count = nbytes);
+
+	MultiByteToWideChar(CP_UTF8, 0, (LPCCH) v.data, (int) v.count, (LPWSTR) result.data, nchars);
+
+	return result;
+}
+
+internal Str8 Win32_MultiByteStr(M_Arena *arena, LPWSTR wstr) {
+	Str8 result = { 0 };
+
+	S32 nbytes = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, 0, 0, 0, 0);
+
+	result.count = nbytes - 1;
+	result.data  = M_ArenaPush(arena, U8, .count = nbytes);
+
+	WideCharToMultiByte(CP_UTF8, 0, wstr, -1, (LPSTR) result.data, nbytes, 0, 0);
+
+	return result;
+}
+
 // Virtual memory
 
 U64 VM_PageSize() {
@@ -36,3 +65,4 @@ void VM_Release(void *base, U64 size) {
 	VirtualFree(base, 0, MEM_RELEASE);
 }
 
+#include "filesystem.c"

code/os/impl/windows/filesystem.c

@@ -0,0 +1,209 @@
+OS_Handle FS_FileOpen(Str8 path, FS_AccessFlags access) {
+	OS_Handle result = { 0 };
+
+	M_TempScope(0, 0) {
+		Str8 wpath = Win32_WideStr(temp.arena, path);
+
+		DWORD dwAccess = 0;
+		DWORD dwShare  = FILE_SHARE_READ;
+		DWORD dwCreate = OPEN_EXISTING;
+
+		if (access & FS_ACCESS_WRITE) {
+			dwCreate = CREATE_ALWAYS;
+			dwAccess = GENERIC_WRITE;
+		}
+
+		if (access & FS_ACCESS_READ) {
+			dwAccess |= GENERIC_READ;
+		}
+
+		HANDLE hFile = CreateFileW((LPCWSTR) wpath.data, dwAccess, dwShare, 0, dwCreate, 0, 0);
+
+		result.v[0] = (hFile == INVALID_HANDLE_VALUE) ? 0 : ((U64) hFile);
+	}
+	return result;
+}
+
+void FS_FileClose(OS_Handle file) {
+	HANDLE hFile = cast(HANDLE) file.v[0];
+	if (hFile) {
+		CloseHandle(hFile);
+	}
+}
+
+void FS_FileRead(OS_Handle file, void *ptr, U64 size, U64 offset) {
+	HANDLE hFile = cast(HANDLE) file.v[0];
+	if (hFile) {
+		U8 *buffer    = ptr;
+		U64 current   = offset;
+		U64 remainder = size;
+
+		while (remainder != 0) {
+			OVERLAPPED overlapped = { 0 };
+			overlapped.Offset     = cast(DWORD) (current & 0xFFFFFFFF);
+			overlapped.OffsetHigh = cast(DWORD) ((current >> 32) & 0xFFFFFFFF);
+
+			DWORD toread = (remainder > U32_MAX) ? U32_MAX : (DWORD) remainder;
+			DWORD nread  = 0;
+
+			if (!ReadFile(hFile, buffer, toread, &nread, &overlapped)) {
+				break;
+			}
+
+			buffer    += nread;
+			current   += nread;
+			remainder -= nread;
+		}
+	}
+}
+
+void FS_FileWrite(OS_Handle file, void *ptr, U64 size, U64 offset) {
+	HANDLE hFile = cast(HANDLE) file.v[0];
+	if (hFile) {
+		U8 *buffer    = ptr;
+		U64 current   = offset;
+		U64 remainder = size;
+
+		while (remainder != 0) {
+			OVERLAPPED overlapped = { 0 };
+			overlapped.Offset     = cast(DWORD) (current & 0xFFFFFFFF);
+			overlapped.OffsetHigh = cast(DWORD) ((current >> 32) & 0xFFFFFFFF);
+
+			DWORD towrite  = (remainder > U32_MAX) ? U32_MAX : (DWORD) remainder;
+			DWORD nwritten = 0;
+
+			if (!WriteFile(hFile, buffer, towrite, &nwritten, &overlapped)) {
+				break;
+			}
+
+			buffer    += nwritten;
+			current   += nwritten;
+			remainder -= nwritten;
+		}
+	}
+}
+
+U64 FS_FileSize(OS_Handle file) {
+	U64 result = 0;
+	HANDLE hFile = cast(HANDLE) file.v[0];
+	if (hFile) {
+		DWORD dwLow, dwHigh;
+		dwLow = GetFileSize(hFile, &dwHigh);
+
+		result = ((U64) dwHigh << 32) | ((U64) dwLow);
+	}
+
+	return result;
+}
+
+FS_List FS_PathList(M_Arena *arena, Str8 path) {
+	FS_List result = { 0 };
+
+	M_TempScope(1, &arena) {
+		Str8 wpath = Win32_WideStr(temp.arena, Sf(temp.arena, "%.*s\\*", Sv(path)));
+
+		WIN32_FIND_DATAW find = { 0 };
+		HANDLE hFind = FindFirstFileW((LPCWSTR) wpath.data, &find);
+
+		while (hFind != INVALID_HANDLE_VALUE) {
+			if (find.cFileName[0] != L'.') {
+				FS_Entry *entry = M_ArenaPush(arena, FS_Entry);
+
+				entry->type = (find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? FS_ENTRY_TYPE_DIR : FS_ENTRY_TYPE_FILE;
+
+				entry->basename = Win32_MultiByteStr(arena, find.cFileName);
+				entry->path     = Sf(arena, "%.*s/%.*s", Sv(path), Sv(entry->basename));
+
+				FILETIME *wt = &find.ftLastWriteTime;
+
+				entry->time = ((U64) wt->dwHighDateTime << 32) | ((U64) wt->dwLowDateTime);
+				entry->size = ((U64) find.nFileSizeHigh << 32) | ((U64) find.nFileSizeLow);
+
+				SLL_Enqueue(result.first, result.last, entry);
+
+				result.count += 1;
+			}
+
+			if (!FindNextFileW(hFind, &find)) {
+				break;
+			}
+		}
+	}
+
+	return result;
+}
+
+Str8 FS_SystemPath(M_Arena *arena, FS_SystemPathType path) {
+	Str8 result = { 0 };
+
+	M_TempScope(1, &arena) {
+		switch (path) {
+			case FS_SYSTEM_PATH_EXE: {
+				U64 offset = M_ArenaOffset(temp.arena);
+
+				DWORD err, nchars;
+
+				DWORD  nSize      = 1024;
+				LPWSTR lpFilename = M_ArenaPush(temp.arena, WCHAR, .count = nSize, .flags = M_ARENA_NO_ZERO);
+
+				for (;;) {
+					nchars = GetModuleFileNameW(0, lpFilename, nSize);
+
+					err = GetLastError();
+					if (err != ERROR_INSUFFICIENT_BUFFER) {
+						break;
+					}
+
+					M_ArenaPop(temp.arena, offset);
+
+					nSize      *= 2;
+					lpFilename  = M_ArenaPush(temp.arena, WCHAR, .count = nSize, .flags = M_ARENA_NO_ZERO);
+				}
+
+				if (err == ERROR_SUCCESS) {
+					while (lpFilename[nchars] != '\\') { nchars -= 1; }
+					lpFilename[nchars] = 0;
+
+					result = Win32_MultiByteStr(arena, lpFilename);
+				}
+			}
+			break;
+
+			case FS_SYSTEM_PATH_WORKING: {
+				DWORD nSize = GetCurrentDirectoryW(0, 0);
+
+				if (nSize != 0) {
+					LPWSTR lpBuffer = M_ArenaPush(temp.arena, WCHAR, .count = nSize, .flags = M_ARENA_NO_ZERO);
+					GetCurrentDirectoryW(nSize, lpBuffer);
+
+					result = Win32_MultiByteStr(arena, lpBuffer);
+				}
+			}
+			break;
+
+			case FS_SYSTEM_PATH_USER: {
+				LPWSTR wpath;
+				HRESULT hResult = SHGetKnownFolderPath(&FOLDERID_RoamingAppData, 0, 0, &wpath);
+				if (hResult == S_OK) {
+					result = Win32_MultiByteStr(arena, wpath);
+					CoTaskMemFree(wpath);
+				}
+			}
+			break;
+
+			case FS_SYSTEM_PATH_TEMP: {
+				DWORD nSize     = MAX_PATH + 1;
+				LPWSTR lpBuffer = M_ArenaPush(temp.arena, WCHAR, .count = nSize);
+
+				DWORD nchars = GetTempPathW(nSize, lpBuffer);
+				if (nchars != 0) {
+					lpBuffer[nchars - 1] = 0; // Strip trailing backslash
+					result = Win32_MultiByteStr(arena, lpBuffer);
+				}
+			}
+			break;
+		}
+	}
+
+	return result;
+}

code/vulkan/core.c

@@ -180,6 +180,7 @@ bool Vk_Setup(SDL_Window *window) {
 		features12.storageBuffer8BitAccess           = VK_TRUE;
 		features12.uniformAndStorageBuffer8BitAccess = VK_TRUE;
 		features12.descriptorIndexing                = VK_TRUE;
+		features12.runtimeDescriptorArray            = VK_TRUE;
 
 		// @Todo: we will probably need to enable some of the 'nonuniform' indexing features
 
@@ -330,6 +331,7 @@ bool Vk_Setup(SDL_Window *window) {
 
 		VkResult err = vk.CreateCommandPool(vk.device, &pool, 0, &frame->pool);
 
+		// Base command buffer
 		VkCommandBufferAllocateInfo alloc = { 0 };
 		alloc.sType              = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
 		alloc.commandBufferCount = 1;
@@ -338,21 +340,68 @@ bool Vk_Setup(SDL_Window *window) {
 
 		vk.AllocateCommandBuffers(vk.device, &alloc, &frame->cmd);
 
-		VkSemaphoreCreateInfo semaphore = { 0 };
+		// Scratch command buffers
-		semaphore.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+		VkCommandBuffer scratch[VK_NUM_SCRATCH];
+		alloc.commandBufferCount = VK_NUM_SCRATCH;
 
-		err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->acquire),  err);
+		vk.AllocateCommandBuffers(vk.device, &alloc, scratch);
-		err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->complete), err);
 
 		VkFenceCreateInfo fence = { 0 };
 		fence.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
 		fence.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
+		for (U32 s = 0; s < VK_NUM_SCRATCH; ++s) {
+			frame->scratch[s].handle = scratch[s];
+			err = Min(vk.CreateFence(vk.device, &fence, 0, &frame->scratch[s].fence), err);
+		}
+
+		// Descriptor pool
+		VkDescriptorPoolSize pool_sizes[2] = { 0 };
+
+		pool_sizes[0].type            = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+		pool_sizes[0].descriptorCount = 2048;
+
+		pool_sizes[1].type            = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+		pool_sizes[1].descriptorCount = 2048;
+
+		VkDescriptorPoolCreateInfo descriptor_pool = { 0 };
+		descriptor_pool.sType         = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+		descriptor_pool.maxSets       = 1024;
+		descriptor_pool.poolSizeCount = 2;
+		descriptor_pool.pPoolSizes    = pool_sizes;
+
+		vk.CreateDescriptorPool(vk.device, &descriptor_pool, 0, &frame->descriptors);
+
+		// rect buffer
+		//
+
+		Vk_Buffer *rbo = &frame->rbo;
+		rbo->usage        = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+		rbo->size         = D_MAX_RECTS * sizeof(D_Rect);
+		rbo->host_visible = true;
+
+		Vk_BufferCreate(rbo);
+
+		VkSemaphoreCreateInfo semaphore = { 0 };
+		semaphore.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+
+		err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->acquire),  err);
+		err = Min(vk.CreateSemaphore(vk.device, &semaphore, 0, &frame->complete), err);
 		err = Min(vk.CreateFence(vk.device, &fence, 0, &frame->fence), err);
 
 		vk.err = err;
 	}
 
+	{
+		VkSamplerCreateInfo create_info = { 0 };
+		create_info.sType      = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+		create_info.magFilter  = VK_FILTER_NEAREST;
+		create_info.minFilter  = VK_FILTER_NEAREST;
+		create_info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
+
+		vk.CreateSampler(vk.device, &create_info, 0, &vk.sampler);
+	}
+
 	result = (vk.err == VK_SUCCESS);
 	return result;
 }
@@ -365,6 +414,7 @@ Vk_Frame *Vk_FrameBegin(SDL_Window *window) {
 
 	vk.ResetFences(vk.device, 1, &frame->fence);
 	vk.ResetCommandPool(vk.device, frame->pool, 0);
+	vk.ResetDescriptorPool(vk.device, frame->descriptors, 0);
 
 	VkResult res = vk.AcquireNextImageKHR(vk.device, vk.swapchain.handle, UINT64_MAX, frame->acquire, 0, &frame->image);
 	(void) res; // @Todo: check res to see if swapchain is out of date and rebuild
@@ -374,12 +424,54 @@ Vk_Frame *Vk_FrameBegin(SDL_Window *window) {
 
 	vk.BeginCommandBuffer(frame->cmd, &begin_info);
 
+	VkImageMemoryBarrier2 colour_optimal = { 0 };
+	colour_optimal.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+	colour_optimal.srcStageMask  = VK_PIPELINE_STAGE_2_NONE;
+	colour_optimal.srcAccessMask = VK_ACCESS_2_NONE;
+	colour_optimal.dstStageMask  = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
+	colour_optimal.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
+	colour_optimal.oldLayout     = VK_IMAGE_LAYOUT_UNDEFINED;
+	colour_optimal.newLayout     = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+	colour_optimal.image         = vk.swapchain.images[frame->image];
+
+	colour_optimal.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	colour_optimal.subresourceRange.layerCount = 1;
+	colour_optimal.subresourceRange.levelCount = 1;
+
+	VkDependencyInfo colour_barrier = { 0 };
+	colour_barrier.sType                   = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
+	colour_barrier.imageMemoryBarrierCount = 1;
+	colour_barrier.pImageMemoryBarriers    = &colour_optimal;
+
+	vk.CmdPipelineBarrier2(frame->cmd, &colour_barrier);
+
 	return frame;
 }
 
 void Vk_FrameEnd() {
 	Vk_Frame *frame = &vk.frames[vk.n_frames % vk.in_flight];
 
+	VkImageMemoryBarrier2 present_src = { 0 };
+	present_src.sType         = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
+	present_src.srcStageMask  = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
+	present_src.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
+	present_src.dstStageMask  = VK_PIPELINE_STAGE_2_NONE;
+	present_src.dstAccessMask = VK_ACCESS_2_NONE;
+	present_src.oldLayout     = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+	present_src.newLayout     = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+	present_src.image         = vk.swapchain.images[frame->image];
+
+	present_src.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	present_src.subresourceRange.layerCount = 1;
+	present_src.subresourceRange.levelCount = 1;
+
+	VkDependencyInfo to_present = { 0 };
+	to_present.sType                   = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
+	to_present.imageMemoryBarrierCount = 1;
+	to_present.pImageMemoryBarriers    = &present_src;
+
+	vk.CmdPipelineBarrier2(frame->cmd, &to_present);
+
 	vk.EndCommandBuffer(frame->cmd);
 
 	VkPipelineStageFlags stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
@@ -408,3 +500,226 @@ void Vk_FrameEnd() {
 
 	vk.n_frames += 1;
 }
+
+Vk_CommandBuffer *Vk_CommandBufferPush() {
+	Vk_Frame *frame = &vk.frames[vk.n_frames % vk.in_flight];
+
+	// If this scratch buffer is still in use wait for it to finish, this is _bad_ but we
+	// shouldn't hit this
+	U32 idx = frame->next_scratch & (VK_NUM_SCRATCH - 1);
+
+	Vk_CommandBuffer *result = &frame->scratch[idx];
+
+	vk.WaitForFences(vk.device, 1, &result->fence, VK_TRUE, U64_MAX);
+	vk.ResetFences(vk.device, 1, &result->fence);
+
+	VkCommandBufferBeginInfo begin_info = { 0 };
+	begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+
+	vk.BeginCommandBuffer(result->handle, &begin_info);
+
+	return result;
+}
+
+void Vk_CommandBufferSubmit(Vk_CommandBuffer *cmds, B32 wait) {
+	vk.EndCommandBuffer(cmds->handle);
+
+	VkSubmitInfo submit_info = { 0 };
+	submit_info.sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+	submit_info.commandBufferCount   = 1;
+	submit_info.pCommandBuffers      = &cmds->handle;
+
+	vk.QueueSubmit(vk.queue.handle, 1, &submit_info, cmds->fence);
+
+	if (wait) { vk.DeviceWaitIdle(vk.device); }
+}
+
+#define VK_HOST_VISIBLE_FLAGS (VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
+
+internal VkDeviceMemory Vk_Allocate(VkMemoryRequirements *mreq, VkMemoryPropertyFlags usage) {
+	VkDeviceMemory result = VK_NULL_HANDLE;
+
+	VkPhysicalDeviceMemoryProperties2 _props = { 0 };
+	_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
+
+	vk.GetPhysicalDeviceMemoryProperties2(vk.gpu, &_props);
+
+	// ?????
+	VkPhysicalDeviceMemoryProperties *props = &_props.memoryProperties;
+
+	U32 type_index = U32_MAX;
+
+	for (U32 it = 0; it < props->memoryTypeCount; ++it) {
+		VkMemoryType *type = &props->memoryTypes[it];
+		if ((type->propertyFlags & usage) == usage) {
+			type_index = it;
+			break;
+		}
+	}
+
+	if (type_index != U32_MAX) {
+		VkMemoryAllocateInfo alloc_info = { 0 };
+		alloc_info.sType           = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+		alloc_info.allocationSize  = mreq->size;
+		alloc_info.memoryTypeIndex = type_index;
+
+		vk.AllocateMemory(vk.device, &alloc_info, 0, &result);
+	}
+
+	Assert(result != VK_NULL_HANDLE);
+	return result;
+}
+
+void Vk_BufferCreate(Vk_Buffer *buffer) {
+	VkBufferCreateInfo create_info = { 0 };
+	create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+	create_info.usage = buffer->usage;
+	create_info.size  = buffer->size;
+
+	vk.CreateBuffer(vk.device, &create_info, 0, &buffer->handle);
+	Assert(buffer->handle != VK_NULL_HANDLE);
+
+	VkMemoryRequirements req;
+	vk.GetBufferMemoryRequirements(vk.device, buffer->handle, &req);
+
+	VkMemoryPropertyFlags usage = buffer->host_visible ? VK_HOST_VISIBLE_FLAGS : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+
+	buffer->size   = req.size;
+	buffer->memory = Vk_Allocate(&req, usage);
+
+	vk.BindBufferMemory(vk.device, buffer->handle, buffer->memory, 0);
+
+	if (buffer->host_visible) {
+		vk.MapMemory(vk.device, buffer->memory, 0, buffer->size, 0, &buffer->data);
+	}
+
+}
+
+void Vk_ImageCreate(Vk_Image *image) {
+	VkImageCreateInfo create_info = { 0 };
+	create_info.sType         = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+	create_info.imageType     = VK_IMAGE_TYPE_2D;
+	create_info.format        = image->format;
+	create_info.extent.width  = image->width;
+	create_info.extent.height = image->height;
+	create_info.extent.depth  = 1;
+	create_info.mipLevels     = 1;
+	create_info.arrayLayers   = 1;
+	create_info.usage         = VK_IMAGE_USAGE_TRANSFER_DST_BIT | image->usage;
+	create_info.samples       = VK_SAMPLE_COUNT_1_BIT;
+	create_info.tiling        = VK_IMAGE_TILING_OPTIMAL;
+
+	vk.CreateImage(vk.device, &create_info, 0, &image->handle);
+
+	VkMemoryRequirements req;
+	vk.GetImageMemoryRequirements(vk.device, image->handle, &req);
+
+	image->size   = req.size;
+	image->memory = Vk_Allocate(&req, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+	vk.BindImageMemory(vk.device, image->handle, image->memory, 0);
+
+	VkImageViewCreateInfo view_info = { 0 };
+	view_info.sType    = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+	view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
+	view_info.format   = image->format;
+	view_info.image    = image->handle;
+
+	view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+	view_info.subresourceRange.levelCount = 1;
+	view_info.subresourceRange.layerCount = 1;
+
+	vk.CreateImageView(vk.device, &view_info, 0, &image->view);
+}
+
+void Vk_PipelineCreate(Vk_Pipeline *pipeline) {
+	VkPipelineInputAssemblyStateCreateInfo ia = { 0 };
+	ia.sType    = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+	ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+
+	VkPipelineShaderStageCreateInfo shaders[8] = { 0 };
+	for (U32 it = 0; it < pipeline->shaders.count; ++it) {
+		shaders[it].sType  = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+		shaders[it].stage  = pipeline->shaders.items[it].stage;
+		shaders[it].module = pipeline->shaders.items[it].handle;
+		shaders[it].pName  = "main";
+	}
+
+	VkPipelineVertexInputStateCreateInfo vi = { 0 };
+	vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+
+	// This will be updated later using dynamic commands but we still need to supply one here for
+	// some reason
+	VkViewport viewport = { 0, 0, 10, 10, 0, 1 };
+	VkRect2D   scissor  = { 0, 0, 10, 10 };
+
+	VkPipelineViewportStateCreateInfo vp = { 0 };
+	vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+	vp.viewportCount = 1;
+	vp.pViewports    = &viewport;
+	vp.scissorCount  = 1;
+	vp.pScissors     = &scissor;
+
+	VkPipelineRasterizationStateCreateInfo rs = { 0 };
+	rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+	rs.lineWidth = 1.0f;
+
+	VkPipelineMultisampleStateCreateInfo ms = { 0 };
+	ms.sType                = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+	ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+
+	VkPipelineDepthStencilStateCreateInfo ds = { 0 };
+	ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+
+	VkPipelineColorBlendAttachmentState blend = { 0 };
+	blend.blendEnable         = VK_TRUE;
+	blend.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+	blend.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+	blend.colorBlendOp        = VK_BLEND_OP_ADD;
+	blend.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+	blend.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
+	blend.alphaBlendOp        = VK_BLEND_OP_ADD;
+	blend.colorWriteMask      = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+
+	VkPipelineColorBlendStateCreateInfo om = { 0 };
+	om.sType           = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+	om.attachmentCount = 1;
+	om.pAttachments    = &blend;
+
+	VkDynamicState dynamic_state[] = {
+		VK_DYNAMIC_STATE_VIEWPORT,
+		VK_DYNAMIC_STATE_SCISSOR
+	};
+
+	VkPipelineDynamicStateCreateInfo dyn = { 0 };
+	dyn.sType             = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+	dyn.dynamicStateCount = ArraySize(dynamic_state);
+	dyn.pDynamicStates    = dynamic_state;
+
+	VkFormat formats[8];
+	for (U32 it = 0; it < pipeline->targets.count; ++it) {
+		formats[it] = pipeline->targets.items[it];
+	}
+
+	VkPipelineRenderingCreateInfo rendering_info = { 0 };
+	rendering_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
+	rendering_info.colorAttachmentCount    = pipeline->targets.count;
+	rendering_info.pColorAttachmentFormats = formats;
+
+	VkGraphicsPipelineCreateInfo create_info = { 0 };
+	create_info.sType               = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+	create_info.pNext               = &rendering_info;
+	create_info.stageCount          = pipeline->shaders.count;
+	create_info.pStages             = shaders;
+	create_info.pVertexInputState   = &vi;
+	create_info.pInputAssemblyState = &ia;
+	create_info.pViewportState      = &vp;
+	create_info.pRasterizationState = &rs;
+	create_info.pMultisampleState   = &ms;
+	create_info.pDepthStencilState  = &ds;
+	create_info.pColorBlendState    = &om;
+	create_info.pDynamicState       = &dyn;
+	create_info.layout              = pipeline->layout.pipeline;
+
+	vk.CreateGraphicsPipelines(vk.device, 0, 1, &create_info, 0, &pipeline->handle);
+}

code/vulkan/core.h

@@ -23,15 +23,81 @@
 #define function static
 
 #define VK_MAX_FRAMES_IN_FLIGHT 8
+#define VK_NUM_SCRATCH 8
+
+typedef struct Vk_Image Vk_Image;
+struct Vk_Image {
+	VkDeviceMemory memory;
+	VkDeviceSize   size;
+
+	VkImage handle;
+	VkImageView view;
+
+	VkFormat format;
+	VkImageUsageFlags usage;
+	U32 width, height;
+};
+
+typedef struct Vk_Buffer Vk_Buffer;
+struct Vk_Buffer {
+	VkBuffer handle;
+
+	VkDeviceMemory memory;
+	VkDeviceSize   size;
+
+	VkBufferUsageFlags usage;
+
+	B32 host_visible;
+	void *data; // if mapped host visible memory
+};
+
+typedef struct Vk_Shader Vk_Shader;
+struct Vk_Shader {
+	VkShaderModule handle;
+	VkShaderStageFlags stage;
+};
+
+typedef struct Vk_Pipeline Vk_Pipeline;
+struct Vk_Pipeline {
+	VkPipeline handle;
+
+	struct {
+		VkPipelineLayout pipeline;
+		VkDescriptorSetLayout set;
+	} layout;
+
+	struct {
+		VkFormat items[8];
+		U32 count;
+	} targets;
+
+	struct {
+		Vk_Shader items[8];
+		U32 count;
+	} shaders;
+};
+
+typedef struct Vk_CommandBuffer Vk_CommandBuffer;
+struct Vk_CommandBuffer {
+	VkCommandBuffer handle;
+	VkFence fence;
+};
 
 typedef struct Vk_Frame Vk_Frame;
 struct Vk_Frame {
 	VkCommandPool   pool;
 	VkCommandBuffer cmd;
 
+	VkDescriptorPool descriptors;
+
 	VkSemaphore acquire, complete;
 	VkFence fence;
 
+	U32 next_scratch;
+	Vk_CommandBuffer scratch[VK_NUM_SCRATCH];
+
+	Vk_Buffer rbo;
+
 	U32 image; // swapchain image index
 };
 
@@ -77,6 +143,8 @@ struct Vk_Context {
 		U32 width;
 		U32 height;
 	} swapchain;
+
+	VkSampler sampler;
 };
 
 extern Vk_Context vk;
@@ -86,4 +154,10 @@ function bool Vk_Setup(SDL_Window *window);
 function Vk_Frame *Vk_FrameBegin(SDL_Window *window);
 function void Vk_FrameEnd();
 
+function Vk_CommandBuffer *Vk_CommandBufferPush();
+function void              Vk_CommandBufferSubmit(Vk_CommandBuffer *cmds, B32 wait);
+
+function void Vk_BufferCreate(Vk_Buffer *buffer);
+function void Vk_ImageCreate(Vk_Image *image);
+
 #endif  // LD_VULKAN_CORE_H_

code/vulkan/functions.h

@@ -6,6 +6,7 @@
 	VK_FUNC(GetDeviceProcAddr);
 	VK_FUNC(GetPhysicalDeviceSurfaceCapabilitiesKHR);
 	VK_FUNC(GetPhysicalDeviceSurfaceFormatsKHR);
+	VK_FUNC(GetPhysicalDeviceMemoryProperties2);
 
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
 	VK_FUNC(CreateWin32SurfaceKHR);
@@ -39,7 +40,33 @@
 	VK_FUNC(BeginCommandBuffer);
 	VK_FUNC(EndCommandBuffer);
 	VK_FUNC(DeviceWaitIdle);
+	VK_FUNC(AllocateMemory);
+	VK_FUNC(CreateBuffer);
+	VK_FUNC(GetBufferMemoryRequirements);
+	VK_FUNC(BindBufferMemory);
+	VK_FUNC(CreateImage);
+	VK_FUNC(GetImageMemoryRequirements);
+	VK_FUNC(BindImageMemory);
+	VK_FUNC(MapMemory);
+	VK_FUNC(CreateGraphicsPipelines);
+	VK_FUNC(CreateShaderModule);
+	VK_FUNC(CreateDescriptorSetLayout);
+	VK_FUNC(CreatePipelineLayout);
+	VK_FUNC(CmdBindPipeline);
+	VK_FUNC(CreateDescriptorPool);
+	VK_FUNC(ResetDescriptorPool);
+	VK_FUNC(AllocateDescriptorSets);
+	VK_FUNC(CmdBindDescriptorSets);
+	VK_FUNC(UpdateDescriptorSets);
+	VK_FUNC(CreateSampler);
+	VK_FUNC(CmdDraw);
+	VK_FUNC(CmdSetViewport);
+	VK_FUNC(CmdSetScissor);
+	VK_FUNC(CmdDrawIndexed);
+	VK_FUNC(CmdBindIndexBuffer);
 
+	VK_FUNC(CmdPushConstants);
+	VK_FUNC(CmdCopyBufferToImage);
 	VK_FUNC(CmdPipelineBarrier2);
 	VK_FUNC(CmdBeginRendering);
 	VK_FUNC(CmdEndRendering);

code/vulkan/shaders/basic.frag

@@ -0,0 +1,15 @@
+#version 460 core
+
+#extension GL_EXT_nonuniform_qualifier : enable
+
+layout(location = 0) in vec2 frag_uv;
+layout(location = 1) in vec4 frag_c;
+layout(location = 2) in flat uint texid;
+
+layout(location = 0) out vec4 framebuffer;
+
+layout(binding = 1) uniform sampler2D u_images[];
+
+void main() {
+	framebuffer = frag_c * texture(u_images[texid], frag_uv);
+}

code/vulkan/shaders/basic.vert

@@ -0,0 +1,64 @@
+#version 460 core
+
+#extension GL_EXT_scalar_block_layout : enable
+
+uint indices[6] = { 0, 1, 3, 0, 3, 2 };
+
+vec2 verticies[4] = vec2[](
+		vec2(-0.5, -0.5),
+		vec2( 0.5, -0.5),
+		vec2(-0.5,  0.5),
+		vec2( 0.5,  0.5)
+);
+
+struct G_Rect {
+	uint id;
+
+	uint   c[4];
+	float uv[4];
+
+	float angle;
+	float x, y;
+	float w, h;
+
+	float _pad0, _pad1;
+};
+
+struct Vertex {
+	vec4 p;
+	vec2 uv;
+	uint c;
+	uint pad;
+};
+
+layout(push_constant, row_major)
+uniform Global {
+	mat4 proj;
+};
+
+layout(binding = 0, scalar)
+readonly buffer Rect {
+	G_Rect rects[];
+};
+
+layout(location = 0) out vec2 frag_uv;
+layout(location = 1) out vec4 frag_c;
+layout(location = 2) out flat uint texid;
+
+vec4 unorm_colour(uint c) {
+	vec4 result = vec4((c >> 0) & 0xFF, (c >> 8) & 0xFF, (c >> 16) & 0xFF, (c >> 24) & 0xFF) / 255.0f;
+	return result;
+}
+
+void main() {
+	G_Rect rect = rects[gl_InstanceIndex];
+	uint   idx  = indices[gl_VertexIndex];
+
+	vec2 p = (verticies[idx] * vec2(rect.w, rect.h)) + vec2(rect.x, rect.y);
+
+	gl_Position = proj * vec4(p, 1.0f, 1.0f);
+
+	frag_uv = vec2(rect.uv[(idx & 1) << 1], rect.uv[1 + (uint(idx / 2) << 1)]);
+	frag_c  = unorm_colour(rect.c[idx]);
+	texid   = rect.id;
+}

linux

@@ -12,6 +12,7 @@ pushd "build" > /dev/null
 
 release=0
 deps=0
+assets=0
 
 for a in $*
 do
@@ -23,6 +24,11 @@ then
 	deps=1
 fi
 
+if [[ ! -d "assets" ]]
+then
+	assets=1
+fi
+
 if [[ $deps == 1 ]]
 then
 	# We don't build SDL3 like on windows, this assumes you have it installed instead. We can't
@@ -35,10 +41,24 @@ then
 	cp ../thirdparty/stb/*.h deps/stb
 fi
 
+if [[ $assets == 1 ]]
+then
+	echo "[Copying assets]"
+
+	cp -r "../assets" .
+fi
+
+echo "[Building shaders]"
+
+[[ ! -d "assets/shaders" ]] && mkdir "assets/shaders"
+
+glslangValidator -o "assets/shaders/basic.vert.spv" --target-env "vulkan1.3" "../code/vulkan/shaders/basic.vert"
+glslangValidator -o "assets/shaders/basic.frag.spv" --target-env "vulkan1.3" "../code/vulkan/shaders/basic.frag"
+
 echo "[Building source]"
 
-COMPILER_OPTS="-Wall -Wno-missing-braces -I'deps/stb'"
+COMPILER_OPTS="-Wall -Wno-missing-braces -Wno-unused-function -Ideps/stb -I../code"
-LINKER_OPTS="-lSDL3"
+LINKER_OPTS="-lSDL3 -lm"
 
 if [[ $release == 1 ]]
 then

windows.bat

@@ -9,6 +9,7 @@ PUSHD "build"
 
 SET deps=0
 SET release=0
+SET assets=0
 
 FOR %%A in (%*) DO (
 	SET %%A=1
@@ -51,10 +52,23 @@ IF %deps% equ 1 (
 	COPY "..\thirdparty\stb\*.h" "deps\stb" > NUL
 )
 
+IF %assets% equ 1 (
+	ECHO [Copying assets]
+
+	xcopy /Y /Q "..\assets" "assets"
+)
+
+ECHO [Building shaders]
+
+IF NOT EXIST "assets\shaders" ( MKDIR "assets\shaders" )
+
+glslangValidator -o "assets\shaders\basic.vert.spv" --target-env vulkan1.3 "..\code\vulkan\shaders\basic.vert"
+glslangValidator -o "assets\shaders\basic.frag.spv" --target-env vulkan1.3 "..\code\vulkan\shaders\basic.frag"
+
 ECHO [Building source]
 
-SET COMPILER_OPTS=-nologo -W4 -I"deps\SDL3\include" -I"deps\stb" -I"%VULKAN_SDK%\Include"
+SET COMPILER_OPTS=-nologo -W4 -I"deps\SDL3\include" -I"deps\stb" -I"%VULKAN_SDK%\Include" -I"..\code"
-SET LINKER_OPTS=-LIBPATH:"deps\SDL3\lib" SDL3.lib
+SET LINKER_OPTS=-LIBPATH:"deps\SDL3\lib" SDL3.lib Ole32.lib Shell32.lib
 
 IF %release% equ 1 (
 	ECHO [Release build]