CMakeLists.txt

@@ -7,6 +7,8 @@ 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,25 +1,20 @@
 #ifndef __COMPONENTS_H
 #define __COMPONENTS_H
-#include "raylib.h"
+
 // TODO: Look at sc to use macros to auto generate functions
 
-#define N_COMPONENTS 2
+#define N_COMPONENTS 1
 enum ComponentEnum
 {
     CBBOX_COMP_T,
-    CTRANSFORM_COMP_T,
 };
 typedef enum ComponentEnum ComponentEnum_t;
 
 typedef struct _CBBox_t
 {
-    Vector2 size;
+    int x;
+    int y;
+    int width;
+    int height;
 }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->size.x = 15;
+    p_bbox->x = 15;
     p_ent = add_entity(&manager, ENEMY_ENT_TAG);
     p_bbox = (CBBox_t *)add_component(&manager, p_ent, CBBOX_COMP_T);
-    p_bbox->size.y = 40;
+    p_bbox->x = 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: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
+        printf("BBOX x: %d\n", p_bbox->x);
         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: %f,%f\n", p_bbox->size.x, p_bbox->size.y);
+        printf("BBOX x: %d\n", p_bbox->x);
         remove_entity(&manager, idx);
     }
     puts("");

lsan_supp.txt

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

mempool.c

@@ -2,59 +2,47 @@
 #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
-typedef struct MemPool
+static struct EntityMemPool
 {
-    void * const buffer;
-    const unsigned long max_size;
-    const unsigned long elem_size;
+    Entity_t entity_buffer[MAX_COMP_POOL_SIZE];
     struct sc_map_64 use_list;
     struct sc_queue_uint free_list;
-}MemPool_t;
+}entity_mem_pool;
 
-// Static allocate mempools
-static MemPool_t comp_mempools[N_COMPONENTS] =
+static struct BBoxMemPool
 {
-    {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}};
+    CBBox_t bbox_buffer[MAX_COMP_POOL_SIZE];
+    struct sc_map_64 use_list;
+    struct sc_queue_uint free_list;
+}bbox_mem_pool;
 
 static bool pool_inited = false;
 void init_memory_pools(void)
 {
     if (!pool_inited)
     {
-        for (size_t i=0; i<N_COMPONENTS; ++i)
+        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)
         {
-            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(&(bbox_mem_pool.free_list), i);
+        }
+        sc_queue_init(&entity_mem_pool.free_list);
+        for (int i=0;i<MAX_COMP_POOL_SIZE;++i)
         {
-                sc_queue_add_last(&comp_mempools[i].free_list, j);
-            }
-        }
-
-        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_buffer[i].m_id = i;
-            sc_map_init_64(&entity_buffer[i].components, 16 ,0);
-            sc_queue_add_last(&(ent_mempool.free_list), 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);
         }
+        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;
     }
 }
@@ -63,17 +51,13 @@ void free_memory_pools(void)
 {
     if (pool_inited)
     {
-        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);
-
+        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 (int i=0;i<MAX_COMP_POOL_SIZE;++i)
         {
-            sc_map_term_64(&entity_buffer[i].components);
+            sc_map_term_64(&entity_mem_pool.entity_buffer[i].components);
         }
         pool_inited = false;
     }
@@ -81,11 +65,11 @@ void free_memory_pools(void)
 
 Entity_t* new_entity_from_mempool(unsigned long *p_e_idx)
 {
-    if(sc_queue_empty(&ent_mempool.free_list)) return NULL;
-    unsigned long e_idx = sc_queue_del_first(&ent_mempool.free_list);
+    if(sc_queue_empty(&entity_mem_pool.free_list)) return NULL;
+    unsigned long e_idx = sc_queue_del_first(&entity_mem_pool.free_list);
     *p_e_idx = e_idx;
-    sc_map_put_64(&ent_mempool.use_list, e_idx, e_idx);
-    Entity_t * ent = entity_buffer + 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_clear_64(&ent->components);
     ent->m_alive = true;
     ent->m_tag = NO_ENT_TAG;
@@ -94,30 +78,34 @@ Entity_t* new_entity_from_mempool(unsigned long *p_e_idx)
 
 Entity_t * get_entity_wtih_id(unsigned long idx)
 {
-    sc_map_get_64(&ent_mempool.use_list, idx);
-    if (!sc_map_found(&ent_mempool.use_list)) return NULL;
-    return entity_buffer + 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;
 }
 
 void free_entity_to_mempool(unsigned long idx)
 {
-	sc_map_del_64(&ent_mempool.use_list, idx);
-	if (sc_map_found(&ent_mempool.use_list))
+	sc_map_del_64(&entity_mem_pool.use_list, idx);
+	if (sc_map_found(&entity_mem_pool.use_list))
     {
-        sc_queue_add_first(&ent_mempool.free_list, idx);
+        sc_queue_add_first(&entity_mem_pool.free_list, idx);
     }
 }
 
 void* new_component_from_mempool(ComponentEnum_t comp_type, unsigned long *idx)
 {
     void * comp = NULL;
-    assert(comp_type < N_COMPONENTS);
-    if(!sc_queue_empty(&comp_mempools[comp_type].free_list))
+    switch(comp_type)
     {
-        *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);
+        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;
     }
     return comp;
 }
@@ -125,22 +113,32 @@ 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;
-    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))
+    switch(comp_type)
     {
-        comp = comp_mempools[comp_type].buffer + (idx * comp_mempools[comp_type].elem_size);
+        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;
     }
     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
-    sc_map_del_64(&comp_mempools[comp_type].use_list, idx);
-    if (sc_map_found(&comp_mempools[comp_type].use_list))
+    switch(comp_type)
     {
-        sc_queue_add_first(&comp_mempools[comp_type].free_list, idx);
+        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;
     }
 }

scene_impl.c

@@ -1,37 +1,14 @@
 #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)
 {
-    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)
-        );
-
-    }
+    return;
 }
 void init_level_scene(LevelScene_t *scene)
 {

scene_test.c

@@ -1,38 +1,11 @@
 #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);
-    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);
 }