Replace method to get Scene specific data

Changelog:
- Use CONTAINER_OF macros to get scene specific data
- Remove unnecessary scene_data from Scene_t
- Still use pointer to scene specific data as these data could be
  quite heavy on memory

assets_test.c

@@ -56,6 +56,6 @@ int main(void)
             spr2->elapsed = 0;
         }
     } 
-    CloseWindow();
     term_assets(&assets);
+    CloseWindow();
 }

engine/constants.h

@@ -3,12 +3,16 @@
 #define __CONSTANTS_H
 #ifndef TILE16_SIZE
 #define TILE_SIZE 32
-#define DEFAULT_MAP_WIDTH 32
+#define DEFAULT_MAP_WIDTH 48
 #define DEFAULT_MAP_HEIGHT 16
+#define VIEWABLE_MAP_WIDTH 32
+#define VIEWABLE_MAP_HEIGHT 16
 #else
 #define TILE_SIZE 16
 #define DEFAULT_MAP_WIDTH 64
 #define DEFAULT_MAP_HEIGHT 32
+#define VIEWABLE_MAP_WIDTH 32
+#define VIEWABLE_MAP_HEIGHT 16
 #endif
 
 #define GRAV_ACCEL 1500

engine/editor_scene.c

@@ -16,168 +16,193 @@ enum EntitySpawnSelection {
     SPAWN_CRATE,
     SPAWN_METAL_CRATE,
 };
-#define MAX_SPAWN_TYPE 4
+#define MAX_SPAWN_TYPE 5
 static unsigned int current_spawn_selection = 0;
 
-static inline unsigned int get_tile_idx(int x, int y, unsigned int tilemap_width)
+static inline unsigned int get_tile_idx(int x, int y, const TileGrid_t* tilemap)
 {
     unsigned int tile_x = x / TILE_SIZE;
     unsigned int tile_y = y / TILE_SIZE;
-    return tile_y * tilemap_width + tile_x;
+
+    if (tile_x < tilemap->width && tile_y < tilemap->height)
+    {
+        return tile_y * tilemap->width + tile_x;
+    }
+
+    return MAX_N_TILES;
 }
 
 static void level_scene_render_func(Scene_t* scene)
 {
-    LevelSceneData_t* data = (LevelSceneData_t *)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     TileGrid_t tilemap = data->tilemap;
 
     Entity_t* p_ent;
 
-    for (size_t i = 0; i < tilemap.n_tiles; ++i)
-    {
-        char buffer[6] = {0};
-        int x = (i % tilemap.width) * TILE_SIZE;
-        int y = (i / tilemap.width) * TILE_SIZE;
-        sprintf(buffer, "%u", sc_map_size_64(&tilemap.tiles[i].entities_set));
+    BeginTextureMode(data->game_viewport);
+        ClearBackground(RAYWHITE);
+        BeginMode2D(data->cam);
+        for (size_t i = 0; i < tilemap.n_tiles; ++i)
+        {
+            char buffer[6] = {0};
+            int x = (i % tilemap.width) * TILE_SIZE;
+            int y = (i / tilemap.width) * TILE_SIZE;
+            sprintf(buffer, "%u", sc_map_size_64(&tilemap.tiles[i].entities_set));
 
-        if (tilemap.tiles[i].tile_type == SOLID_TILE)
-        {
-            DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, BLACK);
-        }
-        else if (tilemap.tiles[i].tile_type == ONEWAY_TILE)
-        {
-            DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, MAROON);
-        }
-        else if (tilemap.tiles[i].tile_type == LADDER)
-        {
-            DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, ORANGE);
-        }
-
-        if (tilemap.tiles[i].water_level > 0)
-        {
-            // Draw water tile
-            Color water_colour = ColorAlpha(BLUE, 0.5);
-            DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, water_colour);
-        }
-    }
-
-    char buffer[64] = {0};
-    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);
-        Color colour;
-        switch(p_ent->m_tag)
-        {
-            case PLAYER_ENT_TAG:
-                colour = RED;
-            break;
-            case CRATES_ENT_TAG:
-                colour = p_bbox->fragile? BROWN : GRAY;
-            break;
-            default:
-                colour = BLACK;
-        }
-        DrawRectangle(p_ct->position.x, p_ct->position.y, p_bbox->size.x, p_bbox->size.y, colour);
-        CHurtbox_t* p_hurtbox = get_component(&scene->ent_manager, p_ent, CHURTBOX_T);
-        CHitBoxes_t* p_hitbox = get_component(&scene->ent_manager, p_ent, CHITBOXES_T);
-        if (p_hitbox != NULL)
-        {
-            for (uint8_t i = 0;i < p_hitbox->n_boxes; ++i)
+            if (tilemap.tiles[i].tile_type == SOLID_TILE)
             {
-                Rectangle rec = {
-                    .x = p_ct->position.x + p_hitbox->boxes[i].x,
-                    .y = p_ct->position.y + p_hitbox->boxes[i].y,
-                    .width = p_hitbox->boxes[i].width,
-                    .height = p_hitbox->boxes[i].height,
-                };
-                DrawRectangleLinesEx(rec, 1.5, ORANGE);
+                DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, BLACK);
+            }
+            else if (tilemap.tiles[i].tile_type == ONEWAY_TILE)
+            {
+                DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, MAROON);
+            }
+            else if (tilemap.tiles[i].tile_type == LADDER)
+            {
+                DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, ORANGE);
+            }
+
+            if (tilemap.tiles[i].water_level > 0)
+            {
+                // Draw water tile
+                Color water_colour = ColorAlpha(BLUE, 0.5);
+                DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, water_colour);
             }
         }
