add ignore

code/core/impl/math.c

@@ -1,22 +1,8 @@
-#include <math.h>
 V2f V2F(F32 x, F32 y) {
 	V2f result = { x, y };
 	return result;
 }
 
-function V2f V2f_Scale(V2f x, F32 scale) {
-  return V2F(x.x * scale, x.y * scale);
-}
-
-V2f NormaliseV2F(V2f x) {
-  F32 magnitude = sqrtf((x.x * x.x) + (x.y * x.y));
-  if(magnitude > 0.0){
-    F32 inverse = 1.0f/magnitude;
-    return V2F(x.x*inverse, x.y*inverse);
-  }
-  return x;
-}
-
 V3f V3F(F32 x, F32 y, F32 z) {
 	V3f result = { x, y, z };
 	return result;
@@ -42,11 +28,6 @@ V3f V3f_Scale(V3f x, F32 s) {
 	return result;
 }
 
-V3f V3f_Sub(V3f a, V3f b) {
-	V3f result = { a.x - b.x, a.y - b.y, a.z - b.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;
@@ -159,7 +140,7 @@ Mat4x4FInv M4x4F_CameraView(V3f x, V3f y, V3f z, V3f p) {
 	//
 	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, z));
+	V3f iz = V3f_Scale(z, 1.0f / V3f_Dot(z, y));
 
 	// Calculate inverse position
 	//
@@ -179,55 +160,4 @@ Mat4x4FInv M4x4F_CameraView(V3f x, V3f y, V3f z, V3f p) {
 	return result;
 }
 
-// Random
-
-Random Random_Seed(U64 seed) {
-	Random result = { seed };
-	return result;
-}
-
-U64 Random_Next(Random *rnd) {
-	U64 result = rnd->state;
-
-	result ^= (result << 13);
-	result ^= (result >>  7);
-	result ^= (result << 17);
-
-	rnd->state = result;
-
-	return result;
-}
-
-F32 Random_F32(Random *rnd, F32 min, F32 max) {
-	F32 result = min + (Random_Unilateral(rnd) * (max - min));
-	return result;
-}
-
-F64 Random_F64(Random *rnd, F64 min, F64 max) {
-	F64 result = min + (Random_Unilateral(rnd) * (max - min));
-	return result;
-}
-
-U32 Random_U32(Random *rnd, U32 min, U32 max) {
-	U32 result = min + (U32) (Random_Unilateral(rnd) * (max - min));
-	return result;
-}
-
-F32 Random_Unilateral(Random *rnd) {
-	F32 result = Random_Next(rnd) / (F32) U64_MAX;
-	return result;
-}
-
-F32 Random_Bilateral(Random *rnd) {
-	F32 result = -1.0f + (2.0f * Random_Unilateral(rnd));
-	return result;
-}
-
-V2f V2f_Clip(V2f screen_xy, V2f screen_size) {
-    V2f result;
-    result.x = ((screen_xy.x / screen_size.w) * 2.0f) - 1.0f;
-    result.y = ((screen_xy.y / screen_size.h) * 2.0f) - 1.0f;
-
-    return result;
-}
 

code/core/impl/string.c

@@ -29,20 +29,6 @@ Str8 Str8_WrapZ(U8 *data) {
 	return result;
 }
 
-#define FNV_OFFSET_BIAS ((U64) 0xCBF29CE484222325)
-#define FNV_PRIME       ((U64) 0x100000001B3)
-
-U64 Str8_Hash(Str8 v) {
-	U64 result = FNV_OFFSET_BIAS;
-
-	for (S64 it = 0; it < v.count; ++it) {
-		result ^= v.data[it];
-		result *= FNV_PRIME;
-	}
-
-	return result;
-}
-
 Str8 Str8_Copy(M_Arena *arena, Str8 s) {
 	Str8 result;
 	result.count = s.count;

code/core/macros.h

@@ -36,11 +36,6 @@
 #define SLL_PopN(h, next) (((h) != 0) ? (h) = (h)->next : 0)
 
 #define SLL_Enqueue(h, t, n) SLL_EnqueueN(h, t, n, next)
-#define SLL_EnqueueFront(h, t, n) SLL_EnqueueFrontN(h, t, n, next)
-#define SLL_Dequeue(h, t) SLL_DequeueN(h, t, next)
-
-#define SLL_Push(h, n) SLL_PushN(h, n, next)
-#define SLL_Pop(h) (((h) != 0) ? (h) = (h)->next : 0)
 
 #define function      static
 #define internal      static

code/core/math.h

@@ -4,13 +4,6 @@
 #define PI_F32  (3.14159265358979323846264338f)
 #define TAU_F32 (2.0f * PI_F32)
 
-#define Abs(x) (((x) < 0 ? -(x) : (x)))
-
-typedef struct Random Random;
-struct Random {
-	U64 state;
-};
-
 typedef union V2f V2f;
 union V2f {
 	struct {
@@ -100,23 +93,14 @@ struct R2f {
 	V2f max;
 };
 
-typedef struct R3f R3f;
-struct R3f {
-	V3f min;
-	V3f 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 V2f V2f_Scale(V2f x, F32 s);
-
 function V3f V3f_Neg(V3f x);
 function V3f V3f_Scale(V3f x, F32 s);
-function V3f V3f_Sub(V3f a, V3f b);
 
 function F32 V3f_Dot(V3f a, V3f b);
 function F32 V4f_Dot(V4f a, V4f b);
@@ -130,23 +114,4 @@ 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);
 
-function V2f NormaliseV2F(V2f x);
-function V2f V2f_Scale(V2f x, F32 scale);
-
-// Random
-
-function Random Random_Seed(U64 seed);
-
-function U64 Random_Next(Random *rnd);
-
-function F32 Random_F32(Random *rnd, F32 min, F32 max);
-function F64 Random_F64(Random *rnd, F64 min, F64 max);
-
-function U32 Random_U32(Random *rnd, U32 min, U32 max);
-
-function F32 Random_Unilateral(Random *rnd);
-function F32 Random_Bilateral(Random *rnd);
-
-V2f V2f_Clip(V2f screen_xy, V2f screen_size);
-
 #endif  // LD_CORE_MATH_H_

code/core/string.h

@@ -11,8 +11,6 @@ function Str8 Str8_Wrap(S64 count, U8 *data);
 function Str8 Str8_WrapRange(U8 *start, U8 *end);
 function Str8 Str8_WrapZ(U8 *data);
 
-function U64 Str8_Hash(Str8 v);
-
 function Str8 Str8_Copy(M_Arena *arena, Str8 s);
 
 function Str8 Str8_Format(M_Arena *arena, const char *format, ...);

code/core/types.h

@@ -34,7 +34,4 @@ struct Str8 {
 #define U32_MAX ((U32) -1)
 #define U64_MAX ((U64) -1)
 
-#define F32_MAX ((F32) 3.40282346638528859811704183484516925e+038F)
-#define F64_MAX ((F64) 1.79769313486231570814527423731704357e+308L)
-
 #endif  // LD_CORE_TYPES_H_

code/draw/core.c

@@ -1,59 +1,3 @@
-
-U32 D_ImageHandle(D_Context *draw, Str8 name) {
-	U32 result = 0;
-
-	U64 hash  = Str8_Hash(name);
-	U64 index = hash & (D_ASSET_HASH_COUNT - 1);
-
-	D_AssetHash *lookup = draw->lookup[index];
-	while (lookup != 0) {
-		if (lookup->hash == hash && Str8_Equal(lookup->value, name, 0)) {
-			result = lookup->id;
-			break;
-		}
-
-		lookup = lookup->next;
-	}
-
-	return result;
-}
-
-
-void D_AnimationInit(D_Animation *a, U32 id, U32 rows, U32 cols, F32 time) {
-	a->id = id;
-
-	a->rows = rows;
-	a->cols = cols;
-
-	a->time = 0;
-	a->frame_time = time;
-
-	a->frame = V2F(1.0f / (F32) cols, 1.0f / (F32) rows);
-
-	a->index = 0;
-}
-
-R2f D_AnimationFrame(D_Animation *a) {
-	R2f result = { 0 };
-
-	U32 row = a->index / a->cols;
-	U32 col = a->index % a->cols;
-
-	result.min = V2F(a->frame.w * col, a->frame.h * row);
-	result.max = V2F(result.min.x + a->frame.w, result.min.y + a->frame.h);
-	return result;
-}
-
-void D_AnimationUpdate(D_Animation *a, F32 dt) {
-	a->time += dt;
-	if (a->time >= a->frame_time) {
-		a->time   = 0;
-		a->index += 1;
-
-		if (a->index >= (a->rows * a->cols)) { a->index = 0; }
-	}
-}
-
 void D_Begin(D_Context *draw, Vk_Frame *frame, U32 max_rects) {
 	Vk_Buffer *rbo   = &frame->rbo;
 
@@ -86,8 +30,7 @@ void D_End(D_Context *draw, Vk_Frame *frame) {
 		rbo_info.offset = 0;
 		rbo_info.range  = VK_WHOLE_SIZE;
 
-		U32 total = draw->n_images + draw->n_fonts;
+		VkDescriptorImageInfo *image_info = M_ArenaPush(temp.arena, VkDescriptorImageInfo, .count = draw->n_images);
-		VkDescriptorImageInfo *image_info = M_ArenaPush(temp.arena, VkDescriptorImageInfo, .count = total);
 
 		for (U32 it = 0; it < draw->n_images; ++it) {
 			image_info[it].imageView   = draw->images[it].image.view;
@@ -95,15 +38,6 @@ void D_End(D_Context *draw, Vk_Frame *frame) {
 			image_info[it].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 		}
 
-		U32 idx = draw->n_images;
-		for (D_Font *it = draw->fonts; it != 0; it = it->next) {
-			image_info[idx].imageView   = it->image.view;
-			image_info[idx].sampler     = vk.sampler; // @Todo: probably want linear filtering on fonts
-			image_info[idx].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-
-			idx += 1;
-		}
-
 		writes[0].sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		writes[0].dstSet          = set;
 		writes[0].dstBinding      = 0;
@@ -114,7 +48,7 @@ void D_End(D_Context *draw, Vk_Frame *frame) {
 		writes[1].sType           = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 		writes[1].dstSet          = set;
 		writes[1].dstBinding      = 1;
-		writes[1].descriptorCount = total;
+		writes[1].descriptorCount = draw->n_images;
 		writes[1].descriptorType  = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
 		writes[1].pImageInfo      = image_info;
 
@@ -177,200 +111,22 @@ void _D_Rect(D_Context *draw, D_RectOpts *opts) {
 		}
 
 		if (opts->flags & D_RECT_IGNORE_ASPECT) {
-			rect->w = opts->dim.w;
+			rect->w = opts->w;
-			rect->h = opts->dim.h;
+			rect->h = opts->h;
 		}
 		else {
 			Vk_Image *image = &draw->images[opts->texture].image;
 
-			F32 width  = cast(F32) image->width;
+			if (image->width > image->height) {
-			F32 height = cast(F32) image->height;
+				rect->w = opts->scale * ((F32) image->width / (F32) image->height);
-
+				rect->h = opts->scale;
-			if (opts->flags & D_RECT_UV_ASPECT) {
+			}
-				width  *= (opts->uv.max.x - opts->uv.min.x);
+			else {
-				height *= (opts->uv.max.y - opts->uv.min.y);
+				rect->w = opts->scale;
+				rect->h = opts->scale * ((F32) image->height / (F32) image->width);
 			}
-
-			F32 aspect_w = (width > height) ? (width / height) : 1.0f;
-			F32 aspect_h = (width > height) ? 1.0f : (height / width);
-
-			rect->w = opts->scale * aspect_w;
-			rect->h = opts->scale * aspect_h;
 		}
 
 		draw->n_rects += 1;
 	}
 }
-
-void D_Text(D_Context *draw, D_Font *font, Str8 text, F32 x, F32 y) {
-	F32 xoff = x;
-	local_persist B32 done = 0;
-
-	for (S64 it = 0; it < text.count; ++it) {
-		if (text.data[it] >= ' ' && text.data[it] <= '~') {
-			D_Glyph *glyph = &font->glyphs[text.data[it] - ' '];
-
-			V2f size;
-			size.w = (glyph->box.max.x - glyph->box.min.x);
-			size.h = (glyph->box.max.y - glyph->box.min.y);
-
-			V2f dim;
-
-			F32 scale = 150.0f / (font->ascent - font->descent);
-
-			if (size.w > size.h) {
-				dim.w = scale * (size.w / size.h);
-				dim.h = scale;
-			}
-			else {
-				dim.w = scale;
-				dim.h = scale * (size.h / size.w);
-			}
-
-			// @Hardcode: need font index in font struct
-			D_Rect(draw, xoff, y, .texture = 0, .c = V4F(0, 1, 1, 1), .dim = dim, .flags = D_RECT_IGNORE_ASPECT);
-			D_Rect(draw, xoff, y, .texture = draw->n_images, .uv = glyph->box, .dim = dim, .flags = D_RECT_IGNORE_ASPECT);
-			xoff += (1.05f * dim.w); // glyph->advance; //+ glyph->offset.x;
-
-			if (!done) { printf(" %f (%f, %f)", xoff, dim.w, dim.h); }
-		}
-	}
-
-	if (!done) { printf("\n"); }
-	done = true;
-}
-
-void D_FontLoad(D_Context *draw, Str8 name, F32 size) {
-	M_TempScope(0, 0) {
-		(void) draw;
-
-		Str8 exe_path = FS_SystemPath(temp.arena, FS_SYSTEM_PATH_EXE);
-		Str8 path = Sf(temp.arena, "%.*s/assets/%.*s.ttf", Sv(exe_path), Sv(name));
-
-		Str8 font_data = FS_ReadEntireFile(temp.arena, path);
-
-		stbtt_fontinfo info = { 0 };
-		stbtt_InitFont(&info, font_data.data, 0);
-
-		F32 scale = stbtt_ScaleForPixelHeight(&info, 20);
-
-		U32 w = 512;
-		U32 h = 512;
-
-		U8 *pixels = M_ArenaPush(temp.arena, U8, .count = (w * h));
-
-		stbtt_pack_context pack = { 0 };
-		stbtt_PackBegin(&pack, pixels, w, h, 0, 1, 0);
-
-		U32 count = '~' - ' ';
-		stbtt_packedchar *packed = M_ArenaPush(temp.arena, stbtt_packedchar, .count = count);
-		stbtt_PackFontRange(&pack, font_data.data, 0, size, ' ', count, packed);
-
-		D_Font *font = M_ArenaPush(draw->arena, D_Font);
-
-		font->px = size;
-
-		S32 asc, desc, line;
-		stbtt_GetFontVMetrics(&info, &asc, &desc, &line);
-
-		font->line_advance = cast(F32) line;
-		font->ascent       = cast(F32) asc;
-		font->descent      = cast(F32) desc;
-
-		font->glyphs = M_ArenaPush(draw->arena, D_Glyph, .count = count);
-
-		for (U32 it = 0; it < count; ++it) {
-			D_Glyph *glyph = &font->glyphs[it];
-			stbtt_packedchar *chr = &packed[it];
-
-			S32 left, width;
-			stbtt_GetCodepointHMetrics(&info, ' ' + it, &width, &left);
-
-			glyph->box = R2F(V2F(chr->x0 / (F32) w, chr->y0 / (F32) h), V2F(chr->x1 / (F32) w, chr->y1 / (F32) h));
-
-			glyph->advance = glyph->box.max.x - glyph->box.min.x; //chr->xadvance * scale;
-			glyph->offset  = V2F(chr->xoff * scale, chr->yoff * scale);
-		}
-
-		Vk_Buffer *staging = &draw->staging;
-		U32 *px = (U32 *) staging->data;
-		for (U32 y = 0; y < h; ++y) {
-			for (U32 x = 0; x < w; ++x) {
-				*px++ = 0x0 | ((U32) pixels[(y * w) + x] << 24);
-			}
-		}
-
-		Vk_CommandBuffer *cmds = Vk_CommandBufferPush();
-
-		font->image.width  = w;
-		font->image.height = h;
-
-		font->image.format = VK_FORMAT_R8G8B8A8_SRGB;
-		font->image.usage  = VK_IMAGE_USAGE_SAMPLED_BIT;
-
-		Vk_ImageCreate(&font->image);
-
-		VkBufferImageCopy copy = { 0 };
-
-		copy.bufferOffset      = 0;
-		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;
-
-		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         = font->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         = font->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, font->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
-
-		dep.pImageMemoryBarriers = &shader_read;
-
-		vk.CmdPipelineBarrier2(cmds->handle, &dep);
-
-		Vk_CommandBufferSubmit(cmds, true);
-
-		SLL_PushN(draw->fonts, font, next);
-		draw->n_fonts += 1;
-	}
-}

code/draw/core.h

@@ -1,30 +1,7 @@
 #if !defined(LD_DRAW_CORE_H_)
 #define LD_DRAW_CORE_H_
 
-#define D_MAX_RECTS (262144)
+#define D_MAX_RECTS 1024
-
-typedef struct D_Glyph D_Glyph;
-struct D_Glyph {
-	F32 advance;
-	V2f offset;
-	R2f box;
-};
-
-typedef struct D_Font D_Font;
-struct D_Font {
-	D_Font *next;
-
-	F32 px;
-
-	F32 line_advance;
-	F32 ascent;
-	F32 descent;
-
-	F32 *kerning;
-	D_Glyph *glyphs;
-
-	Vk_Image image;
-};
 
 typedef struct D_Image D_Image;
 struct D_Image {
@@ -48,39 +25,11 @@ struct D_Rect {
 
 StaticAssert(sizeof(D_Rect) == 64);
 
-typedef struct D_Animation D_Animation;
-struct D_Animation {
-	U32 id;
-
-	U32 rows;
-	U32 cols;
-	F32 frame_time;
-	F32 time;
-
-	V2f frame; // size of one frame
-
-	U32 index;
-};
-
 struct G_Camera;
 
-#define D_ASSET_HASH_COUNT 128
-
-typedef struct D_AssetHash D_AssetHash;
-struct D_AssetHash {
-	D_AssetHash *next;
-
-	Str8 value;
-	U64  hash;
-	U32  id; // texture id
-};
-
 typedef struct D_Context D_Context;
 struct D_Context {
 	Vk_Buffer *rbo;
-	Vk_Buffer staging;
-
-	M_Arena *arena;
 
 	U32 n_pipelines;
 	Vk_Pipeline *pipelines;
@@ -88,9 +37,6 @@ struct D_Context {
 	U32 n_images;
 	D_Image *images;
 
-	U32 n_fonts;
-	D_Font *fonts;
-
 	U32 max_rects;
 	U32 n_rects;
 	D_Rect *rects;
@@ -98,8 +44,6 @@ struct D_Context {
 	U32 window_width;
 	U32 window_height;
 
-	D_AssetHash *lookup[D_ASSET_HASH_COUNT];
-
 	struct G_Camera *camera;
 };
 
@@ -107,7 +51,6 @@ 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
-	D_RECT_UV_ASPECT         = (1 << 2), // get the aspect from the uv rect rather than the full image
 };
 
 typedef struct D_RectOpts D_RectOpts;
@@ -122,15 +65,9 @@ struct D_RectOpts {
 	F32 angle;
 
 	union {
-		V2f dim;
-
-		struct {
 		F32 w, h;
-		};
-
-		struct {
 		F32 scale, _h;
-		};
+		V2f dim;
 	};
 
 	union {
@@ -139,20 +76,10 @@ struct D_RectOpts {
 	};
 };
 
-function U32 D_ImageHandle(D_Context *draw, Str8 name);
-
-function void D_AnimationInit(D_Animation *a, U32 id, U32 rows, U32 cols, F32 time);
-function R2f  D_AnimationFrame(D_Animation *a);
-function void D_AnimationUpdate(D_Animation *a, F32 dt);
-
 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_Text(D_Context *draw, D_Font *font, Str8 text, F32 x, F32 y);
-
 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__ })
 
-function void D_FontLoad(D_Context *draw, Str8 path, F32 size);
-
 #endif  // LD_DRAW_CORE_H_

code/first.c

@@ -1,19 +1,13 @@
 #include <stdio.h>
 #include <stdbool.h>
 #include <SDL3/SDL.h>
-#include <SDL3/SDL_keycode.h>
 
 #define STB_IMAGE_IMPLEMENTATION 1
 #include <stb_image.h>
 
-#define STB_RECT_PACK_IMPLEMENTATION 1
-#include <stb_rect_pack.h>
-
-#define STB_TRUETYPE_IMPLEMENTATION 1
-#include <stb_truetype.h>
-
 #include "core/core.h"
 #include "core/types.h"
+#include "game/npc.h"
 #include "os/core.h"
 
 #include "vulkan/core.h"
@@ -23,7 +17,6 @@
 
 #include "game/impl/world.c"
 #include "game/impl/npc.c"
-#include "game/impl/bandit.c"
 #include "game/testnavmesh.h"
 
 int main(int argc, char **argv)
@@ -31,7 +24,7 @@ int main(int argc, char **argv)
 	(void)argc;
 	(void)argv;
 
-	if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO))
+	if (!SDL_Init(SDL_INIT_VIDEO))
 	{
 		printf("[Error] :: Failed to initialise SDL3 (%s)\n", SDL_GetError());
 		return 1;
@@ -44,30 +37,6 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
-	SDL_AudioStream *austream;
-	Str8 audio_data;
-	M_TempScope(0, 0) {
-		SDL_AudioSpec spec;
-		spec.format   = SDL_AUDIO_S16LE;
-		spec.channels = 2;
-		spec.freq     = 44100;
-
-		austream = SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &spec, 0, 0);
-
-		if (!austream) {
-			printf("Failed to open audio stream (%s)\n", SDL_GetError());
-		}
-
-		Str8 exec = FS_SystemPath(temp.arena, FS_SYSTEM_PATH_EXE);
-		Str8 path = Sf(temp.arena, "%.*s/assets/outside_ambience.wav", Sv(exec));
-
-		SDL_AudioSpec wav_spec;
-		U32 count;
-
-		SDL_LoadWAV((const char *) path.data, &wav_spec, &audio_data.data, &count);
-		audio_data.count = count;
-	}
-
 	Vk_Setup(window);
 
 	G_State *game = 0;
@@ -76,11 +45,9 @@ int main(int argc, char **argv)
 		game = M_ArenaPush(arena, G_State);
 
 		game->arena = arena;
-		game->draw.arena = arena;
 
 		G_ImagesLoad(game);
 		G_PipelinesLoad(game);
-		G_AudioLoad(game);
 
 		G_Camera *camera = &game->camera;
 
@@ -95,61 +62,37 @@ int main(int argc, char **argv)
 		camera->farp = 1000.0f;
 
 		game->draw.camera = camera;
-		World *world = M_ArenaPush(arena, World);
-    game->world = world;
-    world->random = Random_Seed(29237489723847);
-    world->npcCount = 2;
-    for(U32 i = 0; i < world->npcCount; i++) {
-    NPC *npc1 = &world->npcs[i];
-      npc1->collision.pos.x = 15;
-      npc1->collision.pos.y = 15;
-      npc1->collision.size.x = 1;
-      npc1->collision.size.y = 2;
-      npc1->name = S("Matt");
-      npc1->mode = NPC_ACTION_WAITING;
-      npc1->currentArea = i;
-      npc1->waitTime = 0;
-      npc1->maxWaitTime = 5;
-      npc1->currentNavNode = 0;
 	}
 
-    Bandit *badman = &world->bandit;
+	Vk_Buffer rbo = {0};
-		badman->collision.pos.x = 15;
+	rbo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-		badman->collision.pos.y = 15;
+	rbo.size = KB(4);
-		badman->collision.size.x = 1;
+	rbo.host_visible = true;
-		badman->collision.size.y = 2;
-		badman->name = S("Leroy Brown");
-		badman->mode = BANDIT_WAITING;
-		badman->waitTime = 0;
-		badman->maxWaitTime = 2;
-		badman->poiCount = 2;
-    badman->pointsOfInterest[0] = 937;
-    badman->pointsOfInterest[1] = 12;
 
-		world->navMesh = &TestNavMesh;
+	Vk_BufferCreate(&rbo);
-		world->npcPOI[0] = 100;
-    world->player.world = world;
-		world->player.pos.x = 0;
-		world->player.pos.y = 0;
-		world->player.bulletsLoaded = PLAYER_BULLET_COUNT;
-		world->player.reloadTimer = 0;
-    world->player.currentArea = 0;
-	}
-
-
-	D_Animation animation;
-	{
-		U32 id = D_ImageHandle(&game->draw, S("npc_front_base_white"));
-		D_AnimationInit(&animation, id, 1, 4, 1.0f / 20.0f);
-	}
 
 	bool running = true;
+	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));
 
-	const int width  = 1280;
-	const int height = 720;
-
 	while (running)
 	{
 		SDL_Event e;
@@ -159,18 +102,9 @@ int main(int argc, char **argv)
 			{
 				running = false;
 			}
-      V3f projection = G_CameraUnproject(&game->camera, V2f_Clip(
+			ProcessEvents(&e, &world);
-        V2F(e.button.x, e.button.y),
-        V2F((F32) width, (F32) height)
-      ));
-      game->world->mouseProjected = V2F(projection.x, projection.y);
-      ProcessEvents(&e, game->world);
 		}
-
+		UpdateWorld(1.0 / 60.0, &world);
-		UpdateWorld(1.0f / 60.0f, game->world);
-		D_AnimationUpdate(&animation, 1.0f / 250.0f);
-    game->camera.p.x = game->world->player.pos.x;
-    game->camera.p.y = game->world->player.pos.y;
 
 		int w, h;
 		SDL_GetWindowSizeInPixels(window, &w, &h);
@@ -178,7 +112,7 @@ int main(int argc, char **argv)
 		game->draw.window_width = w;
 		game->draw.window_height = h;
 
-		G_CalculateCamera(&game->camera, (F32)w / (F32)h);
+		G_CalulateCamera(&game->camera, (F32)w / (F32)h);
 
 		Vk_Frame *frame = Vk_FrameBegin(window);
 		VkCommandBuffer cmd = frame->cmd;
@@ -208,15 +142,9 @@ int main(int argc, char **argv)
 
 		D_Begin(&game->draw, frame, D_MAX_RECTS);
 
-    //RenderWorld(game->world, &game->draw);
+		D_Rect(&game->draw, 0.0f, 0.0f, .texture = 1);
-// 		D_Rect(&game->draw, 0.0f, 0.0f, .texture = D_ImageHandle(&game->draw, S("saloon_ext")), .scale = 4.0f);
+		D_Rect(&game->draw, -8.0f, 0.0f, .texture = 2, .scale = 2.0f);
-// 		D_Rect(&game->draw, -8.0f, 0.0f, .texture = 2, .scale = 2.0f);
+		D_Rect(&game->draw, 6.0f, 0.0f, .texture = 3);
-// 		D_Rect(&game->draw, 6.0f, 0.0f, .texture = 3);
-
-		G_WorldDraw(game, game->world);
-
-		R2f aframe = D_AnimationFrame(&animation);
-		D_Rect(&game->draw, 0, 0, .texture = animation.id, .uv = aframe, .flags = D_RECT_UV_ASPECT);
 
 		D_End(&game->draw, frame);
 

code/game/aabb.h

@@ -13,6 +13,5 @@ struct AABB
 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);
-function V2f AABB_Centre(AABB a);
 
 #endif // LD_GAME_AABB_H_

code/game/bandit.h

@@ -6,7 +6,7 @@ enum BANDIT_ACTION {
   BANDIT_WAITING,
   BANDIT_WALKING,
   BANDIT_RUNNING,
-  BANDIT_SHOOTING,
+  BANDIT_SHOOTOUT,
 };
 
 typedef struct Bandit Bandit;
@@ -14,7 +14,6 @@ struct Bandit {
   //// Personal
   AABB collision;
   Str8 name;
-  World_Area currentArea;
 
   //// Actions
   BANDIT_ACTION mode;
@@ -23,7 +22,6 @@ struct Bandit {
   // How long they will wait in this location.
   F32 maxWaitTime;
 
-  U32 poiCount;
   // Places the bandit walks to / from
   // E.g. hide outs, home, saloon
   U32 pointsOfInterest[12];

code/game/core.c

@@ -1,18 +1,5 @@
 // @Todo:  These should move to draw/core.c
 //
-internal void G_AssetNameHash(D_Context *draw, Str8 name, U32 id) {
-	D_AssetHash *result = M_ArenaPush(draw->arena, D_AssetHash);
-
-	U64 hash  = Str8_Hash(name);
-	U64 index = hash & (D_ASSET_HASH_COUNT - 1);
-
-	result->value = name;
-	result->hash  = hash;
-	result->id    = id;
-
-	SLL_Push(draw->lookup[index], result);
-}
-
 void G_ImagesLoad(G_State *game) {
 	M_TempScope(0, 0) {
 		D_Context *draw = &game->draw;
@@ -22,14 +9,14 @@ void G_ImagesLoad(G_State *game) {
 
 		FS_List assets = FS_PathList(temp.arena, path);
 
-		Vk_Buffer *staging = &draw->staging;
+		Vk_Buffer staging = { 0 };
-		staging->size         = MB(256);
+		staging.size         = MB(256);
-		staging->usage        = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
+		staging.usage        = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
-		staging->host_visible = true;
+		staging.host_visible = true;
 
-		Vk_BufferCreate(staging);
+		Vk_BufferCreate(&staging);
 
-		U8 *base   = staging->data;
+		U8 *base   = staging.data;
 		U64 offset = 0;
 
 		Vk_CommandBuffer *cmds = Vk_CommandBufferPush();
@@ -72,9 +59,6 @@ void G_ImagesLoad(G_State *game) {
 
 			white->name = S("_WHITE");
 
-			// This doesn't _really_ need one because its just zero and always will be zero
-			G_AssetNameHash(draw, white->name, 0);
-
 			white->image.width  = 2;
 			white->image.height = 2;
 			white->image.format = VK_FORMAT_R8G8B8A8_SRGB;
@@ -124,7 +108,7 @@ void G_ImagesLoad(G_State *game) {
 
 			vk.CmdPipelineBarrier2(cmds->handle, &dep);
 
-			vk.CmdCopyBufferToImage(cmds->handle, staging->handle, white->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+			vk.CmdCopyBufferToImage(cmds->handle, staging.handle, white->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
 
 			dep.pImageMemoryBarriers = &shader_read;
 
@@ -161,13 +145,12 @@ void G_ImagesLoad(G_State *game) {
 					base   += image_sz;
 					offset += image_sz;
 
-					Assert(offset <= staging->size);
+					Assert(offset <= staging.size);
+
+					draw->n_images += 1;
 
 					image->name = Str8_Copy(game->arena, Str8_RemoveAfterLast(it->basename, '.'));
 
-					G_AssetNameHash(draw, image->name, draw->n_images);
-
-					draw->n_images += 1;
 					printf("[Info] :: Loaded %.*s from %.*s\n", Sv(image->name), Sv(it->basename));
 
 					image->image.width  = w;
@@ -215,7 +198,7 @@ void G_ImagesLoad(G_State *game) {
 
 					vk.CmdPipelineBarrier2(cmds->handle, &dep);
 
-					vk.CmdCopyBufferToImage(cmds->handle, staging->handle, image->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
+					vk.CmdCopyBufferToImage(cmds->handle, staging.handle, image->image.handle, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copy);
 
 					dep.pImageMemoryBarriers = &shader_read;
 
@@ -268,7 +251,7 @@ void G_PipelinesLoad(G_State *game) {
 
 		bindings[1].binding         = 1;
 		bindings[1].descriptorType  = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
-		bindings[1].descriptorCount = game->draw.n_images + game->draw.n_fonts;
+		bindings[1].descriptorCount = game->draw.n_images;
 		bindings[1].stageFlags      = VK_SHADER_STAGE_FRAGMENT_BIT;
 
 		VkDescriptorSetLayoutCreateInfo set_info = { 0 };
@@ -307,23 +290,7 @@ void G_PipelinesLoad(G_State *game) {
 	Vk_PipelineCreate(basic);
 }
 
-void G_AudioLoad(G_State *game) {
+void G_CalulateCamera(G_Camera *camera, F32 aspect) {
-	(void) game;
-
-	M_TempScope(0, 0) {
-		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);
-
-		// @Incomplete: finish this
-
-		for (FS_Entry *it = assets.first; it != 0; it = it->next) {
-		}
-	}
-}
-
-void G_CalculateCamera(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);
 
@@ -331,32 +298,6 @@ void G_CalculateCamera(G_Camera *camera, F32 aspect) {
 	camera->proj.inv = M4x4F_Mul(view.inv, proj.inv);
 }
 
-V3f G_CameraUnprojectAt(G_Camera *camera, V2f clip, F32 z) {
-	V3f dir    = V3f_Sub(camera->p, V3f_Scale(camera->z, z));
-	V4f z_dist = V4F(dir.x, dir.y, dir.z, 1.0f);
-	V4f persp  = M4x4F_VMul4(camera->proj.fwd, z_dist);
-
-	clip = V2f_Scale(clip, persp.w);
-
-	V4f world = M4x4F_VMul4(camera->proj.inv, V4F(clip.x, clip.y, persp.z, persp.w));
-
-	V3f result = world.xyz;
-	return result;
-}
-
-V3f G_CameraUnproject(G_Camera *camera, V2f clip) {
-	V3f result = G_CameraUnprojectAt(camera, clip, camera->p.z);
-	return result;
-}
-
-R3f G_CameraBounds(G_Camera *camera) {
-	R3f result;
-	result.min = G_CameraUnproject(camera, V2F(-1, -1));
-	result.max = G_CameraUnproject(camera, V2F( 1,  1));
-
-	return result;
-}
-
 #include "impl/aabb.c"
 #include "impl/nav.c"
 #include "impl/player.c"

code/game/core.h

@@ -1,6 +1,5 @@
 #if !defined(LD_GAME_CORE_H_)
 #define LD_GAME_CORE_H_
-#include "world.h"
 
 typedef struct G_Camera G_Camera;
 struct G_Camera {
@@ -19,25 +18,17 @@ struct G_State {
 
 	D_Context draw;
 	G_Camera camera;
-
-  World *world;
 };
 
 function void G_ImagesLoad(G_State *game);
 function void G_PipelinesLoad(G_State *game);
-function void G_AudioLoad(G_State *game);
 
-function void G_CalculateCamera(G_Camera *camera, F32 aspect);
+function void G_CalulateCamera(G_Camera *camera, F32 aspect);
-
-// Assumes 'calculate' has been called
-function V3f G_CameraUnprojectAt(G_Camera *camera, V2f clip, F32 z);
-function V3f G_CameraUnproject(G_Camera *camera, V2f clip);
-
-function R3f G_CameraBounds(G_Camera *camera);
 
 #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

@@ -23,18 +23,14 @@ bool AABB_Slab(V2f origin, V2f point, AABB a)
   // x
   F32 tLow = (start.x - origin.x) * invdirection.x;
   F32 tHigh = (finish.x - origin.x) * invdirection.x;
-  F32 tMin = Min(tLow, tHigh);
+  F32 tMin = min(tLow, tHigh);
-  F32 tMax = Max(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));
+  tMin = max(tMin, min(tLow, tHigh));
-  tMax = Min(tMax, Max(tLow, tHigh));
+  tMax = min(tMax, max(tLow, tHigh));
 
   return tMax >= tMin;
 }
-
-V2f AABB_Centre(AABB a) {
-  return V2F(a.pos.x + a.size.x/2, a.pos.y + a.size.y/2);
-}

code/game/impl/bandit.c

@@ -1,47 +0,0 @@
-#include "game/world.h"
-#include "game/bandit.h"
-
-void UpdateBandit(F32 delta, Bandit *bandit, World *world) {
-  if (
-      world->player.controls.shot && AABB_Slab(world->player.pos, world->player.shotPos, bandit->collision) && bandit->currentArea == world->player.currentArea)
-  {
-    printf("You shot the bandit %*.s\n", Sv(bandit->name));
-    bandit->health--;
-  }
-  switch (bandit->mode) {
-    case BANDIT_WAITING:
-      bandit->waitTime+=delta;
-      if(bandit->waitTime > bandit->maxWaitTime) {
-        bandit->mode = BANDIT_WALKING;
-        do {
-          U32 randomChoice = Random_U32(&world->random, 0, bandit->poiCount);
-          bandit->targetNavNode = bandit->pointsOfInterest[randomChoice];
-        } while(bandit->targetNavNode == bandit->currentNavNode);
-        bandit->path = Nav_Path(world->navMesh, bandit->currentNavNode, bandit->targetNavNode);
-        bandit->walkTimer = 0;
-      }
-    break;
-    case BANDIT_WALKING:
-      bandit->walkTimer+=delta;
-      if(bandit->walkTimer >= NPC_SPEED){
-        bandit->walkTimer = 0;
-        if(bandit->path.nodeCount == bandit->pathIndex+1){
-          bandit->mode = BANDIT_WAITING;
-          bandit->maxWaitTime = Random_F32(&world->random, 20, 140);
-          bandit->waitTime = 0;
-          bandit->currentNavNode = bandit->targetNavNode;
-          bandit->pathIndex = 0;
-          return;
-        }
-        bandit->currentNavNode = bandit->path.indexes[bandit->pathIndex];
-        bandit->pathIndex+=1;
-      }
-      NavNode cNav = world->navMesh->nodes[bandit->currentNavNode];
-      NavNode tNav = world->navMesh->nodes[bandit->path.indexes[bandit->pathIndex]];
-      bandit->collision.pos.x = cNav.pos.x * (1 - bandit->walkTimer/NPC_SPEED) + tNav.pos.x * bandit->walkTimer/NPC_SPEED;
-      bandit->collision.pos.y = cNav.pos.y * (1 - bandit->walkTimer/NPC_SPEED) + tNav.pos.y * bandit->walkTimer/NPC_SPEED;
-    break;
-      // TODO Shooting
-      // TODO Running away
-  }
-}

code/game/impl/nav.c

@@ -9,7 +9,7 @@ typedef struct navSearchNodeState navSearchNodeState;
 struct navSearchNodeState
 {
   bool visited;
-  F64 distance;
+  U64 distance;
   U32 shortest;
   bool addedToUnvisited;
 };
@@ -27,7 +27,7 @@ navSearchState initState(U32 start, U32 meshSize)
   {
     state.nodeStates[i].visited = false;
     state.nodeStates[i].addedToUnvisited = false;
-    state.nodeStates[i].distance = F64_MAX;
+    state.nodeStates[i].distance = U64_MAX;
     state.nodeStates[i].shortest = 0;
   }
   state.nodeStates[start].distance = 0;
@@ -61,13 +61,8 @@ U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchSta
 }
 
 // Generate a path to follow between the start and end node.
-NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
+NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end)
-  // This is a stupid fix, since it's easier to work backwards
+{
-  // to generate a path, I'm swapping the start / end, to generate
-  // it backwards
-  U32 tmp = end;
-  end = start;
-  start = tmp;
   navSearchState state = initState(start, mesh->nodeCount);
   U32 unfinishedCount = 1;
   U32 unfinishedIndexes[NAV_MAX_NODES] = {start};
@@ -78,15 +73,21 @@ NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
   U32 unfinishedOffset = 0;
   U32 lowestNodeIndex = start;
   bool found = false;
-  while(!found) {
+  while (!found)
-    for(int connectionI = 0 ; connectionI < mesh->nodes[lowestNodeIndex].connectionCount; connectionI++) {
+  {
+    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;}
+      if (testNode->visited)
-      F64 distance = cast(F64) (state.nodeStates[lowestNodeIndex].distance + connection->Cost);
+      {
-      distance += cast(F64) Abs((mesh->nodes[end].pos.x - mesh->nodes[connection->NodeIndex].pos.x));
+        continue;
-      distance += cast(F64) Abs((mesh->nodes[end].pos.y - mesh->nodes[connection->NodeIndex].pos.y));
+      }
-      if(testNode->distance > distance) {
+      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;
       }

code/game/impl/npc.c

@@ -1,22 +1,22 @@
 #include "game/npc.h"
 #include "game/world.h"
 #include "core/types.h"
-#include "core/math.h"
 
-void UpdateNPC(F32 delta, NPC *npc, World *world) {
+#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;
-        // TODO change targets to poi's rather than just random nodes
+        U32 next = npc->targetNavNode == 100 ? 20 : 100;
-        // TODO choose either global POI's or use NPC custom poi if
+        npc->targetNavNode = next; // TODO RANDOM
-        // customPOI is true
+        printf("Starting to nav path\n");
-        do {
-          npc->targetNavNode = Random_U32(&world->random, 0, world->navMesh->nodeCount);
-        } while(npc->targetNavNode == npc->currentNavNode);
         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:
@@ -24,18 +24,18 @@ void UpdateNPC(F32 delta, NPC *npc, World *world) {
       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 = Random_F32(&world->random, 20, 140);
+          npc->maxWaitTime = 20; // TODO RANDOM
           npc->waitTime = 0;
-          npc->currentNavNode = npc->targetNavNode;
           npc->pathIndex = 0;
           return;
         }
-        npc->currentNavNode = npc->path.indexes[npc->pathIndex];
         npc->pathIndex+=1;
+        npc->currentNavNode = npc->path.indexes[npc->pathIndex];
       }
       NavNode cNav = world->navMesh->nodes[npc->currentNavNode];
-      NavNode tNav = world->navMesh->nodes[npc->path.indexes[npc->pathIndex]];
+      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

@@ -1,78 +1,37 @@
 #include "../player.h"
-#include <SDL3/SDL_events.h>
 #include <SDL3/SDL_keycode.h>
 #include <stdio.h>
 
-void PlayerInput(SDL_Event *event, Player *player)
+void PlayerUpdate(SDL_Event *event, Player *player)
 {
   SDL_KeyboardEvent key = event->key;
   SDL_MouseButtonEvent mouseBtn = event->button;
-  if(event->type == SDL_EVENT_KEY_DOWN || event->type == SDL_EVENT_KEY_UP) {
-    bool val = event->type == SDL_EVENT_KEY_DOWN;
   switch (key.key)
   {
   case SDLK_W:
   {
-        player->controls.upDown = val;
+    player->pos.y += 10;
     break;
   }
   case SDLK_A:
   {
-        player->controls.leftDown = val;
+    player->pos.x -= 10;
     break;
   }
   case SDLK_D:
   {
-        player->controls.rightDown = val;
+    player->pos.x += 10;
     break;
   }
   case SDLK_S:
   {
-        player->controls.downDown = val;
+    player->pos.y -= 10;
     break;
   }
   }
-  }
+  if (mouseBtn.clicks == 1)
-  if (
+  {
-    event->type == SDL_EVENT_MOUSE_BUTTON_DOWN 
-    && mouseBtn.button == SDL_BUTTON_LEFT
-  ) {
-    if(player->bulletsLoaded > 0) {
     // shooting
     player->bulletsLoaded -= 1;
-      player->controls.shot = true;
-      player->shotPos = player->world->mouseProjected;
-      printf("shot %f %f\n", player->shotPos.x, player->shotPos.y);
-    } else if(player->reloadTimer == 0) {
-      player->reloadTimer = PLAYER_RELOAD_TIME;
-      printf("reloading\n");
-  };
   }
 }
-
-void PlayerUpdate(F32 delta, Player *player) {
-  player->controls.shot = false;
-  V2f dir = V2F(0, 0);
-  if(player->controls.upDown) {
-    dir.y -= 1;
-  }
-  if(player->controls.downDown) {
-    dir.y += 1;
-  }
-  if(player->controls.leftDown) {
-    dir.x -= 1;
-  }
-  if(player->controls.rightDown) {
-    dir.x += 1;
-  }
-  if(player->reloadTimer > 0) {
-    player->reloadTimer-=delta;
-    if(player->reloadTimer <= 0) {
-      player->bulletsLoaded = PLAYER_BULLET_COUNT;
-      player->reloadTimer = 0;
-    }
-  }
-  dir = V2f_Scale(NormaliseV2F(dir), PLAYER_SPEED*delta);
-  player->pos.x += dir.x;
-  player->pos.y += dir.y;
-}

code/game/impl/world.c

@@ -1,77 +1,22 @@
 #include "../world.h"
 #include "../npc.h"
 #include "../player.h"
-#include "../aabb.h"
 #include <SDL3/SDL_events.h>
-#include "../map.h"
 
 void UpdateWorld(F32 delta, World *world)
 {
-  UpdateBandit(delta, &world->bandit, world);
+  // UpdateNPCs(delta, world);
-  UpdateNPCs(delta, world);
-  PlayerUpdate(delta, &world->player);
 }
 
 void UpdateNPCs(F32 delta, World *world)
 {
-  for (U32 i = 0; i < world->npcCount; i++)
+  for (int i = 0; i < world->npcCount; i++)
   {
-    NPC *npc = &world->npcs[i];
+    updateNPC(delta, &world->npcs[i], world);
-    UpdateNPC(delta, npc, world);
-    if (
-        world->player.controls.shot && AABB_Slab(world->player.pos, world->player.shotPos, npc->collision) && npc->currentArea == world->player.currentArea)
-    {
-      printf("You shot %*.s\n", Sv(world->npcs[i].name));
-    }
   }
 }
 
 void ProcessEvents(SDL_Event *event, World *world)
 {
-  PlayerInput(event, &world->player);
+  PlayerUpdate(event, &world->player);
-}
-
-void RenderWorld(World *world, D_Context *draw) {
-  World_Tile tileTypes[] = {dirt, middlePath, middlePathEdgeTop, middlePathEdgeRight, middlePathEdgeBottom, middlePathEdgeLeft, middlePathCornerTopLeft, middlePathCornerTopRight, middlePathCornerBottomRight, middlePathCornerTurnBottomLeft};
-  for (int i = 0; i < 4800; i++)
-  {
-    D_Rect(draw, (F32) (i % 96), (F32) (i / 96), .texture = tileTypes[map[i]].tile, .angle = (F32) tileTypes[map[i]].rotation);
-  }
-  for(U32 i = 0; i < world->npcCount; i++) {
-    NPC npc = world->npcs[i];
-    if(npc.currentArea == world->player.currentArea) {
-      V2f drawPos = AABB_Centre(npc.collision);
-      D_Rect(draw, drawPos.x, drawPos.y, .texture = 1);
-      D_Rect(draw, drawPos.x, drawPos.y, .texture = 0, .dim = npc.collision.size, .flags = D_RECT_IGNORE_ASPECT);
-    }
-  }
-  if(world->bandit.currentArea == world->player.currentArea) {
-    V2f drawPos = AABB_Centre(world->bandit.collision);
-    D_Rect(draw, drawPos.x, drawPos.y, .texture = 9);
-    D_Rect(draw, drawPos.x, drawPos.y, .texture = 0, .dim = world->bandit.collision.size, .flags = D_RECT_IGNORE_ASPECT);
-  }
-  D_Rect(draw, world->player.pos.x, world->player.pos.y, .texture = 1);
-}
-
-void G_WorldDraw(G_State *game, World *world) {
-	D_Context *draw = &game->draw;
-
-	(void) world;
-
-	U32 id     = D_ImageHandle(&game->draw, S("tile_dirt_0"));
-	U32 alt_id = D_ImageHandle(&game->draw, S("tile_dirt_1"));
-
-	for (F32 y = -128; y < 128; y += 1.0f) {
-		for (F32 x = -128; x < 128; x += 1.0f) {
-			U32 ux = (U32) x;
-			U32 uy = (U32) y;
-
-			U32 tid = id;
-			if ((ux % 11) == 0 || ((uy % 7) == 0)) {
-				tid = alt_id;
-			}
-
-			D_Rect(draw, x, y, .texture = tid);
-		}
-	}
 }

code/game/map.h

@@ -1,65 +0,0 @@
-#include "world.h"
-
-
-World_Tile dirt = {.rotation=0,.collision=false,.tile=16};//0
-World_Tile middlePath = {.rotation=0,.collision=false,.tile=6};//1
-World_Tile middlePathEdgeTop = {.rotation=0,.collision=false,.tile=7};//2
-World_Tile middlePathEdgeRight = {.rotation=PI_F32/2,.collision=false,.tile=7};//3
-World_Tile middlePathEdgeBottom = {.rotation=PI_F32,.collision=false,.tile=7};//4
-World_Tile middlePathEdgeLeft = {.rotation=-PI_F32/2,.collision=false,.tile=7};//5
-World_Tile middlePathCornerTopLeft = {.rotation=0,.collision=false,.tile=5};//6
-World_Tile middlePathCornerTopRight = {.rotation=PI_F32/2,.collision=false,.tile=5};//7
-World_Tile middlePathCornerBottomRight = {.rotation=-PI_F32,.collision=false,.tile=5};//8
-World_Tile middlePathCornerTurnBottomLeft = {.rotation=-PI_F32/2,.collision=false,.tile=5};//9
-int map[] = {
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,6,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,4,4,4,4,4,4,4,4,4,4,4,4,9,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,8,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,9,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,5,3,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,7,2,2,2,2,2,6,7,2,2,2,2,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,8,4,4,4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,5,3,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,7,2,2,2,2,2,6,7,2,2,2,2,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,8,4,4,4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,5,3,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,7,2,2,2,2,2,6,7,2,2,2,2,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,8,4,4,4,4,4,4,4,4,4,4,4,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-};

code/game/npc.h

@@ -5,7 +5,7 @@
 #include "npc_look.h"
 #include "../core/types.h"
 
-#define NPC_SPEED 1.0f
+#define NPC_SPEED 0.2f
 
 typedef enum NPC_ACTION NPC_ACTION;
 enum NPC_ACTION {
@@ -22,11 +22,6 @@ struct NPC {
   AABB collision;
   Str8 name;
   NPC_LOOK look;
-  World_Area currentArea;
-
-  bool customPOI;
-  U32 customPOICount;
-  U32 npcPOI[16];
 
   //// Actions
   NPC_ACTION mode;

code/game/player.h

@@ -6,33 +6,13 @@
 
 #include <SDL3/SDL_events.h>
 
-#define PLAYER_SPEED 10.0f
-#define PLAYER_RELOAD_TIME 1.5f
-#define PLAYER_BULLET_COUNT 6
-
-typedef struct ControlState ControlState;
-struct ControlState {
-  bool rightDown;
-  bool leftDown;
-  bool upDown;
-  bool downDown;
-  bool shot;
-};
-
 typedef struct Player Player;
 struct Player
 {
-    World *world;
     V2f pos;
-    World_Area currentArea;
     U32 bulletsLoaded;
-    ControlState controls;
-    V2f shotPos;
-
-    F32 reloadTimer;
 };
 
-function void PlayerInput(SDL_Event *event, Player *player);
+function void PlayerUpdate(SDL_Event *event, Player *player);
-function void PlayerUpdate(F32 delta, Player *player);
 
 #endif  // LD_GAME_PLAYER_H_

code/game/world.h

@@ -1,38 +1,21 @@
 #if !defined(LD_GAME_WORLD_H_)
 #define LD_GAME_WORLD_H_
 
-#include "../core/math.h"
-
-// Areas are which
-typedef U32 World_Area;
-enum World_Area
-{
-  WORLD_AREA_OUTSIDE = (1 << 0),
-  WORLD_AREA_SALOON = (1 << 1),
-  WORLD_PATH_MIDDLE_EDGE = (1 << 2),
-  WORLD_PATH_MIDDLE = (1 << 3),
-  WORLD_PATH_CORNER = (1 << 4),
-  WORLD_PATH_CORNER_EDGE = (1 << 5),
-};
-
-typedef struct World_Tile World_Tile;
-struct World_Tile
-{
-  World_Area tile;
-  double rotation;
-  bool collision;
-};
-
-typedef struct World World;
 #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;
-  Random random;
-  V2f mouseProjected;
 
   //// Player
 	Player player;
@@ -50,10 +33,8 @@ struct World {
 };
 
 function void UpdateWorld(F32 delta, World *world);
-function void RenderWorld(World *world, D_Context *drawContext);
 function void ProcessEvents(SDL_Event *event, World *world);
 function void UpdateNPCs(F32 delta, World *world);
-function void UpdateNPC(F32 delta, NPC *npc, World *world);
+function void updateNPC(F32 delta, NPC *npc, World *world);
-function void UpdateBandit(F32 delta, Bandit *bandit, World *world);
 
 #endif  // LD_GAME_WORLD_H_

code/vulkan/core.c

@@ -518,8 +518,6 @@ Vk_CommandBuffer *Vk_CommandBufferPush() {
 
 	vk.BeginCommandBuffer(result->handle, &begin_info);
 
-	frame->next_scratch += 1;
-
 	return result;
 }
 

code/vulkan/shaders/basic.vert

@@ -50,19 +50,11 @@ vec4 unorm_colour(uint c) {
 	return result;
 }
 
-vec2 rotate2f(vec2 v, float angle) {
-	float s = sin(angle);
-	float c = cos(angle);
-
-	vec2 result = vec2(c * v.x - s * v.y, s * v.x + c * v.y);
-	return result;
-}
-
 void main() {
 	G_Rect rect = rects[gl_InstanceIndex];
 	uint   idx  = indices[gl_VertexIndex];
 
-	vec2 p = (rotate2f(verticies[idx], rect.angle) * vec2(rect.w, rect.h)) + vec2(rect.x, rect.y);
+	vec2 p = (verticies[idx] * vec2(rect.w, rect.h)) + vec2(rect.x, rect.y);
 
 	gl_Position = proj * vec4(p, 1.0f, 1.0f);
 

linux

@@ -57,7 +57,7 @@ glslangValidator -o "assets/shaders/basic.frag.spv" --target-env "vulkan1.3" "..
 
 echo "[Building source]"
 
-COMPILER_OPTS="-Wall -Wno-override-init-side-effects -Wno-missing-braces -Wno-unused-function -Ideps/stb -I../code"
+COMPILER_OPTS="-Wall -Wno-missing-braces -Wno-unused-function -Ideps/stb -I../code"
 LINKER_OPTS="-lSDL3 -lm"
 
 if [[ $release == 1 ]]