Rework Entity Sprite Component & Add Tile Sprite

Changelog:
- Add tile sprites as part of Level Data
- Render tile sprite if loaded in
- CSprite now stores array of sprite rendering info
    - use current idx to keep track

scene_test.c

@@ -1,5 +1,6 @@
 #include "mempool.h"
 #include "scene_impl.h"
+#include "assets_loader.h"
 #include <stdio.h>
 #include <unistd.h>
 
@@ -23,20 +24,13 @@ int main(void)
     init_memory_pools();
 
     init_assets(&engine.assets);
-    Texture2D* tex = add_texture(&engine.assets, "plr_tex", "res/bunny_stand.png");
-    Sprite_t* spr = add_sprite(&engine.assets, "plr_stand", tex);
-    spr->origin = (Vector2){0, 0};
-    spr->frame_size = (Vector2){32, 64};
-
-    spr = add_sprite(&engine.assets, "plr_run", tex);
-    spr->frame_count = 1;
-    spr->origin = (Vector2){0, 0};
-    spr->frame_size = (Vector2){32, 64};
-    spr->speed = 30;
+    load_from_infofile("res/assets.info", &engine.assets);
 
     LevelScene_t scene;
     scene.scene.engine = &engine;
     init_level_scene(&scene);
+    scene.data.tile_sprites[ONEWAY_TILE] = get_sprite(&engine.assets, "tl_owp");
+    scene.data.tile_sprites[LADDER] = get_sprite(&engine.assets, "tl_ldr");
     scenes[0] = &scene.scene;
     change_scene(&engine, 0);
 

scenes/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_subdirectory(engine)
 add_library(lib_scenes STATIC
+    assets_loader.c
     player_ent.c
     items_ent.c
     editor_scene.c

scenes/assets_loader.c

@@ -0,0 +1,125 @@
+#include "assets_loader.h"
+#include <stdio.h>
+#include <string.h>
+
+typedef enum AssetInfoType
+{
+    TEXTURE_INFO,
+    SPRITE_INFO,
+    INVALID_INFO
+}AssetInfoType_t;
+
+typedef struct SpriteInfo
+{
+    char* tex;
+    Vector2 origin;
+    Vector2 frame_size;
+    int speed;
+    int frame_count;
+}SpriteInfo_t;
+
+static bool parse_sprite_info(char* sprite_info_str, SpriteInfo_t* spr_info)
+{
+    char* tex_name = strtok(sprite_info_str, ",");
+    if (tex_name == NULL) return false;
+    spr_info->tex = tex_name;
+    char* spr_data = tex_name + strlen(tex_name) + 1;
+    int data_count = sscanf(
+        spr_data, "%f,%f,%f,%f,%d,%d",
+        &spr_info->origin.x, &spr_info->origin.y,
+        &spr_info->frame_size.x, &spr_info->frame_size.y,
+        &spr_info->frame_count, &spr_info->speed
+    );
+    return data_count == 6;
+}
+
+bool load_from_infofile(const char* file, Assets_t* assets)
+{
+    FILE* in_file = fopen(file, "r");
+    if (in_file == NULL)
+    {
+        printf("Unable to open file %s\n", file);
+        return false;
+    }
+    
+    static char buffer[256];
+    char* tmp;
+    char tmp2[32];
+    size_t line_num = 0;
+    AssetInfoType_t info_type = INVALID_INFO;
+
+    while (true)
+    {
+        tmp = fgets(buffer, 256, in_file);
+        if (tmp == NULL) break;
+        tmp[strcspn(tmp, "\r\n")] = '\0';
+
+        if (tmp[0] == '-')
+        {
+            tmp++;
+            if (strcmp(tmp, "Texture") == 0)
+            {
+                info_type = TEXTURE_INFO;
+            }
+            else if (strcmp(tmp, "Sprite") == 0)
+            {
+                info_type = SPRITE_INFO;
+            }
+            else
+            {
+                info_type = INVALID_INFO;
+            }
+        }
+        else
+        {
+            char* name = strtok(buffer, ":");
+            char* info_str = strtok(NULL, ":");
+            if (name == NULL || info_str == NULL) continue;
+
+            while(*name == ' ' || *name == '\t') name++;
+            while(*info_str == ' ' || *info_str == '\t') info_str++;
+            switch(info_type)
+            {
+                case TEXTURE_INFO:
+                {
+                    if (add_texture(assets, name, info_str) == NULL)
+                    {
+                        printf("Unable to add texture at line %lu\n", line_num);
+                        break;
+                    }
+                    printf("Added texture %s as %s\n", info_str, name);
+                    //strcpy(tmp2, name);
+                }
+                break;
+                case SPRITE_INFO:
+                {
+                    SpriteInfo_t spr_info = {0};
+                    if (!parse_sprite_info(info_str, &spr_info))
+                    {
+                        printf("Unable to parse info for sprite at line %lu\n", line_num);
+                        break;
+                    }
+                    //printf("Compare %s,%s = %d\n", tmp2, spr_info.tex, strcmp(tmp2, spr_info.tex));
+                    Texture2D* tex = get_texture(assets, spr_info.tex);
+                    if (tex == NULL)
+                    {
+                        printf("Unable to get texture info %s for sprite %s\n", spr_info.tex, name);
+                        break;
+                    }
+                    printf("Added Sprite %s from texture %s\n", name, spr_info.tex);
+                    Sprite_t* spr = add_sprite(assets, name, tex);
+                    spr->origin = spr_info.origin;
+                    spr->frame_size = spr_info.frame_size;
+                    spr->frame_count = spr_info.frame_count;
+                    spr->speed = spr_info.speed;
+                }
+                break;
+                default:
+                break;
+            }
+        }
+        line_num++; 
+    }
+    fclose(in_file);
+    return true;
+}

scenes/assets_loader.h

@@ -0,0 +1,7 @@
+#ifndef __ASSETS_LOADER_H
+#define __ASSETS_LOADER_H
+#include "assets.h"
+
+bool load_from_infofile(const char* file, Assets_t* assets);
+
+#endif // __ASSETS_LOADER_H

scenes/editor_scene.c

@@ -16,6 +16,7 @@ enum EntitySpawnSelection {
     SPAWN_CRATE,
     SPAWN_METAL_CRATE,
 };
+
 #define MAX_SPAWN_TYPE 5
 static unsigned int current_spawn_selection = 0;
 
@@ -49,7 +50,11 @@ static void level_scene_render_func(Scene_t* scene)
             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)