-        if (p_hurtbox != NULL)
+
+        char buffer[64] = {0};
+        sc_map_foreach_value(&scene->ent_manager.entities, p_ent)
         {
-            Rectangle rec = {
-                .x = p_ct->position.x + p_hurtbox->offset.x,
-                .y = p_ct->position.y + p_hurtbox->offset.y,
-                .width = p_hurtbox->size.x,
-                .height = p_hurtbox->size.y,
-            };
-            DrawRectangleLinesEx(rec, 1.5, PURPLE);
+            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);
+            Color colour;
+            switch(p_ent->m_tag)
+            {
+                case PLAYER_ENT_TAG:
+                    colour = RED;
+                break;
+                case CRATES_ENT_TAG:
+                    colour = p_bbox->fragile? BROWN : GRAY;
+                break;
+                default:
+                    colour = BLACK;
+            }
+            DrawRectangle(p_ct->position.x, p_ct->position.y, p_bbox->size.x, p_bbox->size.y, colour);
+            CHurtbox_t* p_hurtbox = get_component(&scene->ent_manager, p_ent, CHURTBOX_T);
+            CHitBoxes_t* p_hitbox = get_component(&scene->ent_manager, p_ent, CHITBOXES_T);
+            if (p_hitbox != NULL)
+            {
+                for (uint8_t i = 0;i < p_hitbox->n_boxes; ++i)
+                {
+                    Rectangle rec = {
+                        .x = p_ct->position.x + p_hitbox->boxes[i].x,
+                        .y = p_ct->position.y + p_hitbox->boxes[i].y,
+                        .width = p_hitbox->boxes[i].width,
+                        .height = p_hitbox->boxes[i].height,
+                    };
+                    DrawRectangleLinesEx(rec, 1.5, ORANGE);
+                }
+            }
+            if (p_hurtbox != NULL)
+            {
+                Rectangle rec = {
+                    .x = p_ct->position.x + p_hurtbox->offset.x,
+                    .y = p_ct->position.y + p_hurtbox->offset.y,
+                    .width = p_hurtbox->size.x,
+                    .height = p_hurtbox->size.y,
+                };
+                DrawRectangleLinesEx(rec, 1.5, PURPLE);
+            }
+            CSprite_t* p_cspr = get_component(&scene->ent_manager, p_ent, CSPRITE_T);
+            if (p_cspr != NULL)
+            {
+                Vector2 pos = Vector2Add(p_ct->position, p_cspr->offset);
+                draw_sprite(p_cspr->sprite, pos);
+            }
         }
