2 files changed, 140 insertions, 81 deletions

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;