Rewrite mempools to be scalable

Changelog:
- Rewrite the Mempool Struct to be generic enough
- Static alloc for components mempool and entities mempool
- Component mempool now uses the component enum as index
- Update all mempool functions to work with the new struct

CMakeLists.txt

@@ -7,8 +7,6 @@ set(CMAKE_C_STANDARD 99)
 set(RAYLIB_DIR $ENV{HOME}/Documents/Coding/raylib/out/)
 
 
-
-
 add_subdirectory(sc)
 add_executable(${PROJECT_NAME}
     main.c

components.h

@@ -1,20 +1,25 @@
 #ifndef __COMPONENTS_H
 #define __COMPONENTS_H
-
+#include "raylib.h"
 // TODO: Look at sc to use macros to auto generate functions
 
-#define N_COMPONENTS 1
+#define N_COMPONENTS 2
 enum ComponentEnum
 {
     CBBOX_COMP_T,
+    CTRANSFORM_COMP_T,
 };
 typedef enum ComponentEnum ComponentEnum_t;
 
 typedef struct _CBBox_t
 {
-    int x;
-    int y;
-    int width;
-    int height;
+    Vector2 size;
 }CBBox_t;
+
+typedef struct _CTransform_t
+{
+    Vector2 position;
+    Vector2 velocity;
+    Vector2 accel;
+}CTransform_t;
 #endif // __COMPONENTS_H

entManager_test.c

@@ -13,10 +13,10 @@ int main(void)
     puts("Creating two entities");
     Entity_t *p_ent = add_entity(&manager, PLAYER_ENT_TAG);
     CBBox_t * p_bbox = (CBBox_t *)add_component(&manager, p_ent, CBBOX_COMP_T);
-    p_bbox->x = 15;
+    p_bbox->size.x = 15;
     p_ent = add_entity(&manager, ENEMY_ENT_TAG);
     p_bbox = (CBBox_t *)add_component(&manager, p_ent, CBBOX_COMP_T);
-    p_bbox->x = 40;
+    p_bbox->size.y = 40;
     update_entity_manager(&manager);
 
     puts("Print and remove the entities");
@@ -24,7 +24,7 @@ int main(void)
     sc_map_foreach(&manager.entities, idx, p_ent)
     {
         p_bbox = (CBBox_t *)get_component(&manager, p_ent, CBBOX_COMP_T);
-        printf("BBOX x: %d\n", p_bbox->x);
+        printf("BBOX: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
         remove_entity(&manager, idx);
     }
     puts("");
@@ -34,7 +34,7 @@ int main(void)
     sc_map_foreach(&manager.entities, idx, p_ent)
     {
         p_bbox = (CBBox_t *)get_component(&manager, p_ent, CBBOX_COMP_T);
-        printf("BBOX x: %d\n", p_bbox->x);
+        printf("BBOX: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
         remove_entity(&manager, idx);
     }
     puts("");

lsan_supp.txt

@@ -0,0 +1 @@
+leak:X11

mempool.c

@@ -2,47 +2,59 @@
 #include "sc/queue/sc_queue.h"
 #include "sc/map/sc_map.h"
 
+// Static allocate buffers
+static Entity_t entity_buffer[MAX_COMP_POOL_SIZE];
+static CBBox_t bbox_buffer[MAX_COMP_POOL_SIZE];
+static CTransform_t ctransform_buffer[MAX_COMP_POOL_SIZE];
+
 // Use hashmap as a Set
 // Use list will be used to check if an object exist
 // The alternative method to check the free list if idx is not there
 // requires bound checking
 // It's just easier on the mind overall
 // If need to optimise memory, replace free_list with set and remove use_list
-static struct EntityMemPool
+typedef struct MemPool
 {
-    Entity_t entity_buffer[MAX_COMP_POOL_SIZE];
+    void * const buffer;
+    const unsigned long max_size;
+    const unsigned long elem_size;
     struct sc_map_64 use_list;
     struct sc_queue_uint free_list;
-}entity_mem_pool;
+}MemPool_t;
 
-static struct BBoxMemPool
+// Static allocate mempools
+static MemPool_t comp_mempools[N_COMPONENTS] =
 {
-    CBBox_t bbox_buffer[MAX_COMP_POOL_SIZE];
-    struct sc_map_64 use_list;
-    struct sc_queue_uint free_list;
-}bbox_mem_pool;
+    {bbox_buffer, MAX_COMP_POOL_SIZE, sizeof(CBBox_t), {0}, {0}},
+    {ctransform_buffer, MAX_COMP_POOL_SIZE, sizeof(CTransform_t), {0}, {0}},
+};
+static MemPool_t ent_mempool = {entity_buffer, MAX_COMP_POOL_SIZE, sizeof(Entity_t), {0}, {0}};
 
 static bool pool_inited = false;
 void init_memory_pools(void)
 {
     if (!pool_inited)
     {
-        memset(bbox_mem_pool.bbox_buffer, 0, sizeof(bbox_mem_pool.bbox_buffer));
-        memset(entity_mem_pool.entity_buffer, 0, sizeof(entity_mem_pool.entity_buffer));
-        sc_queue_init(&bbox_mem_pool.free_list);
-        for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
+        for (size_t i=0; i<N_COMPONENTS; ++i)
         {
-            sc_queue_add_last(&(bbox_mem_pool.free_list), i);
+            memset(comp_mempools[i].buffer, 0, comp_mempools[i].elem_size*comp_mempools[i].max_size);
+            sc_map_init_64(&comp_mempools[i].use_list, MAX_COMP_POOL_SIZE ,0);
+            sc_queue_init(&comp_mempools[i].free_list);
+            for (size_t j=0;j<MAX_COMP_POOL_SIZE;++j)
+            {
+                sc_queue_add_last(&comp_mempools[i].free_list, j);
+            }
         }
-        sc_queue_init(&entity_mem_pool.free_list);
-        for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
+
+        memset(ent_mempool.buffer, 0, ent_mempool.elem_size*ent_mempool.max_size);
+        sc_queue_init(&ent_mempool.free_list);
+        sc_map_init_64(&ent_mempool.use_list, MAX_COMP_POOL_SIZE ,0);
+        for (size_t i=0;i<MAX_COMP_POOL_SIZE;++i)
         {
-            entity_mem_pool.entity_buffer[i].m_id = i;
-            sc_map_init_64(&entity_mem_pool.entity_buffer[i].components, 16 ,0);
-            sc_queue_add_last(&(entity_mem_pool.free_list), i);
+            entity_buffer[i].m_id = i;
+            sc_map_init_64(&entity_buffer[i].components, 16 ,0);
+            sc_queue_add_last(&(ent_mempool.free_list), i);
         }
-        sc_map_init_64(&bbox_mem_pool.use_list, MAX_COMP_POOL_SIZE ,0);
-        sc_map_init_64(&entity_mem_pool.use_list, MAX_COMP_POOL_SIZE ,0);
         pool_inited = true;
     }
 }
@@ -51,13 +63,17 @@ void free_memory_pools(void)
 {
     if (pool_inited)
     {
-        sc_map_term_64(&bbox_mem_pool.use_list);
-        sc_map_term_64(&entity_mem_pool.use_list);
-        sc_queue_term(&bbox_mem_pool.free_list);
-        sc_queue_term(&entity_mem_pool.free_list);
+        for (size_t i=0; i<N_COMPONENTS; ++i)
+        {
+            sc_map_term_64(&comp_mempools[i].use_list);
+            sc_queue_term(&comp_mempools[i].free_list);
+        }
+        sc_map_term_64(&ent_mempool.use_list);
+        sc_queue_term(&ent_mempool.free_list);
+
         for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
         {
-            sc_map_term_64(&entity_mem_pool.entity_buffer[i].components);
+            sc_map_term_64(&entity_buffer[i].components);
         }
         pool_inited = false;
     }
@@ -65,11 +81,11 @@ void free_memory_pools(void)
 
 Entity_t* new_entity_from_mempool(unsigned long *p_e_idx)
 {
-    if(sc_queue_empty(&entity_mem_pool.free_list)) return NULL;
-    unsigned long e_idx = sc_queue_del_first(&entity_mem_pool.free_list);
+    if(sc_queue_empty(&ent_mempool.free_list)) return NULL;
+    unsigned long e_idx = sc_queue_del_first(&ent_mempool.free_list);
     *p_e_idx = e_idx;
-    sc_map_put_64(&entity_mem_pool.use_list, e_idx, e_idx);
-    Entity_t * ent = entity_mem_pool.entity_buffer + e_idx;
+    sc_map_put_64(&ent_mempool.use_list, e_idx, e_idx);
+    Entity_t * ent = entity_buffer + e_idx;
     sc_map_clear_64(&ent->components);
     ent->m_alive = true;
     ent->m_tag = NO_ENT_TAG;
@@ -78,34 +94,30 @@ Entity_t* new_entity_from_mempool(unsigned long *p_e_idx)
 
 Entity_t * get_entity_wtih_id(unsigned long idx)
 {
-    sc_map_get_64(&entity_mem_pool.use_list, idx);
-    if (!sc_map_found(&entity_mem_pool.use_list)) return NULL;
-    return entity_mem_pool.entity_buffer + idx;
+    sc_map_get_64(&ent_mempool.use_list, idx);
+    if (!sc_map_found(&ent_mempool.use_list)) return NULL;
+    return entity_buffer + idx;
 }
 
 void free_entity_to_mempool(unsigned long idx)
 {
-	sc_map_del_64(&entity_mem_pool.use_list, idx);
-	if (sc_map_found(&entity_mem_pool.use_list))
+	sc_map_del_64(&ent_mempool.use_list, idx);
+	if (sc_map_found(&ent_mempool.use_list))
     {
-        sc_queue_add_first(&entity_mem_pool.free_list, idx);
+        sc_queue_add_first(&ent_mempool.free_list, idx);
     }
 }
 
 void* new_component_from_mempool(ComponentEnum_t comp_type, unsigned long *idx)
 {
     void * comp = NULL;
-    switch(comp_type)
+    assert(comp_type < N_COMPONENTS);
+    if(!sc_queue_empty(&comp_mempools[comp_type].free_list))
     {
-        case CBBOX_COMP_T:
-            if(sc_queue_empty(&bbox_mem_pool.free_list)) break;
-            *idx = sc_queue_del_first(&bbox_mem_pool.free_list);
-            sc_map_put_64(&bbox_mem_pool.use_list, *idx, *idx);
-            comp = bbox_mem_pool.bbox_buffer + *idx;
-            memset(comp, 0, sizeof(CBBox_t));
-        break;
-        default:
-        break;
+        *idx = sc_queue_del_first(&comp_mempools[comp_type].free_list);
+        sc_map_put_64(&comp_mempools[comp_type].use_list, *idx, *idx);
+        comp = comp_mempools[comp_type].buffer + (*idx * comp_mempools[comp_type].elem_size);
+        memset(comp, 0, comp_mempools[comp_type].elem_size);
     }
     return comp;
 }
@@ -113,32 +125,22 @@ void* new_component_from_mempool(ComponentEnum_t comp_type, unsigned long *idx)
 void* get_component_wtih_id(ComponentEnum_t comp_type, unsigned long idx)
 {
     void * comp = NULL;
-    switch(comp_type)
+    assert(comp_type < N_COMPONENTS);
+    sc_map_get_64(&comp_mempools[comp_type].use_list, idx);
+    if (sc_map_found(&comp_mempools[comp_type].use_list))
     {
-        case CBBOX_COMP_T:
-            sc_map_get_64(&bbox_mem_pool.use_list, idx);
-            if (!sc_map_found(&bbox_mem_pool.use_list)) break;
-            comp = bbox_mem_pool.bbox_buffer + idx;
-        break;
-        default:
-        break;
+        comp = comp_mempools[comp_type].buffer + (idx * comp_mempools[comp_type].elem_size);
     }
     return comp;
 }
 
 void free_component_to_mempool(ComponentEnum_t comp_type, unsigned long idx)
 {
+    assert(comp_type < N_COMPONENTS);
     // This just free the component from the memory pool
-    switch(comp_type)
+    sc_map_del_64(&comp_mempools[comp_type].use_list, idx);
+    if (sc_map_found(&comp_mempools[comp_type].use_list))
     {
-        case CBBOX_COMP_T:
-            sc_map_del_64(&bbox_mem_pool.use_list, idx);
-            if (sc_map_found(&bbox_mem_pool.use_list))
-            {
-                sc_queue_add_first(&bbox_mem_pool.free_list, idx);
-            }
-        break;
-        default:
-        break;
+        sc_queue_add_first(&comp_mempools[comp_type].free_list, idx);
     }
 }

scene_impl.c

@@ -1,14 +1,37 @@
 #include "scene_impl.h"
 #include "raylib.h"
+#include "raymath.h"
+#include <stdio.h>
 
 static void level_scene_render_func(Scene_t* scene)
 {
+    Entity_t *p_ent;
+    sc_map_foreach_value(&scene->ent_manager.entities, p_ent)
+    {
+        CTransform_t* p_ct = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
+        CBBox_t* p_bbox = get_component(&scene->ent_manager, p_ent, CBBOX_COMP_T);
+        DrawRectangle(p_ct->position.x, p_ct->position.y, p_bbox->size.x, p_bbox->size.y, RED);
+    }
     return;
 }
 
 static void movement_update_system(Scene_t* scene)
 {
-    return;
+    puts("Updating movement");
+    float delta_time = GetFrameTime();
+    CTransform_t * p_ctransform;
+    sc_map_foreach_value(&scene->ent_manager.component_map[CTRANSFORM_COMP_T], p_ctransform)
+    {
+        p_ctransform->velocity = Vector2Add(
+            p_ctransform->velocity,
+            Vector2Scale(p_ctransform->accel, delta_time)
+        );
+        p_ctransform->position = Vector2Add(
+            p_ctransform->position,
+            Vector2Scale(p_ctransform->velocity, delta_time)
+        );
+
+    }
 }
 void init_level_scene(LevelScene_t *scene)
 {

scene_test.c

@@ -1,11 +1,38 @@
 #include "mempool.h"
 #include "scene_impl.h"
 #include <stdio.h>
+#include <unistd.h>
 
 int main(void)
 {
+    InitWindow(320, 240, "raylib");
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+    init_memory_pools();
     LevelScene_t scene;
     init_level_scene(&scene);
-    update_scene(&scene.scene);
+    Entity_t *p_ent = add_entity(&scene.scene.ent_manager, PLAYER_ENT_TAG);
+    CBBox_t *p_bbox = add_component(&scene.scene.ent_manager, p_ent, CBBOX_COMP_T);
+    p_bbox->size.x = 30;
+    p_bbox->size.y = 30;
+    CTransform_t * p_ctran = (CTransform_t *)add_component(&scene.scene.ent_manager, p_ent, CTRANSFORM_COMP_T);
+    p_ctran->accel.x = 20;
+    p_ctran->accel.y = 10;
+    update_entity_manager(&scene.scene.ent_manager);
+    for (size_t step = 0; step < 120; step++)
+    {
+        puts("======");
+        printf("Step %lu\n", step);
+        update_scene(&scene.scene);
+        printf("Position: %f,%f\n", p_ctran->position.x, p_ctran->position.y);
+        printf("Velocity: %f,%f\n", p_ctran->velocity.x, p_ctran->velocity.y);
+        printf("Accel: %f,%f\n", p_ctran->accel.x, p_ctran->accel.y);
+        // This is needed to advance time delta
+        BeginDrawing();
+            // TODO: Call the current scene Render function
+            render_scene(&scene.scene);
+            ClearBackground(RAYWHITE);
+        EndDrawing();
+    } 
+    CloseWindow();
     free_level_scene(&scene);
 }