-        CSprite_t* p_cspr = get_component(&scene->ent_manager, p_ent, CSPRITE_T);
-        if (p_cspr != NULL)
+
+        for (size_t i = 0; i < tilemap.n_tiles; ++i)
         {
-            Vector2 pos = Vector2Add(p_ct->position, p_cspr->offset);
-            draw_sprite(p_cspr->sprite, pos);
+            int x = (i % tilemap.width) * TILE_SIZE;
+            int y = (i / tilemap.width) * TILE_SIZE;
+            sprintf(buffer, "%u", sc_map_size_64(&tilemap.tiles[i].entities_set));
+
+            if (tilemap.tiles[i].solid > 0)
+            {
+                DrawText(buffer, x, y, 10, WHITE);
+            }
+            else
+            {
+                // Draw water tile
+                DrawText(buffer, x, y, 10, BLACK);
+            }
         }
-    }
 
-    for (size_t i = 0; i < tilemap.n_tiles; ++i)
-    {
-        int x = (i % tilemap.width) * TILE_SIZE;
-        int y = (i / tilemap.width) * TILE_SIZE;
-        sprintf(buffer, "%u", sc_map_size_64(&tilemap.tiles[i].entities_set));
-
-        if (tilemap.tiles[i].solid > 0)
+        // Draw tile grid
+        for (size_t i = 0; i < tilemap.width; ++i)
         {
-            DrawText(buffer, x, y, 10, WHITE);
+            int x = (i+1)*TILE_SIZE;
+            DrawLine(x, 0, x, tilemap.height * TILE_SIZE, BLACK);
         }
-        else
+        for (size_t i = 0; i < tilemap.height;++i)
         {
-            // Draw water tile
-            DrawText(buffer, x, y, 10, BLACK);
+            int y = (i+1)*TILE_SIZE;
+            DrawLine(0, y, tilemap.width * TILE_SIZE, y, BLACK);
         }
-    }
+        EndMode2D();
+    EndTextureMode();
 
-    // Draw tile grid
-    for (size_t i = 0; i < tilemap.width; ++i)
-    {
-        int x = (i+1)*TILE_SIZE;
-        DrawLine(x, 0, x, tilemap.height * TILE_SIZE, BLACK);
-    }
-    for (size_t i = 0; i < tilemap.height;++i)
-    {
-        int y = (i+1)*TILE_SIZE;
-        DrawLine(0, y, tilemap.width * TILE_SIZE, y, BLACK);
-    }
+    Rectangle draw_rec = data->game_rec;
+    draw_rec.x = 0;
+    draw_rec.y = 0;
+    draw_rec.height *= -1;
+    BeginDrawing();
+        ClearBackground(LIGHTGRAY);
+        DrawTextureRec(
+            data->game_viewport.texture,
+            draw_rec,
+            (Vector2){data->game_rec.x, data->game_rec.y},
+            WHITE
+        );
+        // For DEBUG
+        const int gui_x = data->game_rec.x + data->game_rec.width + 10;
+        sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], p_ent)
+        {
+            CTransform_t* p_ct = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
+            CJump_t* p_cjump = get_component(&scene->ent_manager, p_ent, CJUMP_COMP_T);
+            CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_ent, CPLAYERSTATE_T);
+            CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_ent, CMOVEMENTSTATE_T);
+            sprintf(buffer, "Pos: %.3f\n %.3f", p_ct->position.x, p_ct->position.y);
+            DrawText(buffer, gui_x, 15, 12, BLACK);
+            sprintf(buffer, "Vel: %.3f\n %.3f", p_ct->velocity.x, p_ct->velocity.y);
+            DrawText(buffer, gui_x + 80, 15, 12, BLACK);
+            //sprintf(buffer, "Accel: %.3f\n %.3f", p_ct->accel.x, p_ct->accel.y);
+            //DrawText(buffer, tilemap.width * TILE_SIZE + 128, 60, 12, BLACK);
+            sprintf(buffer, "Jumps: %u", p_cjump->jumps);
+            DrawText(buffer, gui_x, 60, 12, BLACK);
+            sprintf(buffer, "Crouch: %u", p_pstate->is_crouch);
+            DrawText(buffer, gui_x, 90, 12, BLACK);
+            sprintf(buffer, "Water: %s", p_mstate->water_state & 1? "YES":"NO");
+            DrawText(buffer, gui_x, 120, 12, BLACK);
+            sprintf(buffer, "Ladder: %u", p_pstate->ladder_state);
+            DrawText(buffer, gui_x, 150, 12, BLACK);
+        }
+        sprintf(buffer, "Spawn Entity: %u", current_spawn_selection);
+        DrawText(buffer, gui_x, 240, 12, BLACK);
+        sprintf(buffer, "Number of Entities: %u", sc_map_size_64v(&scene->ent_manager.entities));
+        DrawText(buffer, gui_x, 270, 12, BLACK);
+        sprintf(buffer, "FPS: %u", GetFPS());
+        DrawText(buffer, gui_x, 320, 12, BLACK);
 
