Merge remote-tracking branch 'origin'

Fixed typo in calculate camera
Removed some warning

.gitignore

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

code/core/impl/math.c

@@ -160,4 +160,46 @@ 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;
+}

code/core/math.h

@@ -4,6 +4,11 @@
 #define PI_F32  (3.14159265358979323846264338f)
 #define TAU_F32 (2.0f * PI_F32)
 
+typedef struct Random Random;
+struct Random {
+	U64 state;
+};
+
 typedef union V2f V2f;
 union V2f {
 	struct {
@@ -114,4 +119,18 @@ 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);
 
+// 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);
+
 #endif  // LD_CORE_MATH_H_

code/draw/core.h

@@ -1,7 +1,7 @@
 #if !defined(LD_DRAW_CORE_H_)
 #define LD_DRAW_CORE_H_
 
-#define D_MAX_RECTS 1024
+#define D_MAX_RECTS (262144)
 
 typedef struct D_Image D_Image;
 struct D_Image {

code/first.c

@@ -19,8 +19,7 @@
 #include "game/impl/npc.c"
 #include "game/testnavmesh.h"
 
-int main(int argc, char **argv)
-{
+int main(int argc, char **argv) {
 	(void) argc;
 	(void) argv;
 
@@ -62,34 +61,42 @@ int main(int argc, char **argv)
 		camera->farp  = 1000.0f;
 
 		game->draw.camera = camera;
+		World *world = M_ArenaPush(arena, World);
+    game->world = world;
+    world->npcCount = 2;
+    NPC *npc1 = &world->npcs[0];
+    npc1->collision.pos.x = 15;
+    npc1->collision.pos.y = 15;
+    npc1->collision.size.x = 10;
+    npc1->collision.size.y = 10;
+    npc1->name = S("Matt");
+    npc1->mode = NPC_ACTION_WAITING;
+    npc1->waitTime = 0;
+    npc1->maxWaitTime = 5;
+    npc1->currentNavNode = 87;
+    npc1->collision.pos.x = 15;
+    npc1->collision.pos.y = 15;
+    npc1->collision.size.x = 10;
+    npc1->collision.size.y = 10;
+
+    NPC *npc2 = &world->npcs[0];
+    npc2->collision.pos.x = 15;
+    npc2->collision.pos.y = 15;
+    npc2->collision.size.x = 10;
+    npc2->collision.size.y = 10;
+    npc2->name = S("James");
+    npc2->mode = NPC_ACTION_WAITING;
+    npc2->waitTime = 0;
+    npc2->maxWaitTime = 10;
+    npc2->currentNavNode = 0;
+
+    world->navMesh = &TestNavMesh;
+    world->npcPOI[0] = 100;
+    world->player.pos.x = 0;
+    world->player.pos.y = 0;
 	}
 
-	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;
-	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));
 
@@ -102,9 +109,9 @@ int main(int argc, char **argv)
 			{
 				running = false;
 			}
-			ProcessEvents(&e, &world);
+      ProcessEvents(&e, game->world);
 		}
-		UpdateWorld(1.0 / 60.0, &world);
+    UpdateWorld(1.0/60.0, game->world);
 
 		int w, h;
 		SDL_GetWindowSizeInPixels(window, &w, &h);
@@ -112,7 +119,7 @@ int main(int argc, char **argv)
 		game->draw.window_width  = w;
 		game->draw.window_height = h;
 
-		G_CalulateCamera(&game->camera, (F32)w / (F32)h);
+		G_CalculateCamera(&game->camera, (F32) w / (F32) h);
 
 		Vk_Frame *frame = Vk_FrameBegin(window);
 		VkCommandBuffer cmd = frame->cmd;

code/game/aabb.h

@@ -3,15 +3,15 @@
 #include "../core/types.h"
 #include "../core/macros.h"
 
+
 typedef struct AABB AABB;
-struct 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/core.c

@@ -290,7 +290,7 @@ void G_PipelinesLoad(G_State *game) {
 	Vk_PipelineCreate(basic);
 }
 
-void G_CalulateCamera(G_Camera *camera, F32 aspect) {
+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);
 

code/game/core.h

@@ -1,5 +1,6 @@
 #if !defined(LD_GAME_CORE_H_)
 #define LD_GAME_CORE_H_
