1 files changed, 183 insertions, 0 deletions

diff --git a/gfx/src/asset/asset_cache.c b/gfx/src/asset/asset_cache.c
new file mode 100644
index 0000000..0c6a8dc
--- /dev/null
+++ b/gfx/src/asset/asset_cache.c
@@ -0,0 +1,183 @@
+#include "asset_cache.h"
+
+#include <gfx/asset.h>
+#include <gfx/gfx.h>
+#include <gfx/util/scene.h>
+#include <gfx/util/texture.h>
+
+#include <cstring.h>
+#include <log/log.h>
+
+#include <assert.h>
+#include <stddef.h>
+
+static Hash calc_scene_hash(const LoadSceneCmd* cmd) {
+  assert(cmd);
+  switch (cmd->origin) {
+  case AssetFromFile:
+    return cstring_hash(mstring_cstr(&cmd->filepath));
+  case AssetFromMemory:
+    return (Hash)cmd->data;
+  }
+  assert(false);
+  return 0;
+}
+
+static Hash calc_texture_hash(const LoadTextureCmd* cmd) {
+  assert(cmd);
+  switch (cmd->origin) {
+  case AssetFromFile:
+    switch (cmd->type) {
+    case LoadTexture:
+      return cstring_hash(mstring_cstr(&cmd->data.texture.filepath));
+    case LoadCubemap:
+      return cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_pos_x)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_neg_x)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_pos_y)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_neg_y)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_pos_z)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_neg_z));
+    }
+    break;
+  case AssetFromMemory:
+    switch (cmd->type) {
+    case LoadTexture:
+      return (Hash)cmd->data.texture.data;
+    case LoadCubemap:
+      return (Hash)cmd->data.cubemap.buffers.data_pos_x ^
+             (Hash)cmd->data.cubemap.buffers.data_neg_x ^
+             (Hash)cmd->data.cubemap.buffers.data_pos_y ^
+             (Hash)cmd->data.cubemap.buffers.data_neg_y ^
+             (Hash)cmd->data.cubemap.buffers.data_pos_z ^
+             (Hash)cmd->data.cubemap.buffers.data_neg_z;
+    }
+    break;
+  }
+  assert(false);
+  return 0;
+}
+
+static Asset* lookup_cache(AssetCache* cache, Hash hash) {
+  assert(cache);
+  mempool_foreach(&cache->assets, asset, {
+    if (asset->hash == hash) {
+      return asset;
+    }
+  });
+  return 0;
+}
+
+// TODO: questionable function. Make mempool_alloc() fail when out of memory.
+static void insert_into_cache(AssetCache* cache, const Asset* asset) {
+  assert(cache);
+  assert(asset);
+  Asset* poolAsset = mempool_alloc(&cache->assets);
+  assert(asset);
+  *poolAsset = *asset;
+}
+
+static void log_scene_cache_hit(const LoadSceneCmd* cmd, Hash hash) {
+  assert(cmd);
+  switch (cmd->origin) {
+  case AssetFromFile:
+    LOGI(
+        "Found asset [%s] in cache with hash [%lu]",
+        mstring_cstr(&cmd->filepath), hash);
+    break;
+  case AssetFromMemory:
+    LOGI("Found asset [%p] in cache with hash [%lu]", cmd->data, hash);
+    break;
+  }
+}
+
+static void log_scene_loaded(const LoadSceneCmd* cmd) {
+  assert(cmd);
+  switch (cmd->origin) {
+  case AssetFromFile:
+    LOGI("Loaded asset from file: [%s]", mstring_cstr(&cmd->filepath));
+    break;
+  case AssetFromMemory:
+    LOGI("Loaded asset from memory: [%p]", cmd->data);
+    break;
+  }
+}
+
+void gfx_init_asset_cache(AssetCache* cache) {
+  assert(cache);
+  mempool_make(&cache->assets);
+
+  // Allocate a dummy asset at index 0 to guarantee that no assets allocated by
+  // the caller map to index 0.
+  const Asset* dummy = mempool_alloc(&cache->assets);
+  assert(mempool_get_block_index(&cache->assets, dummy) == 0);
+}
+
+void gfx_destroy_asset_cache(AssetCache* cache) {
+  assert(cache);
+  mempool_del(&cache->assets);
+}
+
+SceneNode* gfx_load_scene(
+    Gfx* gfx, SceneNode* root_node, const LoadSceneCmd* cmd) {
+  assert(gfx);
+
+  AssetCache* cache = gfx_get_asset_cache(gfx);
+
+  // First search for the asset in the cache.
+  // TODO: Animated models are currently mutated in place, so sharing them is
+  //  not really valid.
+  const uint64_t hash  = calc_scene_hash(cmd);
+  Asset*         asset = lookup_cache(cache, hash);
+  if (asset) {
+    log_scene_cache_hit(cmd, hash);
+    return (SceneNode*)asset;
+  }
+
+  // Asset not found in the cache.
+  // Load it, insert it into the cache, and return it.
+  SceneNode* node = gfx_scene_load(gfx, root_node, cmd);
+  if (node) {
+    insert_into_cache(
+        cache, &(Asset){
+                   .type = SceneAsset,
+                   .hash = hash,
+                   .data = node,
+               });
+    log_scene_loaded(cmd);
+  }
+  return node;
+}
+
+Texture* gfx_load_texture(Gfx* gfx, const LoadTextureCmd* cmd) {
+  assert(gfx);
+  assert(cmd);
+
+  AssetCache* cache = gfx_get_asset_cache(gfx);
+
+  // First search for the asset in the cache.
+  const uint64_t hash  = calc_texture_hash(cmd);
+  Asset*         asset = lookup_cache(cache, hash);
+  if (asset) {
+    return (Texture*)asset;
+  }
+
+  // Asset not found in the cache.
+  // Load it, insert it into the cache, and return it.
+  RenderBackend* render_backend = gfx_get_render_backend(gfx);
+  Texture*       texture        = gfx_texture_load(render_backend, cmd);
+  if (texture) {
+    insert_into_cache(
+        cache, &(Asset){
+                   .type = TextureAsset,
+                   .hash = hash,
+                   .data = texture,
+               });
+  }
+  return texture;
+}