+            if (data->tile_sprites[tilemap.tiles[i].tile_type] != NULL)
+            {
+                draw_sprite(data->tile_sprites[tilemap.tiles[i].tile_type], (Vector2){x,y});
+            }
+            else if (tilemap.tiles[i].tile_type == SOLID_TILE)
             {
                 DrawRectangle(x, y, TILE_SIZE, TILE_SIZE, BLACK);
             }
@@ -116,8 +121,12 @@ static void level_scene_render_func(Scene_t* scene)
             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);
+                const SpriteRenderInfo_t spr = p_cspr->sprites[p_cspr->current_idx];
+                if (spr.sprite != NULL)
+                {
+                    Vector2 pos = Vector2Add(p_ct->position, spr.offset);
+                    draw_sprite(spr.sprite, pos);
+                }
             }
         }
 
@@ -413,6 +422,7 @@ void init_level_scene(LevelScene_t* scene)
     scene->data.tilemap.n_tiles = scene->data.tilemap.width * scene->data.tilemap.height;
     assert(scene->data.tilemap.n_tiles <= MAX_N_TILES);
     scene->data.tilemap.tiles = all_tiles;
+    memset(scene->data.tile_sprites, 0, sizeof(scene->data.tile_sprites));
     for (size_t i = 0; i < MAX_N_TILES;i++)
     {
         all_tiles[i].solid = NOT_SOLID;

scenes/engine/EC/components.h

@@ -114,11 +114,17 @@ typedef struct Sprite {
 } Sprite_t;
 
 typedef unsigned int (*sprite_transition_func_t)(Entity_t *ent); // Transition requires knowledge of the entity
-typedef struct _CSprite_t {
-    const char * const *sprites_map; //Array of all sprite names associated
+typedef struct _SpriteRenderInfo
+{
     Sprite_t* sprite;
-    sprite_transition_func_t transition_func;
     Vector2 offset;
+    bool flip_x;
+    bool flip_y;
+} SpriteRenderInfo_t;
+
+typedef struct _CSprite_t {
+    SpriteRenderInfo_t* sprites;
+    sprite_transition_func_t transition_func;
     unsigned int current_idx;
 } CSprite_t;
 

scenes/engine/assets.c

@@ -5,23 +5,50 @@
 #define MAX_SPRITES 16
 #define MAX_SOUNDS 16
 #define MAX_FONTS 4
+#define MAX_NAME_LEN 32
 uint8_t free_idx[4] = {0};
 
 // Hard limit number of 
-static Texture2D textures[MAX_TEXTURES];
-static Font fonts[MAX_FONTS];
-static Sound sfx[MAX_SOUNDS];
-static Sprite_t sprites[MAX_SPRITES];
+typedef struct TextureData
+{
+    Texture2D texture;
+    char name[MAX_NAME_LEN];
+}TextureData_t;
+typedef struct SpriteData
+{
+    Sprite_t sprite;
+    char name[MAX_NAME_LEN];
+}SpriteData_t;
+typedef struct FontData
+{
+    Font font;
+    char name[MAX_NAME_LEN];
+}FontData_t;
+typedef struct SoundData
+{
+    Sound sound;
+    char name[MAX_NAME_LEN];
+}SoundData_t;
+
+
+static TextureData_t textures[MAX_TEXTURES];
+static FontData_t fonts[MAX_FONTS];
+static SoundData_t sfx[MAX_SOUNDS];
+static SpriteData_t sprites[MAX_SPRITES];
 
 // Maybe need a circular buffer??
 Texture2D* add_texture(Assets_t* assets, const char* name, const char* path)
 {
     uint8_t tex_idx = free_idx[0];
     assert(tex_idx < MAX_TEXTURES);
-    textures[tex_idx] = LoadTexture(path);
-    sc_map_put_s64(&assets->m_textures, name, tex_idx);
+    Texture2D tex = LoadTexture(path);
+    if (tex.width == 0 || tex.height == 0) return NULL;
+
+    textures[tex_idx].texture = tex;
+    strncpy(textures[tex_idx].name, name, MAX_NAME_LEN);
+    sc_map_put_s64(&assets->m_textures, textures[tex_idx].name, tex_idx);
     free_idx[0]++;
-    return textures + tex_idx;
+    return &textures[tex_idx].texture;
 }
 
 Sprite_t* add_sprite(Assets_t* assets, const char* name, Texture2D* texture)
@@ -29,30 +56,33 @@ Sprite_t* add_sprite(Assets_t* assets, const char* name, Texture2D* texture)
     uint8_t spr_idx = free_idx[1];
     assert(spr_idx < MAX_SPRITES);
     memset(sprites + spr_idx, 0, sizeof(Sprite_t));
-    sprites[spr_idx].texture = texture;
-    sc_map_put_s64(&assets->m_sprites, name, spr_idx);
+    sprites[spr_idx].sprite.texture = texture;
+    strncpy(sprites[spr_idx].name, name, MAX_NAME_LEN);
+    sc_map_put_s64(&assets->m_sprites, sprites[spr_idx].name, spr_idx);
     free_idx[1]++;
-    return sprites + spr_idx;
+    return &sprites[spr_idx].sprite;
 }
 
 Sound* add_sound(Assets_t* assets, const char* name, const char* path)
 {
     uint8_t snd_idx = free_idx[2];
     assert(snd_idx < MAX_SOUNDS);
-    sfx[snd_idx] = LoadSound(path);
-    sc_map_put_s64(&assets->m_sounds, name, snd_idx);
+    sfx[snd_idx].sound = LoadSound(path);
+    strncpy(sfx[snd_idx].name, name, MAX_NAME_LEN);
+    sc_map_put_s64(&assets->m_sounds, sfx[snd_idx].name, snd_idx);
     free_idx[2]++;
-    return sfx + snd_idx;
+    return &sfx[snd_idx].sound;
 }
 
 Font* add_font(Assets_t* assets, const char* name, const char* path)
 {
     uint8_t fnt_idx = free_idx[3];
     assert(fnt_idx < MAX_FONTS);
-    fonts[fnt_idx] = LoadFont(path);
-    sc_map_put_s64(&assets->m_fonts, name, fnt_idx);
+    fonts[fnt_idx].font = LoadFont(path);
+    strncpy(fonts[fnt_idx].name, name, MAX_NAME_LEN);
+    sc_map_put_s64(&assets->m_fonts, fonts[fnt_idx].name, fnt_idx);
     free_idx[3]++;
-    return fonts + fnt_idx;
+    return &fonts[fnt_idx].font;
 }
 
 void init_assets(Assets_t* assets)
@@ -86,7 +116,7 @@ Texture2D* get_texture(Assets_t* assets, const char* name)
     uint8_t tex_idx = sc_map_get_s64(&assets->m_textures, name);
     if (sc_map_found(&assets->m_textures))
     {
-        return textures + tex_idx;
+        return &textures[tex_idx].texture;
     }
     return NULL;
 }
