Flatten project structure

This will make it easier to break up the code into smaller chunks again
later.

One would think doing this seems fun to me at this point.

1 files changed, 155 insertions, 0 deletions

diff --git a/src/resources.c b/src/resources.c
new file mode 100644
index 0000000..49b20e0
--- /dev/null
+++ b/src/resources.c
@@ -0,0 +1,155 @@
+#include <string.h>
+
+#include <daw/types.h>
+#include <daw/daw.h>
+#include <daw/logging.h>
+#include <daw/platform.h>
+#include <daw/resources.h>
+
+extern Instance* GLOBAL_PLATFORM;
+
+extern const char* ShaderType_str[];
+
+void* get_asset(Resources* r, u32 idx) {
+  switch (r->assets[idx].type) {
+  case Asset_shader:
+    // The shaders used to compile shader programs are not preserved.
+    WARN("We don't store pure shaders");
+    break;
+
+  case Asset_shaderprog:
+    LOG("Idx: r->get[%d] = %d", idx, r->get[idx]);
+    //LOG("Ptr: &r->shader[r->get[idx]] = %z", &r->shader[r->get[idx]]);
+    return &r->shader[r->get[idx]];
+
+  case Asset_texture:
+    return &r->texture[r->get[idx]];
+
+  case Asset_error:
+  case Asset_audio:
+  case Asset_font:
+  default:
+    ERROR("Asset type Not implemented");
+    break;
+  }
+  return NULL;
+}
+
+i32 resources_load(Resources *resources) {
+  resources->get = calloc(resources->assets_len, sizeof(usize));
+  usize audio_len = 0;
+  usize font_len = 0;
+  usize shader_len = 0;
+  usize shaderprog_len = 0;
+  usize texture_len = 0;
+
+  usize i = 0;
+
+  // Count each type of resource so we can allocate appropriate sizes.
+  for (i = 0; i < resources->assets_len; i++) {
+    usize idx = 0;
+
+    switch (resources->assets[i].type) {
+      case Asset_audio:      idx = audio_len++;      WARN("Audio resource type not implemented!"); break;
+      case Asset_font:       idx = font_len++;       WARN("Font resource type not implemented!"); break;
+      case Asset_shader:     idx = shader_len++;     break;
+      case Asset_shaderprog: idx = shaderprog_len++; break;
+      case Asset_texture:    idx = texture_len++;    break;
+
+      case Asset_error: break;
+      default:
+        ERROR("Unknown resource type!");
+        exit(EXIT_FAILURE);
+        break;
+    }
+
+    // Update index translation table.
+    resources->get[i] = idx;
+  }
+
+  //resources->audio = calloc(audio_len, sizeof());
+  //resources->font = calloc(font_len, sizeof());
+  resources->shader = calloc(shaderprog_len, sizeof(Shader));
+  resources->texture = calloc(texture_len, sizeof(Texture));
+
+  Shader* imm_shader = calloc(shader_len, sizeof(Shader));
+
+  audio_len = 0;
+  font_len = 0;
+  shader_len = 0;
+  shaderprog_len = 0;
+  texture_len = 0;
+
+  for (i = 0; i < resources->assets_len; i++) {
+    switch (resources->assets[i].type) {
+    case Asset_audio:
+        //resources->audio_len++;
+        WARN("Audio resource type not implemented!");
+        break;
+    case Asset_font:
+        //resources->font_len++;
+        WARN("Font resource type not implemented!");
+        break;
+    case Asset_shader: {
+        ShaderType t =
+            guess_shadertype_from_filename(resources->assets[i].shader.path);
+        const Shader s = compile_shader(resources->assets[i].shader.path, t);
+        LOG("Compiled %s! (%s)", resources->assets[i].shader.path, ShaderType_str[t]);
+
+        imm_shader[shader_len] = s;
+        shader_len++;
+    } break;
+    case Asset_shaderprog: {
+        const usize sz = resources->assets[i].shaderprog.shader_len;
+        const u32* shader_ids = resources->assets[i].shaderprog.shader;
+        Shader* shaders = calloc(sz, sizeof(Shader));
+
+        for (usize j = 0; j < sz; j++) {
+          //DEBUG("shader[%d] = %d\n", j, imm_shader[resources->assets[i].shaderprog.shader[j]].program);
+          //shaders[j] = imm_shader[resources->assets[i].shaderprog.shader[j]];
+          u32 shader_idx = shader_ids[j];
+          //DEBUG("Idx: get[%d] = %d\n", shader_idx, imm_shader[resources->get[shader_idx]].program);
+          shaders[j] = imm_shader[resources->get[shader_idx]];
+        }
+
+        const Shader s = compose_shader(shaders, sz);
+
+        resources->shader[resources->shader_len] = s;
+        resources->shader_len++;
+    } break;
+    case Asset_texture:
+        resources->texture[resources->texture_len] = load_texture(&resources->assets[i].texture);
+        resources->texture_len++;
+        LOG("Loaded texture \"%s\"!", resources->assets[i].texture.path);
+        break;
+
+    case Asset_error:
+        break;
+    default:
+        ERROR("Unknown resource type!");
+        exit(EXIT_FAILURE);
+        break;
+    }
+
+    //resources->get[i] = idx;
+  }
+
+  LOG("Total assets: %lu", resources->assets_len);
+  LOG(" Shaders: %lu", resources->shader_len);
+  LOG(" Textures: %lu", resources->texture_len);
+
+  // Delete the immediate shaders
+  for (i = 0; i < shader_len; i++) {
+    // glDeleteShader()
+  }
+
+  shaders_delete(imm_shader, shader_len);
+  free(imm_shader);
+
+  return 0;
+}
+
+isize resource_make_global(isize resource_id) {
+  ERROR("`resource_make_global` Not implemented");
+  return -1;
+}