+#include "world.h"
 
 typedef struct G_Camera G_Camera;
 struct G_Camera {
@@ -18,17 +19,18 @@ 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_CalulateCamera(G_Camera *camera, F32 aspect);
+function void G_CalculateCamera(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

@@ -1,36 +1,15 @@
 #include "game/aabb.h"
-#include <math.h>
+#include "core/types.h"
 
-bool AABB_Collide(AABB a, AABB b)
-{
+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 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

@@ -6,8 +6,7 @@
 #define MAX_UNFINISHED 128
 
 typedef struct navSearchNodeState navSearchNodeState;
-struct navSearchNodeState
-{
+struct navSearchNodeState{
   bool visited;
   U64 distance;
   U32 shortest;
@@ -15,16 +14,13 @@ struct navSearchNodeState
 };
 
 typedef struct navSearchState navSearchState;
-struct navSearchState
-{
+struct navSearchState{
   navSearchNodeState nodeStates[NAV_MAX_NODES];
 };
 
-navSearchState initState(U32 start, U32 meshSize)
-{
-  navSearchState state;
-  for (U32 i = 0; i < meshSize; i++)
-  {
+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;
@@ -34,25 +30,20 @@ navSearchState initState(U32 start, U32 meshSize)
   return state;
 }
 
-U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchState state, U32 *offset)
-{
+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++)
-  {
+  for(U32 i = *offset; i < unfinishedCount; i++) {
     navSearchNodeState checkNode = state.nodeStates[unfinishedIndexes[i]];
-    if (checkNode.visited)
-    {
-      if (!startFound)
-      {
+    if(checkNode.visited) {
+      if(!startFound) {
         *offset = i;
       }
       continue;
     }
     startFound = true;
-    if (lowest > checkNode.distance)
-    {
+    if (lowest > checkNode.distance) {
       lowest  = cast(U32) checkNode.distance;
       lowestI = unfinishedIndexes[i];
     }
@@ -61,8 +52,7 @@ 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) {
   navSearchState state = initState(start, mesh->nodeCount);
   U32 unfinishedCount = 1;
   U32 unfinishedIndexes[NAV_MAX_NODES] = {start};
@@ -73,26 +63,19 @@ NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end)
   U32 unfinishedOffset = 0;
   U32 lowestNodeIndex = start;
   bool found = false;
-  while (!found)
-  {
-    for (int connectionI = 0; connectionI < mesh->nodes[lowestNodeIndex].connectionCount; connectionI++)
-    {
+  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;
-      }
+      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)
-      {
+      if(testNode->distance > distance) {
         testNode->distance = distance;
         testNode->shortest = lowestNodeIndex;
       }
-      if (!testNode->addedToUnvisited)
-      {
+      if(!testNode->addedToUnvisited) {
         unfinishedIndexes[unfinishedCount] = connection->NodeIndex;
         unfinishedCount++;
         testNode->addedToUnvisited = true;
@@ -100,15 +83,13 @@ NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end)
     }
     state.nodeStates[lowestNodeIndex].visited = true;
     lowestNodeIndex = getLowestState(unfinishedIndexes, unfinishedCount, state, &unfinishedOffset);
-    if (lowestNodeIndex == end)
-    {
+    if(lowestNodeIndex == end) {
       found = true;
     }
   }
   NavPath res_path = {0};
   U32 index = end;
-  while (index != start)
-  {
+  while(index!=start) {
     res_path.indexes[res_path.nodeCount] = index;
     res_path.nodeCount++;
     index = state.nodeStates[index].shortest;

code/game/impl/player.c

@@ -5,33 +5,22 @@
 void PlayerUpdate(SDL_Event *event, Player *player)
 {
     SDL_KeyboardEvent key = event->key;
-  SDL_MouseButtonEvent mouseBtn = event->button;
-  switch (key.key)
-  {
-  case SDLK_W:
-  {
+    switch(key.key) {
+      case SDLK_W: {
         player->pos.y += 10;
         break;
       }
-  case SDLK_A:
-  {
+      case SDLK_A: {
         player->pos.x -= 10;
         break;
       }
-  case SDLK_D:
-  {
+      case SDLK_D: {
         player->pos.x += 10;
         break;
       }
-  case SDLK_S:
-  {
+      case SDLK_S: {
         player->pos.y -= 10;
         break;
       }
     }
-  if (mouseBtn.clicks == 1)
-  {
-    // shooting
-    player->bulletsLoaded -= 1;
-  }
 }

code/game/impl/world.c

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

code/game/player.h

@@ -10,7 +10,6 @@ typedef struct Player Player;
 struct Player
 {
     V2f pos;
-    U32 bulletsLoaded;
 };
 
 function void PlayerUpdate(SDL_Event *event, Player *player);