@@ -96,7 +126,7 @@ Sprite_t* get_sprite(Assets_t* assets, const char* name)
     uint8_t spr_idx = sc_map_get_s64(&assets->m_sprites, name);
     if (sc_map_found(&assets->m_sprites))
     {
-        return sprites + spr_idx;
+        return &sprites[spr_idx].sprite;
     }
     return NULL;
 }
@@ -106,7 +136,7 @@ Sound* get_sound(Assets_t* assets, const char* name)
     uint8_t snd_idx = sc_map_get_s64(&assets->m_sounds, name);
     if (sc_map_found(&assets->m_sounds))
     {
-        return sfx + snd_idx;
+        return &sfx[snd_idx].sound;
     }
     return NULL;
 }
@@ -116,7 +146,7 @@ Font* get_font(Assets_t* assets, const char* name)
     uint8_t fnt_idx = sc_map_get_s64(&assets->m_fonts, name);
     if (sc_map_found(&assets->m_fonts))
     {
-        return fonts + fnt_idx;
+        return &fonts[fnt_idx].font;
     }
     return NULL;
 }

scenes/game_systems.c

@@ -1071,22 +1071,18 @@ void sprite_animation_system(Scene_t* scene)
             unsigned int spr_idx = p_cspr->transition_func(p_ent);
             if (p_cspr->current_idx != spr_idx)
             {
-                Sprite_t* new_spr = get_sprite(&scene->engine->assets, p_cspr->sprites_map[spr_idx]);
-                if (new_spr != NULL)
-                {
-                    p_cspr->sprite = new_spr;
-                    p_cspr->current_idx = spr_idx;
-                    p_cspr->sprite->current_frame = 0;
-                }
+                p_cspr->current_idx = spr_idx;
+                p_cspr->sprites[spr_idx].sprite->current_frame = 0;
             }
         }
