Asset query api

apps/game/src/app.c

@@ -211,7 +211,7 @@ static void app_action_restart_draw(UiCanvasComp* canvas, const AppActionContext
     app_action_notify(ctx, string_lit("Restart"));
     log_i("Restart");
 
-    scene_level_load(ctx->world, g_appLevel);
+    scene_level_reload(ctx->world);
   }
 }
 
@@ -610,7 +610,7 @@ void app_ecs_init(EcsWorld* world, const CliInvocation* invoc) {
   input_resource_load_map(inputResource, string_lit("global/game-input.imp"));
   input_resource_load_map(inputResource, string_lit("global/debug-input.imp"));
 
-  scene_level_load(world, g_appLevel);
+  scene_level_load(world, asset_lookup(world, assets, g_appLevel));
   scene_prefab_init(world, string_lit("global/game-prefabs.pfb"));
   scene_weapon_init(world, string_lit("global/game-weapons.wea"));
   scene_terrain_init(

assets/fonts/ui.ftx

@@ -19,7 +19,7 @@
     {
       "id": "fonts/materialicons_regular.ttf",
       "yOffset": -0.15,
-      "characters": "\uE9E4\uEF5B\uE3AE\uE1DB\uEA5F\uE069\uE338\uE4FC\uE80E\uE5CA\uE9BA\uE5D0\uE89E\uE312\uE5CD\uF016\uE412\uE25E\uE5CF\uE5CE\uE5D7\uE5D6\uE9FE\uE87B\uE71C\uE425\uF230\uEA4A\uEA3C\uE92B\uE162\uE145\uE518\uE8B8\uE322\uE429\uE8F4\uE80B\uE405\uE574\uE868\uE050\uE04F\uE3F4\uE034\uF053\uE7EF"
+      "characters": "\uE9E4\uEF5B\uE3AE\uE1DB\uEA5F\uE069\uE338\uE4FC\uE80E\uE5CA\uE9BA\uE5D0\uE89E\uE312\uE5CD\uF016\uE412\uE25E\uE5CF\uE5CE\uE5D7\uE5D6\uE9FE\uE87B\uE71C\uE425\uF230\uEA4A\uEA3C\uE92B\uE162\uE145\uE518\uE8B8\uE322\uE429\uE8F4\uE80B\uE405\uE574\uE868\uE050\uE04F\uE3F4\uE034\uF053\uE7EF\uE5D5\uE161"
     },
     {
       "id": "fonts/shapes.ttf",

assets/global/debug-input.imp

@@ -13,31 +13,31 @@
       "blockers": [ "TextInput" ],
       "bindings": [
         { "type": "Down", "key": "ArrowUp" },
-        { "type": "Down", "key": "W" }
+        { "type": "Down", "key": "W", "illegalModifiers": [ "Control" ] }
       ]
     },
     {
       "name": "CameraPanBackward",
       "blockers": [ "TextInput" ],
       "bindings": [
         { "type": "Down", "key": "ArrowDown" },
-        { "type": "Down", "key": "S" }
+        { "type": "Down", "key": "S", "illegalModifiers": [ "Control" ] }
       ]
     },
     {
       "name": "CameraPanRight",
       "blockers": [ "TextInput" ],
       "bindings": [
         { "type": "Down", "key": "ArrowRight" },
-        { "type": "Down", "key": "D" }
+        { "type": "Down", "key": "D", "illegalModifiers": [ "Control" ] }
       ]
     },
     {
       "name": "CameraPanLeft",
       "blockers": [ "TextInput" ],
       "bindings": [
         { "type": "Down", "key": "ArrowLeft" },
-        { "type": "Down", "key": "A" }
+        { "type": "Down", "key": "A", "illegalModifiers": [ "Control" ] }
       ]
     },
     {
@@ -48,6 +48,13 @@
         { "type": "Down", "key": "MouseExtra1" }
       ]
     },
+    {
+      "name": "SaveLevel",
+      "blockers": [ "TextInput" ],
+      "bindings": [
+        { "type": "Down", "key": "S", "requiredModifiers": [ "Control" ] }
+      ]
+    },
     {
       "name": "DebugTimePauseToggle",
       "blockers": [ "TextInput" ],

libs/asset/include/asset_manager.h

@@ -3,6 +3,8 @@
 #include "ecs_entity.h"
 #include "ecs_module.h"
 
+#define asset_query_max_results 512
+
 typedef struct {
   String id, data;
 } AssetMemRecord;
@@ -83,6 +85,21 @@ void asset_reload_request(EcsWorld*, EcsEntityId assetEntity);
  */
 bool asset_save(AssetManagerComp*, String id, String data);
 
+/**
+ * Query for assets that match the given id pattern.
+ *
+ * Supported pattern syntax:
+ * '?' matches any single character.
+ * '*' matches any number of any characters including none.
+ *
+ * NOTE: Returns the number of found assets.
+ */
+u32 asset_query(
+    EcsWorld*,
+    AssetManagerComp*,
+    String      pattern,
+    EcsEntityId out[PARAM_ARRAY_SIZE(asset_query_max_results)]);
+
 /**
  * Debug apis.
  */

libs/asset/src/manager.c

@@ -454,6 +454,30 @@ bool asset_save(AssetManagerComp* manager, const String id, const String data) {
   return asset_repo_save(manager->repo, id, data);
 }
 
+typedef struct {
+  EcsWorld*         world;
+  AssetManagerComp* manager;
+  u32               count;
+  EcsEntityId*      out;
+} AssetQueryContext;
+
+static void asset_query_output(void* ctxRaw, const String id) {
+  AssetQueryContext* ctx = ctxRaw;
+  if (LIKELY(ctx->count != asset_query_max_results)) {
+    ctx->out[ctx->count++] = asset_lookup(ctx->world, ctx->manager, id);
+  }
+}
+
+u32 asset_query(
+    EcsWorld*         world,
+    AssetManagerComp* manager,
+    const String      pattern,
+    EcsEntityId       out[PARAM_ARRAY_SIZE(asset_query_max_results)]) {
+  AssetQueryContext ctx = {.world = world, .manager = manager, .out = out};
+  asset_repo_query(manager->repo, pattern, &ctx, asset_query_output);
+  return ctx.count;
+}
+
 void asset_register_dep(EcsWorld* world, EcsEntityId asset, const EcsEntityId dependency) {
   diag_assert(asset);
   diag_assert(dependency);

libs/asset/src/repo.c

@@ -1,7 +1,25 @@
 #include "core_alloc.h"
+#include "core_array.h"
+#include "core_diag.h"
 
 #include "repo_internal.h"
 
+static const String g_assetRepoQueryResultStrs[] = {
+    string_static("RepoQuerySuccess"),
+    string_static("RepoQueryErrorNotSupported"),
+    string_static("RepoQueryErrorPatternNotSupported"),
+    string_static("RepoQueryErrorWhileQuerying"),
+};
+
+ASSERT(
+    array_elems(g_assetRepoQueryResultStrs) == AssetRepoQueryResult_Count,
+    "Incorrect number of AssetRepoQueryResult strings");
+
+String asset_repo_query_result_str(const AssetRepoQueryResult result) {
+  diag_assert(result < AssetRepoQueryResult_Count);
+  return g_assetRepoQueryResultStrs[result];
+}
+
 void asset_repo_destroy(AssetRepo* repo) { repo->destroy(repo); }
 
 AssetSource* asset_repo_source_open(AssetRepo* repo, String id) { return repo->open(repo, id); }
@@ -30,3 +48,14 @@ bool asset_repo_changes_poll(AssetRepo* repo, u64* outUserData) {
   }
   return false;
 }
+
+AssetRepoQueryResult asset_repo_query(
+    AssetRepo*                  repo,
+    const String                filterPattern,
+    void*                       context,
+    const AssetRepoQueryHandler handler) {
+  if (repo->query) {
+    return repo->query(repo, filterPattern, context, handler);
+  }
+  return AssetRepoQueryResult_ErrorNotSupported;
+}

libs/asset/src/repo_fs.c

@@ -1,5 +1,6 @@
 #include "core_alloc.h"
 #include "core_file.h"
+#include "core_file_iterator.h"
 #include "core_file_monitor.h"
 #include "core_path.h"
 #include "log_logger.h"
@@ -94,6 +95,104 @@ static bool asset_repo_fs_changes_poll(AssetRepo* repo, u64* outUserData) {
   return false;
 }
 
+typedef enum {
+  AssetRepoFsQuery_Recursive = 1 << 0,
+} AssetRepoFsQueryFlags;
+
+static AssetRepoQueryResult asset_repo_fs_query_iteration(
+    AssetRepoFs*                repoFs,
+    const String                directory,
+    const String                pattern,
+    const AssetRepoFsQueryFlags flags,
+    void*                       context,
+    const AssetRepoQueryHandler handler) {
+
+  if (UNLIKELY(directory.size) > 256) {
+    // Sanity check the maximum directory length (relative to the repo root-path).
+    log_w("AssetRepository: Directory path length exceeds maximum");
+    return AssetRepoQueryResult_ErrorWhileQuerying;
+  }
+
+  Allocator* alloc     = alloc_bump_create_stack(768);
+  DynString  dirBuffer = dynstring_create(alloc, 512);
+
+  // Open a file iterator for the absolute path starting from the repo root-path.
+  path_append(&dirBuffer, repoFs->rootPath);
+  path_append(&dirBuffer, directory);
+  FileIterator* itr = file_iterator_create(alloc, dynstring_view(&dirBuffer));
+
+  FileIteratorEntry  entry;
+  FileIteratorResult itrResult;
+  while ((itrResult = file_iterator_next(itr, &entry)) == FileIteratorResult_Found) {
+    // Construct a file path relative to the repo root-path.
+    dynstring_clear(&dirBuffer);
+    path_append(&dirBuffer, directory);
+    path_append(&dirBuffer, entry.name);
+    const String path = dynstring_view(&dirBuffer);
+
+    switch (entry.type) {
+    case FileType_Regular:
+      if (string_match_glob(path, pattern, StringMatchFlags_None)) {
+        handler(context, path);
+      }
+      break;
+    case FileType_Directory:
+      if (flags & AssetRepoFsQuery_Recursive) {
+        // TODO: Handle errors for sub-directory iteration failure.
+        asset_repo_fs_query_iteration(repoFs, path, pattern, flags, context, handler);
+      }
+      break;
+    case FileType_None:
+    case FileType_Unknown:
+      break;
+    }
+  }
+  file_iterator_destroy(itr);
+
+  if (UNLIKELY(itrResult != FileIteratorResult_End)) {
+    log_w(
+        "AssetRepository: Error while performing file query",
+        log_param("result", fmt_text(file_iterator_result_str(itrResult))));
+    return AssetRepoQueryResult_ErrorWhileQuerying;
+  }
+  return AssetRepoQueryResult_Success;
+}
+
+static AssetRepoQueryResult asset_repo_fs_query(
+    AssetRepo* repo, const String pattern, void* context, const AssetRepoQueryHandler handler) {
+  AssetRepoFs* repoFs = (AssetRepoFs*)repo;
+
+  // Find a root directory for the query.
+  const String directory = path_parent(pattern);
+
+  static const String g_globChars = string_static("*?");
+  if (UNLIKELY(!sentinel_check(string_find_first_any(directory, g_globChars)))) {
+    /**
+     * Filtering in the directory part part is not supported at the moment.
+     * Supporting this would require recursing from the first non-filtered directory.
+     */
+    log_w("AssetRepository: Unsupported file query pattern");
+    return AssetRepoQueryResult_ErrorPatternNotSupported;
+  }
+
+  AssetRepoFsQueryFlags flags = 0;
+
+  /**
+   * Recursive queries are defined by a file-name starting with a wildcard.
+   *
+   * For example a query of `dir/ *.txt` will match both 'dir/hello.txt' and 'dir/sub/hello.txt',
+   * '*.txt' will match any 'txt' files regardless how deeply its nested. This means there's no
+   * way to search for direct children starting with a wildcard at the moment, in the future we
+   * can consider supporting more exotic syntax like 'dir/ ** / *.txt' for recursive queries.
+   */
+  const String fileFilter = path_filename(pattern);
+  if (string_starts_with(fileFilter, string_lit("*"))) {
+    flags |= AssetRepoFsQuery_Recursive;
+  }
+
+  return asset_repo_fs_query_iteration(repoFs, directory, pattern, flags, context, handler);
+}
+
 static void asset_repo_fs_destroy(AssetRepo* repo) {
   AssetRepoFs* repoFs = (AssetRepoFs*)repo;
 
@@ -113,6 +212,7 @@ AssetRepo* asset_repo_create_fs(String rootPath) {
               .destroy      = asset_repo_fs_destroy,
               .changesWatch = asset_repo_fs_changes_watch,
               .changesPoll  = asset_repo_fs_changes_poll,
+              .query        = asset_repo_fs_query,
           },
       .rootPath = string_dup(g_alloc_heap, rootPath),
       .monitor  = file_monitor_create(g_alloc_heap, rootPath),

libs/asset/src/repo_internal.h

@@ -6,6 +6,17 @@
 typedef struct sAssetRepo   AssetRepo;
 typedef struct sAssetSource AssetSource;
 
+typedef void (*AssetRepoQueryHandler)(void* ctx, String assetId);
+
+typedef enum {
+  AssetRepoQueryResult_Success,
+  AssetRepoQueryResult_ErrorNotSupported,
+  AssetRepoQueryResult_ErrorPatternNotSupported,
+  AssetRepoQueryResult_ErrorWhileQuerying,
+
+  AssetRepoQueryResult_Count,
+} AssetRepoQueryResult;
+
 /**
  * Asset repository.
  * NOTE: Api is thread-safe.
@@ -16,6 +27,7 @@ struct sAssetRepo {
   void (*destroy)(AssetRepo*);
   void (*changesWatch)(AssetRepo*, String id, u64 userData);
   bool (*changesPoll)(AssetRepo*, u64* outUserData);
+  AssetRepoQueryResult (*query)(AssetRepo*, String pattern, void* ctx, AssetRepoQueryHandler);
 };
 
 struct sAssetSource {
@@ -24,6 +36,8 @@ struct sAssetSource {
   void (*close)(AssetSource*);
 };
 
+String asset_repo_query_result_str(AssetRepoQueryResult);
+
 AssetRepo* asset_repo_create_fs(String rootPath);
 AssetRepo* asset_repo_create_mem(const AssetMemRecord* records, usize recordCount);
 void       asset_repo_destroy(AssetRepo*);
@@ -32,5 +46,6 @@ AssetSource* asset_repo_source_open(AssetRepo*, String id);
 bool         asset_repo_save(AssetRepo*, String id, String data);
 void         asset_repo_source_close(AssetSource*);
 
-void asset_repo_changes_watch(AssetRepo*, String id, u64 userData);
-bool asset_repo_changes_poll(AssetRepo*, u64* outUserData);
+void                 asset_repo_changes_watch(AssetRepo*, String id, u64 userData);
+bool                 asset_repo_changes_poll(AssetRepo*, u64* outUserData);
+AssetRepoQueryResult asset_repo_query(AssetRepo*, String pattern, void* ctx, AssetRepoQueryHandler);

libs/asset/src/repo_mem.c

@@ -7,6 +7,7 @@
 
 typedef struct {
   StringHash idHash;
+  String     id;
   String     data;
 } RepoEntry;
 
@@ -37,10 +38,26 @@ static AssetSource* asset_source_mem_open(AssetRepo* repo, const String id) {
   return src;
 }
 
+static AssetRepoQueryResult asset_repo_mem_query(
+    AssetRepo* repo, const String pattern, void* ctx, const AssetRepoQueryHandler handler) {
+  AssetRepoMem* repoMem = (AssetRepoMem*)repo;
+
+  dynarray_for_t(&repoMem->entries, RepoEntry, entry) {
+    if (string_match_glob(entry->id, pattern, StringMatchFlags_None)) {
+      handler(ctx, entry->id);
+    }
+  }
+
+  return AssetRepoQueryResult_Success;
+}
+
 static void asset_repo_mem_destroy(AssetRepo* repo) {
   AssetRepoMem* repoMem = (AssetRepoMem*)repo;
 
-  dynarray_for_t(&repoMem->entries, RepoEntry, entry) { string_free(g_alloc_heap, entry->data); };
+  dynarray_for_t(&repoMem->entries, RepoEntry, entry) {
+    string_free(g_alloc_heap, entry->id);
+    string_free(g_alloc_heap, entry->data);
+  };
   dynarray_destroy(&repoMem->entries);
 
   alloc_free_t(g_alloc_heap, repoMem);
@@ -56,13 +73,15 @@ AssetRepo* asset_repo_create_mem(const AssetMemRecord* records, const usize reco
               .destroy      = asset_repo_mem_destroy,
               .changesWatch = null,
               .changesPoll  = null,
+              .query        = asset_repo_mem_query,
           },
       .entries = dynarray_create_t(g_alloc_heap, RepoEntry, recordCount),
   };
 
   for (usize i = 0; i != recordCount; ++i) {
     RepoEntry entry = {
         .idHash = string_hash(records[i].id),
+        .id     = string_dup(g_alloc_heap, records[i].id),
         .data   = string_dup(g_alloc_heap, records[i].data),
     };
     *dynarray_insert_sorted_t(&repo->entries, RepoEntry, asset_compare_entry, &entry) = entry;