Update README.md

Makefile

@@ -1,6 +1,6 @@
 CC            = clang
-CFLAGS        = -g -O3 -Iwapp/src
-LDFLAGS       = -lm
+CFLAGS        = -g -O3 -Iraylib/include -Iwapp/src
+LDFLAGS       = '-Wl,-rpath,$$ORIGIN/raylib/lib' -Lraylib/lib -lraylib -lm -lpthread
 BASEDIR       = $(shell realpath ./)
 RL_SRCDIR     = ${BASEDIR}/raylib-src/src
 RL_BUILDDIR   = ${BASEDIR}/raylib-build
@@ -13,13 +13,26 @@ PLATFORM      = $(shell uname)
 
 all: no_dod dod
 
+raylib:
+ifeq ($(PLATFORM), Linux)
+	cmake -S raylib-src -B raylib-build -DCMAKE_INSTALL_PREFIX=raylib -DCMAKE_CONFIGURATION_TYPES=Release -DBUILD_SHARED_LIBS=ON -G "Ninja Multi-Config"
+	cmake --build raylib-build --config=Release
+	cmake --install raylib-build --config=Release
+else
+	mkdir -p ${RL_BUILDDIR} ${RL_LIBDIR} ${RL_INCLUDEDIR}
+	cd ${RL_SRCDIR} && \
+		make PLATFORM=PLATFORM_DESKTOP RAYLIB_RELEASE_PATH=${RL_BUILDDIR} RAYLIB_LIBTYPE=SHARED && \
+		cp ${RL_BUILDDIR}/* ${RL_LIBDIR} && \
+		cp ${RL_SRCDIR}/*.h ${RL_INCLUDEDIR}
+endif
+
 wapp:
 	cd wapp && python3 -m codegen
 
-no_dod: wapp
+no_dod: raylib wapp
 	$(CC) $(CFLAGS) $(LDFLAGS) no_dod.c wapp/src/wapp.c -o no_dod
 
-dod: wapp
+dod: raylib wapp
 	$(CC) $(CFLAGS) $(LDFLAGS) dod.c wapp/src/wapp.c -o dod
 
 clean:

common.h

@@ -17,8 +17,6 @@
 #define WANDERER_SLOWDOWN_FACTOR 0.5f
 #define WANDERER_SPEEDUP_FACTOR 2.0f
 #define MSG_BUF_LEN 4096
-#define LINE_BUF_LEN 1024
-#define LOOPS 100
 
 #define abs(A) (A < 0 ? A * -1 : A)
 #define min(A, B) (A < B ? A : B)

dod.c

@@ -1,10 +1,14 @@
 #include "wapp.h"
 #include "common.h"
+#include "raylib.h"
 #include <math.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <assert.h>
 #include <string.h>
+#include <pthread.h>
+
+#define THREAD_COUNT 4
 
 #define MOVABLE_TAG_SHIFT     0
 #define RENDERABLE_TAG_SHIFT  1
@@ -56,8 +60,20 @@ struct Manager {
   u64      count;
 };
 
+typedef struct PositionThreadArgs PositionThreadArgs;
+struct PositionThreadArgs {
+  const Rect *zones;
+  Rect       *rects;
+  Velocity   *velocities;
+  u8         *tags;
+  u64        count;
+  f32        delta;
+};
+
+typedef void *(*PThreadRoutine)(void *);
 typedef void (*ScaleInitialiser)(Scale *scale, XOR256State *state);
 typedef void (*VelocityInitialiser)(Velocity *velocity, XOR256State *state);
+typedef void (*RaylibDrawRectFunc)(int posX, int posY, int width, int height, Color color);
 
 void init_manager(const Allocator *allocator, Manager *manager);
 void init_position(Position *position, XOR256State *state);
@@ -65,14 +81,19 @@ void init_scale_wanderer(Scale *scale, XOR256State *state);
 void init_scale_zone(Scale *scale, XOR256State *state);
 void init_velocity(Velocity *velocity, XOR256State *state);
 void zero_velocity(Velocity *velocity, XOR256State *state);
-u64 update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count, f32 delta);
+void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count, f32 delta);
+void *update_position_thread(PositionThreadArgs *args);
 void render_entities(const u8 *tags, const Rect *rects, u64 count);
 u8 collides(const Rect *rect, const Rect *collider);
 i16 get_random_velocity(XOR256State *state);
 
-u64 log_data(const Rect *rects, u64 count, FILE *fp, char *line);
-
 int main(void) {
+  i32 target_fps = 120;
+
+  SetTraceLogLevel(LOG_NONE);
+  InitWindow(WIDTH, HEIGHT, "DOD test");
+  SetTargetFPS(target_fps);
+
   Allocator arena = wapp_mem_arena_allocator_init(MB(20));
   assert(!wapp_mem_allocator_invalid(&arena));
 
@@ -95,24 +116,34 @@ int main(void) {
     velocity_initialisers[is_zone](&(manager.velocities[i]), &state);
   }
 
-  FILE *fp = fopen("dod.out", "w");
-  assert(fp != NULL);
+  f32 last_time = GetFrameTime();
+  f32 delta, cur_time;
 
-  u64 update_counter = 0;
-  u64 render_counter = 0;
-  f32 delta = 0.016666666f;
-  for (u64 i = 0; i < LOOPS; ++i) {
-    update_counter += update_positions(manager.tags, manager.rects, manager.velocities, manager.count, delta);
-
-    char line[LINE_BUF_LEN] = {0};
-
-    render_counter += log_data(manager.rects, manager.count, fp, line);
+  while (!WindowShouldClose()) {
+    f64 time = GetTime();
+    if (time >= 20.0) {
+      break;
+    }
+
+    cur_time = GetFrameTime();
+    delta    = cur_time - last_time;
+
+    update_positions(manager.tags, manager.rects, manager.velocities, manager.count, delta);
+
+    BeginDrawing();
+
+    ClearBackground(BG_COLOR);
+
+    render_entities(manager.tags, manager.rects, manager.count);
+
+    DrawFPS(10, 10);
+
+    EndDrawing();
   }
 
-  fclose(fp);
   wapp_mem_arena_allocator_destroy(&arena);
 
-  printf("UPDATE: %lu, RENDER: %lu\n", update_counter, render_counter);
+  CloseWindow();
 
   return 0;
 }
@@ -167,7 +198,47 @@ void zero_velocity(Velocity *velocity, XOR256State *state) {
   velocity->y = 0.0f;
 }
 
-u64 update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count, f32 delta) {
+void update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count, f32 delta) {
+  persistent pthread_t threads[THREAD_COUNT]       = {0};
+  persistent PositionThreadArgs args[THREAD_COUNT] = {0};
+
+  u64 total_entities_count  = count - ZONE_COUNT;
+  u64 thread_entities_count = (u64)(ceil((f64)total_entities_count / THREAD_COUNT));
+
+  i32 result;
+  u64 start = ZONE_COUNT;
+  u64 end, args_count;
+
+  for (u64 i = 0; i < THREAD_COUNT; ++i) {
+    if (total_entities_count > thread_entities_count) {
+      end = start + thread_entities_count;
+      total_entities_count -= thread_entities_count;
+    } else {
+      end = start + total_entities_count;
+      total_entities_count = 0;
+    }
+
+    args_count = end - start;
+
+    args[i].zones      = &(rects[0]);
+    args[i].tags       = &(tags[start]);
+    args[i].rects      = &(rects[start]);
+    args[i].velocities = &(velocities[start]);
+    args[i].count      = args_count;
+    args[i].delta      = delta;
+
+    start += args_count;
+
+    result = pthread_create(&(threads[i]), NULL, (PThreadRoutine)update_position_thread, (void *)&(args[i]));
+    assert(result == 0);
+  }
+
+  for (u64 i = 0; i < THREAD_COUNT; ++i) {
+    pthread_join(threads[i], NULL);
+  }
+}
+
+void *update_position_thread(PositionThreadArgs *args) {
   persistent f32 multipliers[2] = {1.0f, 0.5f};
   persistent u64 inside_zone_mask = 0x7;
 
@@ -175,38 +246,53 @@ u64 update_positions(u8 *tags, Rect *rects, Velocity *velocities, u64 count, f32
   f32 pos_x, pos_y;
   f32 max_x, max_y;
 
-  u64 total = 0;
-  for (u64 i = ZONE_COUNT; i < count; ++i) {
-    tags[i] &= inside_zone_mask;
+  for (u64 i = 0; i < args->count; ++i) {
+    args->tags[i] &= inside_zone_mask;
     for (u64 j = 0; j < ZONE_COUNT; ++j) {
-      tags[i] |= collides(&rects[i], &rects[j]) << INSIDE_ZONE_TAG_SHIFT;
+      args->tags[i] |= collides(&args->rects[i], &args->zones[j]) << INSIDE_ZONE_TAG_SHIFT;
     }
 
-    index = (tags[i] & ENTITY_TAG_INSIDE_ZONE) >> INSIDE_ZONE_TAG_SHIFT;
+    index = (args->tags[i] & ENTITY_TAG_INSIDE_ZONE) >> INSIDE_ZONE_TAG_SHIFT;
 
-    max_x = WIDTH - rects[i].scale.width;
-    max_y = HEIGHT - rects[i].scale.height;
+    max_x = WIDTH - args->rects[i].scale.width;
+    max_y = HEIGHT - args->rects[i].scale.height;
 
-    pos_x = rects[i].position.x + velocities[i].x * multipliers[index] * delta;
-    pos_y = rects[i].position.y + velocities[i].y * multipliers[index] * delta;
+    pos_x = args->rects[i].position.x + args->velocities[i].x * multipliers[index] * args->delta;
+    pos_y = args->rects[i].position.y + args->velocities[i].y * multipliers[index] * args->delta;
 
     if (pos_x < 0 || pos_x >= max_x) {
       pos_x = min(max(pos_x, 0), max_x);
-      velocities[i].x *= -1;
+      args->velocities[i].x *= -1;
     }
 
     if (pos_y < 0 || pos_y >= max_y) {
       pos_y = min(max(pos_y, 0), max_y);
-      velocities[i].y *= -1;
+      args->velocities[i].y *= -1;
     }
 
-    rects[i].position.x = roundf(pos_x);
-    rects[i].position.y = roundf(pos_y);
-
-    ++total;
+    args->rects[i].position.x = roundf(pos_x);
+    args->rects[i].position.y = roundf(pos_y);
   }
 
-  return total;
+  return args;
+}
+
+void render_entities(const u8 *tags, const Rect *rects, u64 count) {
+  persistent RaylibDrawRectFunc renderers[2] = {DrawRectangle, DrawRectangleLines};
+  persistent Color colors[2]                 = {FG_COLOR, ZONE_COLOR};
+
+  for (u64 i = 0; i < count; ++i) {
+    u8 func_index  = (tags[i] & ENTITY_TAG_COLLIDER) >> COLLIDER_TAG_SHIFT;
+    u8 color_index = func_index | ((tags[i] & ENTITY_TAG_INSIDE_ZONE) >> INSIDE_ZONE_TAG_SHIFT);
+
+    renderers[func_index](
+      rects[i].position.x,
+      rects[i].position.y,
+      rects[i].scale.width,
+      rects[i].scale.height,
+      colors[color_index]
+    );
+  }
 }
 
 u8 collides(const Rect *rect, const Rect *collider) {
@@ -227,24 +313,3 @@ u8 collides(const Rect *rect, const Rect *collider) {
 i16 get_random_velocity(XOR256State *state) {
   return (wapp_prng_xorshift_256(state) % (MAX_ABS_VELOCITY + 1 - MIN_ABS_VELOCITY)) + MIN_ABS_VELOCITY;
 }
-
-u64 log_data(const Rect *rects, u64 count, FILE *fp, char *line) {
-  u64 total = 0;
-  for (u64 i = 0; i < count; ++i) {
-    snprintf(
-      line, LINE_BUF_LEN,
-      "x: %d, y: %d, width: %d, height: %d\n",
-      rects[i].position.x,
-      rects[i].position.y,
-      rects[i].scale.width,
-      rects[i].scale.height
-    );
-    u64 size = strlen(line);
-    fwrite(line, sizeof(char), size, fp);
-    memset(line, 0, size);
-
-    ++total;
-  }
-
-  return total;
-}

no_dod.c

@@ -1,10 +1,9 @@
 #include "wapp.h"
 #include "common.h"
+#include "raylib.h"
 #include <stdint.h>
 #include <stdbool.h>
 #include <assert.h>
-#include <time.h>
-#include <stdio.h>
 
 #define OBJECT_COMMON struct {Position position; Scale scale;}
 
@@ -40,11 +39,19 @@ struct SlowZone {
 
 void init_wanderer(Wanderer *wanderer, XOR256State *state);
 void move_wanderer(Wanderer *wanderer, const SlowZone *zones);
+void render_wanderer(const Wanderer *wanderer);
 void init_slow_zone(SlowZone *zone,  XOR256State *state);
+
+void render_slow_zone(const SlowZone *zone);
+
 bool inside_zone(const Wanderer *wanderer, const SlowZone *zone);
 f32 get_random_float(XOR256State *state);
 
 int main(void) {
+  SetTraceLogLevel(LOG_NONE);
+  InitWindow(WIDTH, HEIGHT, "No-DOD test");
+  SetTargetFPS(120);
+
   Allocator arena       = wapp_mem_arena_allocator_init(MB(20));
   XOR256State state     = wapp_prng_xorshift_init_state();
   u64 wanderers_size    = sizeof(Wanderer) * WANDERER_COUNT;
@@ -63,39 +70,36 @@ int main(void) {
     init_slow_zone(&(zones[i]),&state);
   }
 
-  FILE *fp = fopen("no_dod.out", "w");
-  assert(fp != NULL);
+  while (!WindowShouldClose()) {
+    f64 time = GetTime();
+    if (time >= 20.0) {
+      break;
+    }
 
-  u64 update_counter = 0;
-  u64 render_counter = 0;
-  for (u64 i = 0; i < LOOPS; ++i) {
     for (u64 i = 0; i < WANDERER_COUNT; ++i) {
       move_wanderer(&(wanderers[i]), zones);
-      ++update_counter;
     }
 
-    char line[LINE_BUF_LEN] = {0};
+    BeginDrawing();
+
+    ClearBackground(BG_COLOR);
+
+    for (u64 i = 0; i < ZONE_COUNT; ++i) {
+      render_slow_zone(&(zones[i]));
+    }
 
     for (u64 i = 0; i < WANDERER_COUNT; ++i) {
-      snprintf(
-        line, LINE_BUF_LEN,
-        "x: %f, y: %f, width: %f, height: %f\n",
-        wanderers[i].position.x,
-        wanderers[i].position.y,
-        wanderers[i].scale.width,
-        wanderers[i].scale.height
-      );
-      u64 size = strlen(line);
-      fwrite(line, sizeof(char), size, fp);
-      memset(line, 0, size);
-      ++render_counter;
-    }
+      render_wanderer(&(wanderers[i]));
+    }
+
+    DrawFPS(10, 10);
+
+    EndDrawing();
   }
 
-  fclose(fp);
   wapp_mem_arena_allocator_destroy(&arena);
 
-  printf("UPDATE: %lu, RENDER: %lu\n", update_counter, render_counter);
+  CloseWindow();
 
   return 0;
 }
@@ -153,6 +157,17 @@ void move_wanderer(Wanderer *wanderer, const SlowZone *zones) {
   }
 }
 
+void render_wanderer(const Wanderer *wanderer) {
+  Color color = wanderer->slow ? ZONE_COLOR : FG_COLOR;
+  DrawRectangle(
+    (i32)wanderer->position.x,
+    (i32)wanderer->position.y,
+    (i32)wanderer->scale.width,
+    (i32)wanderer->scale.height,
+    color
+  );
+}
+
 void init_slow_zone(SlowZone *zone,  XOR256State *state) {
   zone->position = (Position){
     .x = wapp_prng_xorshift_256(state) % WIDTH,
@@ -165,6 +180,16 @@ void init_slow_zone(SlowZone *zone,  XOR256State *state) {
   };
 }
 
+void render_slow_zone(const SlowZone *zone) {
+  DrawRectangleLines(
+    zone->position.x,
+    zone->position.y,
+    zone->scale.width,
+    zone->scale.height,
+    ZONE_COLOR
+  );
+}
+
 bool inside_zone(const Wanderer *wanderer, const SlowZone *zone) {
   f32 wanderer_min_x = wanderer->position.x + wanderer->scale.width;
   f32 wanderer_min_y = wanderer->position.y + wanderer->scale.height;