+        SpriteRenderInfo_t spr = p_cspr->sprites[p_cspr->current_idx];
         // Animate it (handle frame count)
-        p_cspr->sprite->elapsed++;
-        if (p_cspr->sprite->elapsed == p_cspr->sprite->speed)
+        spr.sprite->elapsed++;
+        if (spr.sprite->elapsed == spr.sprite->speed)
         {
-            p_cspr->sprite->current_frame++;
-            p_cspr->sprite->current_frame %= p_cspr->sprite->frame_count;
-            p_cspr->sprite->elapsed = 0;
+            spr.sprite->current_frame++;
+            spr.sprite->current_frame %= spr.sprite->frame_count;
+            spr.sprite->elapsed = 0;
         }
     }
 }

scenes/player_ent.c

@@ -8,10 +8,7 @@ enum PlayerSpriteEnum
     SPR_PLAYER_RUN
 };
 
-static const char* const player_sprite_map[N_PLAYER_SPRITES] = {
-    "plr_stand",
-    "plr_run",
-};
+static SpriteRenderInfo_t player_sprite_map[N_PLAYER_SPRITES] = {0};
 
 static unsigned int player_sprite_transition_func(Entity_t* ent)
 {
@@ -49,9 +46,11 @@ Entity_t* create_player(EntityManager_t* ent_manager, Assets_t* assets)
         .height = p_bbox->size.y - 1,
     };
     CSprite_t* p_cspr = add_component(ent_manager, p_ent, CSPRITE_T);
-    p_cspr->sprite = get_sprite(assets, "plr_stand");
-    p_cspr->offset = (Vector2){0, -20};
-    p_cspr->sprites_map = player_sprite_map;
+    p_cspr->sprites = player_sprite_map;
+    p_cspr->sprites[0].sprite = get_sprite(assets, "plr_stand");
+    p_cspr->sprites[0].offset = (Vector2){0, -20};
+    p_cspr->sprites[1].sprite = get_sprite(assets, "plr_stand");
+    p_cspr->sprites[1].offset = (Vector2){0, -20};
     p_cspr->transition_func = &player_sprite_transition_func;
 
     return p_ent;

scenes/scene_impl.h

@@ -17,7 +17,7 @@ typedef enum TileType {
     ONEWAY_TILE,
     LADDER
 } TileType_t;
-
+#define MAX_TILE_TYPES 4
 typedef enum SolidType
 {
     NOT_SOLID = 0,
@@ -45,6 +45,7 @@ typedef struct LevelSceneData {
     RenderTexture2D game_viewport;
     Rectangle game_rec;
     Camera2D cam;
+    Sprite_t* tile_sprites[MAX_TILE_TYPES];
 }LevelSceneData_t;
 
 typedef struct LevelScene {