4 files changed, 165 insertions, 100 deletions

diff --git a/src/core/core.c b/src/core/core.c
index e1671ea..9c04cc7 100644
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -3,6 +3,7 @@
 #include "gl_util.h"
 
 // #include <log/log.h>
+#include <fnv1a.h>
 
 #include <assert.h>
 
@@ -282,26 +283,29 @@ void gfx_destroy_framebuffer(GfxCore* gfxcore, FrameBuffer** framebuffer) {
 // Shaders.
 // -----------------------------------------------------------------------------
 
-static uint64_t hash_shader_desc(const ShaderDesc* desc) {
+static hash_t hash_shader_desc(const ShaderDesc* desc) {
   assert(desc);
-  // Note that defines may affect shader permutations, so we need to hash those
-  // as well.
-  uint64_t hash = 0;
+  // Defines may affect shader permutations, so we need to hash those as well.
+  hash_t hash = fnv1a32_begin();
+  hash        = fnv1a32_update(hash, desc->code, strlen(desc->code));
   for (size_t i = 0; i < desc->num_defines; ++i) {
     const ShaderCompilerDefine* define = &desc->defines[i];
-    hash = (((hash << 13) + sstring_hash(define->name)) << 7) +
-           sstring_hash(define->value);
+
+    hash = fnv1a32_update(
+        hash, sstring_cstr(&define->name), sstring_length(&define->name));
+    hash = fnv1a32_update(
+        hash, sstring_cstr(&define->value), sstring_length(&define->value));
   }
-  return (hash << 17) + cstring_hash(desc->code);
+  return hash;
 }
 
-static uint64_t hash_program_desc(const ShaderProgramDesc* desc) {
+static hash_t hash_program_desc(const ShaderProgramDesc* desc) {
   assert(desc);
-  return ((uint64_t)desc->vertex_shader->id << 32) |
-         (uint64_t)desc->fragment_shader->id;
+  return ((hash_t)desc->vertex_shader->id << 16) |
+         (hash_t)desc->fragment_shader->id;
 }
 
-static Shader* find_cached_shader(ShaderCache* cache, uint64_t hash) {
+static Shader* find_cached_shader(ShaderCache* cache, hash_t hash) {
   assert(cache);
   mempool_foreach(cache, entry, {
     if (entry->hash == hash) {
@@ -311,7 +315,7 @@ static Shader* find_cached_shader(ShaderCache* cache, uint64_t hash) {
   return 0;
 }
 
-static ShaderProgram* find_cached_program(ProgramCache* cache, uint64_t hash) {
+static ShaderProgram* find_cached_program(ProgramCache* cache, hash_t hash) {
   assert(cache);
   mempool_foreach(cache, entry, {
     if (entry->hash == hash) {
@@ -350,9 +354,9 @@ Shader* gfx_make_shader(GfxCore* gfxcore, const ShaderDesc* desc) {
   assert(desc);
 
   // Check the shader cache first.
-  ShaderCache*   cache  = &gfxcore->shader_cache;
-  const uint64_t hash   = hash_shader_desc(desc);
-  Shader*        shader = find_cached_shader(cache, hash);
+  ShaderCache* cache  = &gfxcore->shader_cache;
+  const hash_t hash   = hash_shader_desc(desc);
+  Shader*      shader = find_cached_shader(cache, hash);
   if (shader) {
     // LOGD("Found cached shader with hash [%lx]", hash);
     return shader;
@@ -395,7 +399,7 @@ ShaderProgram* gfx_make_shader_program(
 
   // Check the shader program cache first.
   ProgramCache*  cache = &gfxcore->program_cache;
-  const uint64_t hash  = hash_program_desc(desc);
+  const hash_t   hash  = hash_program_desc(desc);
   ShaderProgram* prog  = find_cached_program(cache, hash);
   if (prog) {
     // LOGD("Found cached shader program with hash [%lx]", hash);
diff --git a/src/core/core_impl.h b/src/core/core_impl.h
index eefdfbe..320532d 100644
--- a/src/core/core_impl.h
+++ b/src/core/core_impl.h
@@ -15,16 +15,18 @@
 
 #include <stdint.h>
 
+typedef uint32_t hash_t;
+
 // TODO: Make a generic (hash, void*) structure and define functions over it.
 // Then define a macro that defines type-safe macros given the type of the
 // entry.
 typedef struct ShaderCacheEntry {
-  uint64_t hash;
-  Shader*  shader;
+  hash_t  hash;
+  Shader* shader;
 } ShaderCacheEntry;
 
 typedef struct ShaderProgramCacheEntry {
-  uint64_t       hash;
+  hash_t         hash;
   ShaderProgram* program;
 } ShaderProgramCacheEntry;
 
diff --git a/src/core/geometry.c b/src/core/geometry.c
index cfc749f..488dc23 100644
--- a/src/core/geometry.c
+++ b/src/core/geometry.c
@@ -12,7 +12,7 @@
 ///
 /// Note that views are allowed to have no data, in which case a buffer of the
 /// specified size is created.
-#define view_is_populated(BUFFER_VIEW) (BUFFER_VIEW.size_bytes > 0)
+#define view_is_populated(BUFFER_VIEW) (BUFFER_VIEW.count > 0)
 
 static GLenum primitive_type_to_gl(PrimitiveType type) {
   switch (type) {
@@ -34,30 +34,25 @@ void init_view_buffer(
     BufferUsage buffer_usage) {
   if (!view->buffer) {
     view->buffer = gfx_make_buffer(
-        gfxcore,
-        &(BufferDesc){
-            .usage      = buffer_usage,
-            .type       = buffer_type,
-            .data.data  = view->data,
-            .data.count = view->size_bytes /
-                          gfx_get_buffer_type_size_bytes(buffer_type)});
+        gfxcore, &(BufferDesc){.usage      = buffer_usage,
+                               .type       = buffer_type,
+                               .data.data  = view->data,
+                               .data.count = view->count});
+    assert(view->buffer);
   }
-  assert(view->size_bytes <= view->buffer->size_bytes);
 }
 
-/// Configure the buffer in teh VAO.
+/// Configure the buffer in the VAO.
 static void configure_buffer(
     GfxCore* gfxcore, const GeometryDesc* desc, BufferView* view,
-    size_t num_components, size_t component_size_bytes, GLenum component_type,
-    GLboolean normalized, GLuint channel) {
+    size_t num_components, GLenum component_type, GLboolean normalized,
+    GLuint channel) {
   assert(gfxcore);
   assert(desc);
   assert(view);
   assert(view->buffer);
-  assert(
-      desc->num_verts <=
-      view->size_bytes / (num_components * component_size_bytes));
-  assert(view->size_bytes <= view->buffer->size_bytes);
+  assert(view->count == desc->num_verts);
+  assert((view->offset_bytes + view->size_bytes) <= view->buffer->size_bytes);
 
   glBindBuffer(GL_ARRAY_BUFFER, view->buffer->vbo);
   glEnableVertexAttribArray(channel);
@@ -89,8 +84,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->positions3d, 3, sizeof(float),
-        GL_FLOAT, GL_FALSE, GFX_POSITION_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->positions3d, 3, GL_FLOAT, GL_FALSE,
+        GFX_POSITION_CHANNEL);
   } else if (view_is_populated(desc->positions2d)) {
     init_view_buffer(
         gfxcore, (BufferView*)&desc->positions2d, Buffer2d, desc->buffer_usage);
@@ -98,8 +93,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->positions2d, 2, sizeof(float),
-        GL_FLOAT, GL_FALSE, GFX_POSITION_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->positions2d, 2, GL_FLOAT, GL_FALSE,
+        GFX_POSITION_CHANNEL);
   }
   if (view_is_populated(desc->normals)) {
     init_view_buffer(
@@ -108,8 +103,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->normals, 3, sizeof(float), GL_FLOAT,
-        GL_FALSE, GFX_NORMAL_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->normals, 3, GL_FLOAT, GL_FALSE,
+        GFX_NORMAL_CHANNEL);
   }
   if (view_is_populated(desc->tangents)) {
     init_view_buffer(
@@ -118,8 +113,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->tangents, 4, sizeof(float), GL_FLOAT,
-        GL_FALSE, GFX_TANGENT_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->tangents, 4, GL_FLOAT, GL_FALSE,
+        GFX_TANGENT_CHANNEL);
   }
   if (view_is_populated(desc->texcoords)) {
     init_view_buffer(
@@ -128,8 +123,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->texcoords, 2, sizeof(float),
-        GL_FLOAT, GL_FALSE, GFX_TEXCOORDS_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->texcoords, 2, GL_FLOAT, GL_FALSE,
+        GFX_TEXCOORDS_CHANNEL);
   }
   if (view_is_populated(desc->joints.u8)) {
     init_view_buffer(
@@ -138,8 +133,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->joints.u8, 4, sizeof(uint8_t),
-        GL_UNSIGNED_BYTE, GL_FALSE, GFX_JOINTS_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->joints.u8, 4, GL_UNSIGNED_BYTE,
+        GL_FALSE, GFX_JOINTS_CHANNEL);
   } else if (view_is_populated(desc->joints.u16)) {
     init_view_buffer(
         gfxcore, (BufferView*)&desc->joints.u16, BufferU16, desc->buffer_usage);
@@ -147,8 +142,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->joints.u16, 4, sizeof(uint16_t),
-        GL_UNSIGNED_SHORT, GL_FALSE, GFX_JOINTS_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->joints.u16, 4, GL_UNSIGNED_SHORT,
+        GL_FALSE, GFX_JOINTS_CHANNEL);
   }
 
   // If weights are given as unsigned integers, then they are normalized
@@ -160,8 +155,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->weights.u8, 4, sizeof(uint8_t),
-        GL_UNSIGNED_BYTE, GL_TRUE, GFX_WEIGHTS_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->weights.u8, 4, GL_UNSIGNED_BYTE,
+        GL_TRUE, GFX_WEIGHTS_CHANNEL);
   } else if (view_is_populated(desc->weights.u16)) {
     init_view_buffer(
         gfxcore, (BufferView*)&desc->weights.u16, BufferU16,
@@ -170,8 +165,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->weights.u16, 4, sizeof(uint16_t),
-        GL_UNSIGNED_SHORT, GL_TRUE, GFX_WEIGHTS_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->weights.u16, 4, GL_UNSIGNED_SHORT,
+        GL_TRUE, GFX_WEIGHTS_CHANNEL);
   } else if (view_is_populated(desc->weights.floats)) {
     init_view_buffer(
         gfxcore, (BufferView*)&desc->weights.floats, BufferFloat,
@@ -180,8 +175,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
       return false;
     }
     configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->weights.floats, 4, sizeof(float),
-        GL_FLOAT, GL_FALSE, GFX_WEIGHTS_CHANNEL);
+        gfxcore, desc, (BufferView*)&desc->weights.floats, 4, GL_FLOAT,
+        GL_FALSE, GFX_WEIGHTS_CHANNEL);
   }
 
   return true;
@@ -282,9 +277,9 @@ void gfx_update_geometry(Geometry* geometry, const GeometryDesc* desc) {
     assert(geometry->desc.positions3d.buffer);
     gfx_update_buffer(
         geometry->desc.positions3d.buffer,
-        &(BufferDataDesc){
-            .vec3s = desc->positions3d.data,
-            .count = desc->positions3d.size_bytes / sizeof(vec3)});
+        &(BufferDataDesc){.vec3s = desc->positions3d.data,
+                          .count =
+                              desc->positions3d.size_bytes / sizeof(vec3)});
   }
   // TODO: more
   else {
diff --git a/src/core/shader_program.c b/src/core/shader_program.c
index 3cbe48d..3840019 100644
--- a/src/core/shader_program.c
+++ b/src/core/shader_program.c
@@ -72,17 +72,23 @@ void gfx_deactivate_shader_program(const ShaderProgram* prog) {
   ASSERT_GL;
 }
 
-static void set_texture_uniform(
-    GLuint prog, const char* name, int texture_unit, const Texture* texture) {
+static void set_int_uniform(GLuint prog, const char* name, int value) {
   assert(prog != 0);
   assert(name);
-  assert(texture);
 
   const GLint location = glGetUniformLocation(prog, name);
   if (location >= 0) {
-    glActiveTexture(GL_TEXTURE0 + texture_unit);
-    glBindTexture(texture->target, texture->id);
-    glUniform1i(location, texture_unit);
+    glUniform1i(location, value);
+  }
+}
+
+static void set_float_uniform(GLuint prog, const char* name, float value) {
+  assert(prog != 0);
+  assert(name);
+
+  const GLint location = glGetUniformLocation(prog, name);
+  if (location >= 0) {
+    glUniform1f(location, value);
   }
 }
 
@@ -118,13 +124,17 @@ static void set_vec4_uniform(GLuint prog, const char* name, vec4 value) {
   }
 }
 
-static void set_float_uniform(GLuint prog, const char* name, float value) {
+static void set_texture_uniform(
+    GLuint prog, const char* name, int texture_unit, const Texture* texture) {
   assert(prog != 0);
   assert(name);
+  assert(texture);
 
   const GLint location = glGetUniformLocation(prog, name);
   if (location >= 0) {
-    glUniform1f(location, value);
+    glActiveTexture(GL_TEXTURE0 + texture_unit);
+    glBindTexture(texture->target, texture->id);
+    glUniform1i(location, texture_unit);
   }
 }
 
@@ -135,23 +145,30 @@ void gfx_apply_uniforms(const ShaderProgram* prog) {
   for (int i = 0; i < prog->num_uniforms; ++i) {
     const ShaderUniform* uniform = &prog->uniforms[i];
     switch (uniform->type) {
-    case UniformTexture:
-      set_texture_uniform(
-          prog->id, uniform->name.str, next_texture_unit,
-          uniform->value.texture);
-      next_texture_unit++;
+    case UniformInt:
+      set_int_uniform(prog->id, uniform->name.str, uniform->value.uniform_int);
+      break;
+    case UniformFloat:
+      set_float_uniform(
+          prog->id, uniform->name.str, uniform->value.uniform_float);
       break;
     case UniformMat4:
-      set_mat4_uniform(prog->id, uniform->name.str, &uniform->value.mat4, 1);
+      set_mat4_uniform(
+          prog->id, uniform->name.str, &uniform->value.uniform_mat4, 1);
       break;
     case UniformVec3:
-      set_vec3_uniform(prog->id, uniform->name.str, uniform->value.vec3);
+      set_vec3_uniform(
+          prog->id, uniform->name.str, uniform->value.uniform_vec3);
       break;
     case UniformVec4:
-      set_vec4_uniform(prog->id, uniform->name.str, uniform->value.vec4);
+      set_vec4_uniform(
+          prog->id, uniform->name.str, uniform->value.uniform_vec4);
       break;
-    case UniformFloat:
-      set_float_uniform(prog->id, uniform->name.str, uniform->value.scalar);
+    case UniformTexture:
+      set_texture_uniform(
+          prog->id, uniform->name.str, next_texture_unit,
+          uniform->value.texture);
+      next_texture_unit++;
       break;
     case UniformMat4Array:
       set_mat4_uniform(
@@ -179,8 +196,9 @@ static ShaderUniform* get_or_allocate_uniform(
 
   // Create the uniform if it does not exist.
   if (prog->num_uniforms == GFX_MAX_UNIFORMS_PER_SHADER) {
-    FAIL("Exceeded the maximum number of uniforms per shader. Please increase "
-         "this value.");
+    FAIL(
+        "Exceeded the maximum number of uniforms per shader. Please increase "
+        "this value.");
     return 0;
   }
   ShaderUniform* uniform = &prog->uniforms[prog->num_uniforms];
@@ -191,21 +209,67 @@ static ShaderUniform* get_or_allocate_uniform(
 // The functions below save the value of a uniform in the shader program. If the
 // uniform does not even exist, then there is no need to store the value.
 
-void gfx_set_texture_uniform(
-    ShaderProgram* prog, const char* name, const Texture* texture) {
+void gfx_set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) {
+  switch (uniform->type) {
+  case UniformInt:
+    gfx_set_int_uniform(prog, uniform->name.str, uniform->value.uniform_int);
+    break;
+  case UniformFloat:
+    gfx_set_float_uniform(
+        prog, uniform->name.str, uniform->value.uniform_float);
+    break;
+  case UniformMat4:
+    gfx_set_mat4_uniform(prog, uniform->name.str, &uniform->value.uniform_mat4);
+    break;
+  case UniformVec3:
+    gfx_set_vec3_uniform(prog, uniform->name.str, uniform->value.uniform_vec3);
+    break;
+  case UniformVec4:
+    gfx_set_vec4_uniform(prog, uniform->name.str, uniform->value.uniform_vec4);
+    break;
+  case UniformTexture:
+    gfx_set_texture_uniform(prog, uniform->name.str, uniform->value.texture);
+    break;
+  case UniformMat4Array:
+    gfx_set_mat4_array_uniform(
+        prog, uniform->name.str, uniform->value.array.values,
+        uniform->value.array.count);
+    break;
+  }
+}
+
+void gfx_set_int_uniform(ShaderProgram* prog, const char* name, int value) {
   assert(prog);
   assert(name);
-  assert(texture);
 
+  // No need to store the uniform on our side if it does not exist in the
+  // program.
   const GLint location = glGetUniformLocation(prog->id, name);
   if (location < 0) {
     return;
   }
   ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
   assert(uniform);
-  uniform->name          = sstring_make(name);
-  uniform->type          = UniformTexture;
-  uniform->value.texture = texture;
+  uniform->name              = sstring_make(name);
+  uniform->type              = UniformInt;
+  uniform->value.uniform_int = value;
+}
+
+void gfx_set_float_uniform(ShaderProgram* prog, const char* name, float value) {
+  assert(prog);
+  assert(name);
+
+  // No need to store the uniform on our side if it does not exist in the
+  // program.
+  const GLint location = glGetUniformLocation(prog->id, name);
+  if (location < 0) {
+    return;
+  }
+  ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
+  assert(uniform);
+  uniform->name                = sstring_make(name);
+  uniform->type                = UniformFloat;
+  uniform->value.uniform_float = value;
 }
 
 void gfx_set_mat4_uniform(
@@ -220,9 +284,9 @@ void gfx_set_mat4_uniform(
   }
   ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
   assert(uniform);
-  uniform->name       = sstring_make(name);
-  uniform->type       = UniformMat4;
-  uniform->value.mat4 = *mat;
+  uniform->name               = sstring_make(name);
+  uniform->type               = UniformMat4;
+  uniform->value.uniform_mat4 = *mat;
 }
 
 void gfx_set_vec3_uniform(ShaderProgram* prog, const char* name, vec3 value) {
@@ -235,9 +299,9 @@ void gfx_set_vec3_uniform(ShaderProgram* prog, const char* name, vec3 value) {
   }
   ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
   assert(uniform);
-  uniform->name       = sstring_make(name);
-  uniform->type       = UniformVec3;
-  uniform->value.vec3 = value;
+  uniform->name               = sstring_make(name);
+  uniform->type               = UniformVec3;
+  uniform->value.uniform_vec3 = value;
 }
 
 void gfx_set_vec4_uniform(ShaderProgram* prog, const char* name, vec4 value) {
@@ -250,26 +314,26 @@ void gfx_set_vec4_uniform(ShaderProgram* prog, const char* name, vec4 value) {
   }
   ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
   assert(uniform);
-  uniform->name       = sstring_make(name);
-  uniform->type       = UniformVec4;
-  uniform->value.vec4 = value;
+  uniform->name               = sstring_make(name);
+  uniform->type               = UniformVec4;
+  uniform->value.uniform_vec4 = value;
 }
 
-void gfx_set_float_uniform(ShaderProgram* prog, const char* name, float value) {
+void gfx_set_texture_uniform(
+    ShaderProgram* prog, const char* name, const Texture* texture) {
   assert(prog);
   assert(name);
+  assert(texture);
 
-  // No need to store the uniform on our side if it does not exist in the
-  // program.
   const GLint location = glGetUniformLocation(prog->id, name);
   if (location < 0) {
     return;
   }
   ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
   assert(uniform);
-  uniform->name         = sstring_make(name);
-  uniform->type         = UniformFloat;
-  uniform->value.scalar = value;
+  uniform->name          = sstring_make(name);
+  uniform->type          = UniformTexture;
+  uniform->value.texture = texture;
 }
 
 void gfx_set_mat4_array_uniform(
@@ -277,7 +341,7 @@ void gfx_set_mat4_array_uniform(
   assert(prog);
   assert(name);
   assert(mats);
-  
+
   const GLint location = glGetUniformLocation(prog->id, name);
   if (location < 0) {
     return;