About to implement load strategy

src/asset/asset.c

@@ -62,9 +62,10 @@ errorret_t assetLoad(const char_t *filename, void *output) {
   // Find the asset type based on the header
   const assettypedef_t *def = NULL;
   for(uint_fast8_t i = 0; i < ASSET_TYPE_COUNT; i++) {
-    if(ASSET_TYPE_DEFINITIONS[i].header == NULL) continue;
-    if(strcmp(header.header, ASSET_TYPE_DEFINITIONS[i].header) != 0) continue;
-    def = &ASSET_TYPE_DEFINITIONS[i];
+    const assettypedef_t *cmp = &ASSET_TYPE_DEFINITIONS[i];
+    if(cmp->header == NULL) continue;
+    if(strcmp(header.header, cmp->header) != 0) continue;
+    def = cmp;
     break;
   }
   if(def == NULL) {
@@ -73,22 +74,33 @@ errorret_t assetLoad(const char_t *filename, void *output) {
   }
 
   // We found the asset type, now load the asset data
-  assertNotNull(def->load, "Asset load function cannot be NULL.");
-  void *data = memoryAllocate(def->dataSize);
-  bytesRead = zip_fread(file, data, def->dataSize);
-  if(bytesRead == 0 || bytesRead > def->dataSize) {
-    memoryFree(data);
-    zip_fclose(file);
-    errorThrow("Failed to read asset data for file: %s", filename);
+  switch(def->loadStrategy) {
+    case ASSET_LOAD_STRAT_ENTIRE:
+      assertNotNull(def->entire, "Asset load function cannot be NULL.");
+      void *data = memoryAllocate(def->dataSize);
+      bytesRead = zip_fread(file, data, def->dataSize);
+      if(bytesRead == 0 || bytesRead > def->dataSize) {
+        memoryFree(data);
+        zip_fclose(file);
+        errorThrow("Failed to read asset data for file: %s", filename);
+      }
+
+      // Close the file now we have the data
+      zip_fclose(file);
+
+      // Pass to the asset type loader
+      errorret_t ret = def->entire(data, output);
+      memoryFree(data);
+      errorChain(ret);
+      break;
+
+    case ASSET_LOAD_STRAT_TEST:
+      assertUnreachable("Asset load strategy not implemented yet.");
+
+    default:
+      assertUnreachable("Unknown asset load strategy.");
   }
 
-  // Close the file now we have the data
-  zip_fclose(file);
-
-  // Pass to the asset type loader
-  errorret_t ret = def->load(data, output);
-  memoryFree(data);
-  errorChain(ret);
   errorOk();
 }
 

src/asset/assettype.h

@@ -13,18 +13,25 @@ typedef enum {
   ASSET_TYPE_NULL,
   ASSET_TYPE_PALETTE_IMAGE,
   ASSET_TYPE_ALPHA_IMAGE,
+  ASSET_TYPE_LANGUAGE,
   ASSET_TYPE_COUNT,
 } assettype_t;
 
 typedef enum {
   ASSET_LOAD_STRAT_ENTIRE,
+  ASSET_LOAD_STRAT_TEST
 } assetloadstrat_t;
 
 typedef struct {
   const char_t *header;
   const size_t dataSize;
   const assetloadstrat_t loadStrategy;
-  errorret_t (*load)(void *data, void *output);
+  union {
+    errorret_t (*entire)(void *data, void *output);
+    struct {
+      void *test;
+    } test;
+  };
 } assettypedef_t;
 
 static const assettypedef_t ASSET_TYPE_DEFINITIONS[ASSET_TYPE_COUNT] = {
@@ -36,13 +43,22 @@ static const assettypedef_t ASSET_TYPE_DEFINITIONS[ASSET_TYPE_COUNT] = {
     .header = "DPI",
     .loadStrategy = ASSET_LOAD_STRAT_ENTIRE,
     .dataSize = sizeof(assetpaletteimage_t),
-    .load = assetPaletteImageLoad
+    .entire = assetPaletteImageLoad
   },
 
   [ASSET_TYPE_ALPHA_IMAGE] = {
     .header = "DAI",
     .loadStrategy = ASSET_LOAD_STRAT_ENTIRE,
     .dataSize = sizeof(assetalphaimage_t),
-    .load = assetAlphaImageLoad
+    .entire = assetAlphaImageLoad
   },
+
+  [ASSET_TYPE_LANGUAGE] = {
+    .header = "DLF",
+    .loadStrategy = ASSET_LOAD_STRAT_TEST,
+    .dataSize = 0, // Variable size
+    .test = {
+      .test = NULL
+    }
+  }
 };

src/asset/type/assetlanguage.c

@@ -0,0 +1,8 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetlanguage.h"

src/asset/type/assetlanguage.h

@@ -8,6 +8,12 @@
 #pragma once
 #include "locale/language/keys.h"
 
+#define ASSET_LANG_CHUNK_CHAR_COUNT 6 * 1024 // 6 KB per chunk
+
+#pragma pack(push, 1)
+typedef char assetlanguagechunk_t[ASSET_LANG_CHUNK_CHAR_COUNT];
+#pragma pack(pop)
+
 #pragma pack(push, 1)
 typedef struct {
   uint32_t chunk;