-    // For DEBUG
-    sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], p_ent)
-    {
-        CTransform_t* p_ct = get_component(&scene->ent_manager, p_ent, CTRANSFORM_COMP_T);
-        CJump_t* p_cjump = get_component(&scene->ent_manager, p_ent, CJUMP_COMP_T);
-        CPlayerState_t* p_pstate = get_component(&scene->ent_manager, p_ent, CPLAYERSTATE_T);
-        CMovementState_t* p_mstate = get_component(&scene->ent_manager, p_ent, CMOVEMENTSTATE_T);
-        sprintf(buffer, "Pos: %.3f\n %.3f", p_ct->position.x, p_ct->position.y);
-        DrawText(buffer, tilemap.width * TILE_SIZE + 1, 15, 12, BLACK);
-        sprintf(buffer, "Vel: %.3f\n %.3f", p_ct->velocity.x, p_ct->velocity.y);
-        DrawText(buffer, tilemap.width * TILE_SIZE + 128, 15, 12, BLACK);
-        //sprintf(buffer, "Accel: %.3f\n %.3f", p_ct->accel.x, p_ct->accel.y);
-        //DrawText(buffer, tilemap.width * TILE_SIZE + 128, 60, 12, BLACK);
-        sprintf(buffer, "Jumps: %u", p_cjump->jumps);
-        DrawText(buffer, tilemap.width * TILE_SIZE + 1, 60, 12, BLACK);
-        sprintf(buffer, "Crouch: %u", p_pstate->is_crouch);
-        DrawText(buffer, tilemap.width * TILE_SIZE + 1, 90, 12, BLACK);
-        sprintf(buffer, "Water: %s", p_mstate->water_state & 1? "YES":"NO");
-        DrawText(buffer, tilemap.width * TILE_SIZE + 1, 120, 12, BLACK);
-        sprintf(buffer, "Ladder: %u", p_pstate->ladder_state);
-        DrawText(buffer, tilemap.width * TILE_SIZE + 1, 150, 12, BLACK);
-    }
-    sprintf(buffer, "Spawn Entity: %u", current_spawn_selection);
-    DrawText(buffer, tilemap.width * TILE_SIZE + 1, 240, 12, BLACK);
-    sprintf(buffer, "Number of Entities: %u", sc_map_size_64v(&scene->ent_manager.entities));
-    DrawText(buffer, tilemap.width * TILE_SIZE + 1, 270, 12, BLACK);
-    sprintf(buffer, "FPS: %u", GetFPS());
-    DrawText(buffer, tilemap.width * TILE_SIZE + 1, 320, 12, BLACK);
-
-    static char mempool_stats[512];
-    print_mempool_stats(mempool_stats);
-    DrawText(mempool_stats, tilemap.width * TILE_SIZE + 1, 350, 12, BLACK);
+        static char mempool_stats[512];
+        print_mempool_stats(mempool_stats);
+        DrawText(mempool_stats, gui_x, 350, 12, BLACK);
+    EndDrawing();
 }
 
 static void spawn_crate(Scene_t* scene, unsigned int tile_idx, bool metal)
 {
-    LevelSceneData_t* data = (LevelSceneData_t*)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     Entity_t* p_crate = add_entity(&scene->ent_manager, CRATES_ENT_TAG);
     CBBox_t* p_bbox = add_component(&scene->ent_manager, p_crate, CBBOX_COMP_T);
 
@@ -235,12 +260,21 @@ static void toggle_block_system(Scene_t* scene)
 {
     // TODO: This system is not good as the interface between raw input and actions is broken
     static unsigned int last_tile_idx = MAX_N_TILES;
-    LevelSceneData_t *data = (LevelSceneData_t *)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     TileGrid_t tilemap = data->tilemap;
+    Vector2 raw_mouse_pos = {GetMouseX(), GetMouseY()};
+    raw_mouse_pos = Vector2Subtract(raw_mouse_pos, (Vector2){data->game_rec.x, data->game_rec.y});
 
     if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
     {
-        unsigned int tile_idx = get_tile_idx(GetMouseX(), GetMouseY(), tilemap.width);
+        if (
+            raw_mouse_pos.x > data->game_rec.width
+            || raw_mouse_pos.y > data->game_rec.height
+        ) return;
+        Vector2 mouse_pos = GetScreenToWorld2D(raw_mouse_pos, data->cam);
+        
+        unsigned int tile_idx = get_tile_idx(mouse_pos.x, mouse_pos.y, &tilemap);
+        if (tile_idx >= MAX_N_TILES) return;
         enum EntitySpawnSelection sel = (enum EntitySpawnSelection)current_spawn_selection;
         if (tile_idx != last_tile_idx)
         {
@@ -306,10 +340,16 @@ static void toggle_block_system(Scene_t* scene)
             last_tile_idx = tile_idx;
         }
     }
-    // TODO: Check for right click to change to water, also update above
     else if (IsMouseButtonDown(MOUSE_RIGHT_BUTTON))
     {
-        unsigned int tile_idx = get_tile_idx(GetMouseX(), GetMouseY(), tilemap.width);
+        if (
+            raw_mouse_pos.x > data->game_rec.width
+            || raw_mouse_pos.y > data->game_rec.height
+        ) return;
+        Vector2 mouse_pos = GetScreenToWorld2D(raw_mouse_pos, data->cam);
+        
+        unsigned int tile_idx = get_tile_idx(mouse_pos.x, mouse_pos.y, &tilemap);
+        if (tile_idx >= MAX_N_TILES) return;
         if (tile_idx != last_tile_idx)
         {
             if (tilemap.tiles[tile_idx].water_level == 0)
@@ -383,7 +423,6 @@ void level_do_action(Scene_t* scene, ActionType_t action, bool pressed)
 void init_level_scene(LevelScene_t* scene)
 {
     init_scene(&scene->scene, LEVEL_SCENE, &level_scene_render_func, &level_do_action);
-    scene->scene.scene_data = &scene->data;
 
     init_level_scene_data(&scene->data);
     // insert level scene systems
@@ -399,6 +438,7 @@ void init_level_scene(LevelScene_t* scene)
     sc_array_add(&scene->scene.systems, &state_transition_update_system);
     sc_array_add(&scene->scene.systems, &player_ground_air_transition_system);
     sc_array_add(&scene->scene.systems, &sprite_animation_system);
+    sc_array_add(&scene->scene.systems, &camera_update_system);
     sc_array_add(&scene->scene.systems, &toggle_block_system);
 
     // This avoid graphical glitch, not essential

engine/engine.h

@@ -38,7 +38,6 @@ struct Scene {
     EntityManager_t ent_manager;
     SceneType_t scene_type;
     SceneState_t state;
-    void * scene_data;
     GameEngine_t *engine;
 };
 

engine/game_systems.c

@@ -299,7 +299,7 @@ static Vector2 shift_bbox(Vector2 bbox, Vector2 new_bbox, AnchorPoint_t anchor)
 
 void player_movement_input_system(Scene_t* scene)
 {
-    LevelSceneData_t* data = (LevelSceneData_t*)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     TileGrid_t tilemap = data->tilemap;
 
     // Deal with player acceleration/velocity via inputs first
@@ -472,7 +472,7 @@ void player_movement_input_system(Scene_t* scene)
 
 void player_bbox_update_system(Scene_t* scene)
 {
-    LevelSceneData_t* data = (LevelSceneData_t*)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     TileGrid_t tilemap = data->tilemap;
 
     Entity_t* p_player;
@@ -538,7 +538,7 @@ void tile_collision_system(Scene_t* scene)
 {
     static bool checked_entities[MAX_COMP_POOL_SIZE] = {0};
 
-    LevelSceneData_t* data = (LevelSceneData_t*)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     TileGrid_t tilemap = data->tilemap;
 
 
@@ -634,7 +634,7 @@ void tile_collision_system(Scene_t* scene)
         //    Entity_t *p_other_ent = get_entity(&scene->ent_manager, other_ent_idx);
         //    if (!p_ent->m_alive || !p_other_ent->m_alive) continue;
         //}
-        sc_map_clear_32(&data->collision_events);
+        //sc_map_clear_32(&data->collision_events);
 
         // Level boundary collision
         unsigned int level_width = tilemap.width * TILE_SIZE;
@@ -728,7 +728,7 @@ void friction_coefficient_update_system(Scene_t* scene)
 
 void global_external_forces_system(Scene_t* scene)
 {
-    LevelSceneData_t* data = (LevelSceneData_t*)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     CMovementState_t* p_mstate;
     unsigned long ent_idx;
     sc_map_foreach(&scene->ent_manager.component_map[CMOVEMENTSTATE_T], ent_idx, p_mstate)
@@ -867,7 +867,7 @@ void player_ground_air_transition_system(Scene_t* scene)
 
 void state_transition_update_system(Scene_t* scene)
 {
-    LevelSceneData_t* data = (LevelSceneData_t*)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     //Entity_t* p_ent;
 
     CMovementState_t* p_mstate;
@@ -920,7 +920,7 @@ void state_transition_update_system(Scene_t* scene)
 
 void update_tilemap_system(Scene_t* scene)
 {
-    LevelSceneData_t* data = (LevelSceneData_t*)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     TileGrid_t tilemap = data->tilemap;
 
     CTileCoord_t* p_tilecoord;
@@ -966,7 +966,7 @@ void hitbox_update_system(Scene_t* scene)
 {
     static bool checked_entities[MAX_COMP_POOL_SIZE] = {0};
 
-    LevelSceneData_t* data = (LevelSceneData_t*)scene->scene_data;
+    LevelSceneData_t* data = &(CONTAINER_OF(scene, LevelScene_t, scene)->data);
     TileGrid_t tilemap = data->tilemap;
 
     unsigned int ent_idx;
@@ -1092,14 +1092,47 @@ void sprite_animation_system(Scene_t* scene)
     }
 }
 
+void camera_update_system(Scene_t* scene)
+{
+    LevelScene_t* lvl_scene = CONTAINER_OF(scene, LevelScene_t, scene);
+    Entity_t* p_player;
+    const int width = lvl_scene->data.game_rec.width;
+    const int height = lvl_scene->data.game_rec.height;
+    sc_map_foreach_value(&scene->ent_manager.entities_map[PLAYER_ENT_TAG], p_player)
+    {
+        CTransform_t* p_ctransform = get_component(&scene->ent_manager, p_player, CTRANSFORM_COMP_T);
+        lvl_scene->data.cam.offset = (Vector2){ width/2.0f, height/2.0f };
+        lvl_scene->data.cam.target = p_ctransform->position;
+    }
+    Vector2 max = GetWorldToScreen2D(
+        (Vector2){
+            lvl_scene->data.tilemap.width * TILE_SIZE,
+            lvl_scene->data.tilemap.height * TILE_SIZE
+        },
+        lvl_scene->data.cam
+    );
+    Vector2 min = GetWorldToScreen2D((Vector2){0, 0}, lvl_scene->data.cam);
+
+    if (max.x < width) lvl_scene->data.cam.offset.x = width - (max.x - width/2.0f);
+    if (max.y < height) lvl_scene->data.cam.offset.y = height - (max.y - height/2.0f);
+    if (min.x > 0) lvl_scene->data.cam.offset.x = width/2.0f - min.x;
+    if (min.y > 0) lvl_scene->data.cam.offset.y = height/2.0f - min.y;
+}
+
 void init_level_scene_data(LevelSceneData_t* data)
 {
-    sc_map_init_32(&data->collision_events, 128, 0);
+    //sc_map_init_32(&data->collision_events, 128, 0);
+    data->game_viewport = LoadRenderTexture(VIEWABLE_MAP_WIDTH*TILE_SIZE, VIEWABLE_MAP_HEIGHT*TILE_SIZE);
+    data->game_rec = (Rectangle){25, 25, VIEWABLE_MAP_WIDTH*TILE_SIZE, VIEWABLE_MAP_HEIGHT*TILE_SIZE};
+    data->cam = (Camera2D){0};
+    data->cam.rotation = 0.0f;
+    data->cam.zoom = 1.0f;
 }
 
 void term_level_scene_data(LevelSceneData_t* data)
 {
-    sc_map_term_32(&data->collision_events);
+    //sc_map_term_32(&data->collision_events);
+    UnloadRenderTexture(data->game_viewport); // Unload render texture
 }
 
 unsigned int player_sprite_transition_func(Entity_t* ent)

engine/game_systems.h

@@ -15,6 +15,7 @@ void state_transition_update_system(Scene_t* scene);
 void update_tilemap_system(Scene_t* scene);
 void hitbox_update_system(Scene_t* scene);
 void sprite_animation_system(Scene_t* scene);
+void camera_update_system(Scene_t* scene);
 
 unsigned int player_sprite_transition_func(Entity_t* ent);
 #endif // __GAME_SYSTEMS_H

engine/menu_scene.c

@@ -5,16 +5,19 @@
 
 static void menu_scene_render_func(Scene_t* scene)
 {
-    MenuSceneData_t* data = (MenuSceneData_t*)scene->scene_data;
-    DrawText("This is a game", 25, 220, 12, BLACK);
-    UI_button(data->buttons, "Start");
-    UI_button(data->buttons + 1, "Continue");
-    UI_button(data->buttons + 2, "Exit");
+    MenuSceneData_t* data = &(CONTAINER_OF(scene, MenuScene_t, scene)->data);
+    BeginDrawing();
+        ClearBackground(RAYWHITE);
+        DrawText("This is a game", 25, 220, 12, BLACK);
+        UI_button(data->buttons, "Start");
+        UI_button(data->buttons + 1, "Continue");
+        UI_button(data->buttons + 2, "Exit");
+    EndDrawing();
 }
 
 static void menu_do_action(Scene_t* scene, ActionType_t action, bool pressed)
 {
-    MenuSceneData_t* data = (MenuSceneData_t*)scene->scene_data;
+    MenuSceneData_t* data = &(CONTAINER_OF(scene, MenuScene_t, scene)->data);
     int new_selection = data->selected_comp;
     if (!pressed)
     {
@@ -63,7 +66,7 @@ static void menu_do_action(Scene_t* scene, ActionType_t action, bool pressed)
 
 static void gui_loop(Scene_t* scene)
 {
-    MenuSceneData_t* data = (MenuSceneData_t*)scene->scene_data;
+    MenuSceneData_t* data = &(CONTAINER_OF(scene, MenuScene_t, scene)->data);
     if (Vector2LengthSqr(GetMouseDelta()) > 1)
     {
         data->mode = MOUSE_MODE;
@@ -116,7 +119,6 @@ static void gui_loop(Scene_t* scene)
 void init_menu_scene(MenuScene_t* scene)
 {
     init_scene(&scene->scene, MENU_SCENE, &menu_scene_render_func, &menu_do_action);
-    scene->scene.scene_data = &scene->data;
 
     sc_array_add(&scene->scene.systems, &gui_loop);
     

engine/scene_impl.h

@@ -7,6 +7,10 @@
 #include "engine.h"
 #include "gui.h"
 
+#define CONTAINER_OF(ptr, type, member) ({         \
+    const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+    (type *)( (char *)__mptr - offsetof(type,member) );})
+
 typedef enum TileType {
     EMPTY_TILE = 0,
     SOLID_TILE,
@@ -38,7 +42,9 @@ typedef struct TileGrid {
 
 typedef struct LevelSceneData {
     TileGrid_t tilemap;
-    struct sc_map_32 collision_events;
+    RenderTexture2D game_viewport;
+    Rectangle game_rec;
+    Camera2D cam;
 }LevelSceneData_t;
 
 typedef struct LevelScene {

main.c

@@ -7,7 +7,8 @@ Scene_t *scenes[N_SCENES];
 static GameEngine_t engine = {
     .scenes = scenes,
     .max_scenes = 2,
-    .curr_scene = 0
+    .curr_scene = 0,
+    .assets = {0}
 };
 
 const int screenWidth = 1280;
@@ -15,6 +16,16 @@ const int screenHeight = 640;
 
 static void load_assets(void)
 {
+    Texture2D* tex = add_texture(&engine.assets, "plr_tex", "res/test_tex.png");
+    Sprite_t* spr = add_sprite(&engine.assets, "plr_stand", tex);
+    spr->origin = (Vector2){0, 0};
+    spr->frame_size = (Vector2){32, 32};
+
+    spr = add_sprite(&engine.assets, "plr_run", tex);
+    spr->frame_count = 4;
+    spr->origin = (Vector2){0, 0};
+    spr->frame_size = (Vector2){32, 32};
+    spr->speed = 15;
 }
 
 // Maintain own queue to handle key presses
@@ -28,16 +39,20 @@ int main(void)
     InitWindow(screenWidth, screenHeight, "raylib");
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     init_memory_pools();
+
+    init_assets(&engine.assets);
+    load_assets();
+
     LevelScene_t level_scene;
-    init_level_scene(&level_scene);
     level_scene.scene.engine = &engine;
+    init_level_scene(&level_scene);
     MenuScene_t menu_scene;
-    init_menu_scene(&menu_scene);
     menu_scene.scene.engine = &engine;
+    init_menu_scene(&menu_scene);
     scenes[0] = &menu_scene.scene;
     scenes[1] = &level_scene.scene;
-    load_assets();
     change_scene(&engine, 0);
+
     //Camera2D camera = { 0 };
     //camera.offset = (Vector2){0,0};
     //camera.rotation = 0.0f;
@@ -79,18 +94,16 @@ int main(void)
         update_scene(curr_scene);
         update_entity_manager(&curr_scene->ent_manager);
         // This is needed to advance time delta
-        BeginDrawing();
-            render_scene(curr_scene);
-            ClearBackground(RAYWHITE);
-        EndDrawing();
+        render_scene(curr_scene);
 
         if (curr_scene->state != SCENE_PLAYING)
         {
             sc_queue_clear(&key_buffer);
         }
     }
-    CloseWindow(); 
     free_level_scene(&level_scene);
     free_menu_scene(&menu_scene);
     sc_queue_term(&key_buffer);
+    term_assets(&engine.assets);
+    CloseWindow(); 
 }

menu_test.c

@@ -57,7 +57,7 @@ int main(void)
         EndDrawing();
         if (WindowShouldClose()) break;
     } 
-    CloseWindow();
     free_menu_scene(&scene);
     sc_queue_term(&key_buffer);
+    CloseWindow();
 }

scene_test.c

@@ -77,13 +77,11 @@ int main(void)
         update_scene(&scene.scene);
         update_entity_manager(&scene.scene.ent_manager);
         // This is needed to advance time delta
-        BeginDrawing();
-            render_scene(&scene.scene);
-            ClearBackground(RAYWHITE);
-        EndDrawing();
+        render_scene(&scene.scene);
         if (WindowShouldClose()) break;
     } 
-    CloseWindow();
     free_level_scene(&scene);
     sc_queue_term(&key_buffer);
+    term_assets(&engine.assets);
+    CloseWindow();
 }