16 files changed, 247 insertions, 211 deletions

diff --git a/src/asset/model.c b/src/asset/model.c
index a97d20e..b5c6b0d 100644
--- a/src/asset/model.c
+++ b/src/asset/model.c
@@ -1030,7 +1030,6 @@ static bool load_meshes(
         const cgltf_attribute*   attrib       = &prim->attributes[a];
         const cgltf_accessor*    accessor     = attrib->data;
         const cgltf_buffer_view* view         = accessor->buffer_view;
-        const cgltf_size         offset       = accessor->offset + view->offset;
         const cgltf_size         buffer_index = view->buffer - data->buffers;
 
         assert(buffer_index < data->buffers_count);
@@ -1120,12 +1119,20 @@ static bool load_meshes(
           break;
         }
 
-#define CONFIGURE_BUFFER(buf)         \
-  if (buf) {                          \
-    buf->buffer       = buffer;       \
-    buf->offset_bytes = offset;       \
-    buf->size_bytes   = view->size;   \
-    buf->stride_bytes = view->stride; \
+        // See comments here for accessor/view/buffer invariants:
+        //   https://github.com/KhronosGroup/glTF-Sample-Assets/issues/242
+        // Gfx only has Buffer and BufferView, not accessors. We must combine
+        // the glTF's accessor and view offsets correctly.
+        const cgltf_size offset     = accessor->offset + view->offset;
+        const cgltf_size size_bytes = view->size - accessor->offset;
+
+#define CONFIGURE_BUFFER(buf)            \
+  if (buf) {                             \
+    buf->buffer       = buffer;          \
+    buf->offset_bytes = offset;          \
+    buf->size_bytes   = size_bytes;      \
+    buf->stride_bytes = view->stride;    \
+    buf->count        = accessor->count; \
   }
         CONFIGURE_BUFFER(buffer_view_2d);
         CONFIGURE_BUFFER(buffer_view_3d);
@@ -1160,14 +1167,11 @@ static bool load_meshes(
       // either 2d or 3d positions but not both, here we can perform addition
       // to compute the total number of vertices.
       geometry_desc.num_verts =
-          (geometry_desc.positions2d.size_bytes / sizeof(vec2)) +
-          (geometry_desc.positions3d.size_bytes / sizeof(vec3));
-
-#define CHECK_COUNT(buffer_view, type, num_components)                 \
-  if (geometry_desc.buffer_view.buffer) {                              \
-    assert(                                                            \
-        (geometry_desc.buffer_view.size_bytes /                        \
-         (num_components * sizeof(type))) == geometry_desc.num_verts); \
+          geometry_desc.positions2d.count + geometry_desc.positions3d.count;
+
+#define CHECK_COUNT(buffer_view, type, num_components)                  \
+  if (geometry_desc.buffer_view.buffer) {                               \
+    assert(geometry_desc.buffer_view.count == geometry_desc.num_verts); \
   }
 
       // Check that the number of vertices is consistent across all vertex
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 eeb46f8..3840019 100644
--- a/src/core/shader_program.c
+++ b/src/core/shader_program.c
@@ -209,6 +209,35 @@ 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_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);
diff --git a/src/memory.c b/src/memory.c
index de20f78..754f04d 100644
--- a/src/memory.c
+++ b/src/memory.c
@@ -4,7 +4,9 @@
 #include <gfx/sizes.h>
 
 #include "animation_impl.h"
-#include "render/llr_impl.h"
+#include "scene/light_impl.h"
+#include "scene/material_impl.h"
+#include "scene/mesh_impl.h"
 #include "scene/model_impl.h"
 #include "scene/node_impl.h"
 #include "scene/object_impl.h"
diff --git a/src/render/imm.c b/src/render/imm.c
index 8a93488..7ab8d62 100644
--- a/src/render/imm.c
+++ b/src/render/imm.c
@@ -21,12 +21,14 @@ bool gfx_imm_make(Imm* renderer, GfxCore* gfxcore, LLR* llr) {
   renderer->llr     = llr;
 
   renderer->triangles = gfx_make_geometry(
-      gfxcore,
-      &(GeometryDesc){.type         = Triangles,
-                      .buffer_usage = BufferDynamic,
-                      .num_verts    = num_triangle_verts,
-                      .positions3d  = (BufferView3d){
-                           .size_bytes = num_triangle_verts * sizeof(vec3)}});
+      gfxcore, &(GeometryDesc){
+                   .type         = Triangles,
+                   .buffer_usage = BufferDynamic,
+                   .num_verts    = num_triangle_verts,
+                   .positions3d  = (BufferView3d){
+                                                  .size_bytes = num_triangle_verts * sizeof(vec3),
+                                                  .count      = num_triangle_verts}
+  });
   if (!renderer->triangles) {
     goto cleanup;
   }
diff --git a/src/render/llr.c b/src/render/llr.c
index c9c6d34..752b65b 100644
--- a/src/render/llr.c
+++ b/src/render/llr.c
@@ -1,14 +1,15 @@
 #include "llr_impl.h"
 
 #include "animation_impl.h"
-#include "memory.h"
+#include "scene/light_impl.h"
+#include "scene/material_impl.h"
+#include "scene/mesh_impl.h"
 #include "scene/node_impl.h"
 
 #include <gfx/core.h>
 #include <gfx/util/ibl.h>
 
 #include <cassert.h>
-#include <error.h>
 
 static const int IRRADIANCE_MAP_WIDTH               = 1024;
 static const int IRRADIANCE_MAP_HEIGHT              = 1024;
@@ -17,108 +18,23 @@ static const int PREFILTERED_ENVIRONMENT_MAP_HEIGHT = 128;
 static const int BRDF_INTEGRATION_MAP_WIDTH         = 512;
 static const int BRDF_INTEGRATION_MAP_HEIGHT        = 512;
 
-static void make_environment_light(
-    Light* light, const EnvironmentLightDesc* desc) {
-  assert(light);
-  assert(desc);
-  light->type                        = EnvironmentLightType;
-  light->environment.environment_map = desc->environment_map;
-}
-
-Light* gfx_make_light(const LightDesc* desc) {
-  assert(desc);
-
-  Light* light = mem_alloc_light();
-
-  switch (desc->type) {
-  case EnvironmentLightType:
-    make_environment_light(light, &desc->light.environment);
-    break;
-  default:
-    log_error("Unhandled light type");
-    gfx_destroy_light(&light);
-    return 0;
-  }
-
-  return light;
-}
-
-void gfx_destroy_light(Light** light) {
-  assert(light);
-  if (*light) {
-    mem_free_light(light);
-  }
-}
-
-static void material_make(Material* material, const MaterialDesc* desc) {
-  assert(material);
-  assert(desc);
-  assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  material->alpha_mode   = desc->alpha_mode;
-  material->alpha_cutoff = desc->alpha_cutoff;
-  material->num_uniforms = (int8_t)desc->num_uniforms;
-  for (int i = 0; i < desc->num_uniforms; ++i) {
-    material->uniforms[i] = desc->uniforms[i];
-  }
-}
-
-Material* gfx_make_material(const MaterialDesc* desc) {
-  assert(desc);
-  Material* material = mem_alloc_material();
-  material_make(material, desc);
-  return material;
-}
-
-void gfx_destroy_material(Material** material) { mem_free_material(material); }
-
-// TODO: Move this to core/shader_program.
-static void 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;
-  }
-}
-
 /// Activate the material.
 ///
 /// This configures the shader uniforms that are specific to the material.
-static void gfx_material_activate(
-    ShaderProgram* shader, const Material* material) {
+static void material_activate(ShaderProgram* shader, const Material* material) {
   assert(material);
   for (int i = 0; i < material->num_uniforms; ++i) {
     const ShaderUniform* uniform = &material->uniforms[i];
-    set_uniform(shader, uniform);
+    gfx_set_uniform(shader, uniform);
   }
   if (material->alpha_mode != Opaque) {
-    set_uniform(
+    gfx_set_uniform(
         shader, &(ShaderUniform){.name              = sstring_make("AlphaMode"),
                                  .type              = UniformInt,
                                  .value.uniform_int = material->alpha_mode});
   }
   if (material->alpha_mode == Mask) {
-    set_uniform(
+    gfx_set_uniform(
         shader,
         &(ShaderUniform){.name                = sstring_make("AlphaCutoff"),
                          .type                = UniformFloat,
@@ -126,25 +42,6 @@ static void gfx_material_activate(
   }
 }
 
-static void mesh_make(Mesh* mesh, const MeshDesc* desc) {
-  assert(mesh);
-  assert(desc);
-  assert(desc->geometry);
-  assert(desc->material);
-  assert(desc->shader);
-  mesh->geometry = desc->geometry;
-  mesh->material = desc->material;
-  mesh->shader   = desc->shader;
-}
-
-Mesh* gfx_make_mesh(const MeshDesc* desc) {
-  Mesh* mesh = mem_alloc_mesh();
-  mesh_make(mesh, desc);
-  return mesh;
-}
-
-void gfx_destroy_mesh(Mesh** mesh) { mem_free_mesh(mesh); }
-
 /// Initialize renderer state for IBL.
 static bool init_ibl(LLR* renderer) {
   assert(renderer);
@@ -334,7 +231,7 @@ static void configure_state(LLR* renderer) {
 
     // Geometry may be rendered without a material.
     if (renderer->material) {
-      gfx_material_activate(renderer->shader, renderer->material);
+      material_activate(renderer->shader, renderer->material);
     }
   }
 
diff --git a/src/render/llr_impl.h b/src/render/llr_impl.h
index 3a5455a..9d70843 100644
--- a/src/render/llr_impl.h
+++ b/src/render/llr_impl.h
@@ -10,43 +10,12 @@
 #include <stddef.h>
 #include <stdint.h>
 
-typedef struct Geometry      Geometry;
 typedef struct GfxCore       GfxCore;
 typedef struct IBL           IBL;
 typedef struct Material      Material;
 typedef struct ShaderProgram ShaderProgram;
 typedef struct Texture       Texture;
 
-/// An environment light.
-typedef struct EnvironmentLight {
-  const Texture* environment_map;
-  const Texture* irradiance_map;              // Renderer implementation.
-  const Texture* prefiltered_environment_map; // Renderer implementation.
-  int max_reflection_lod; // Mandatory when prefiltered_environment_map is
-  // given.
-} EnvironmentLight;
-
-/// A scene light.
-typedef struct Light {
-  LightType type;
-  union {
-    EnvironmentLight environment;
-  };
-} Light;
-
-typedef struct Material {
-  AlphaMode     alpha_mode;
-  float         alpha_cutoff;
-  int8_t        num_uniforms;
-  ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
-} Material;
-
-typedef struct Mesh {
-  const Geometry* geometry;
-  const Material* material;
-  ShaderProgram*  shader; // TODO: Move this back to Material?
-} Mesh;
-
 /// Immediate mode renderer.
 ///
 /// The renderer caches state changes in memory and only programs the underlying
diff --git a/src/render/renderer.c b/src/render/renderer.c
index 26b63bc..a9d9bef 100644
--- a/src/render/renderer.c
+++ b/src/render/renderer.c
@@ -3,10 +3,11 @@
 #include "animation_impl.h"
 #include "llr_impl.h"
 #include "memory.h"
+#include "scene/material_impl.h"
+#include "scene/mesh_impl.h"
 #include "scene/model_impl.h"
 #include "scene/node_impl.h"
 #include "scene/object_impl.h"
-#include "scene/scene_impl.h"
 
 #include <gfx/core.h>
 #include <gfx/render/llr.h>
@@ -236,6 +237,8 @@ void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) {
   //  potentially renders the scene multiple times as needed. For example, a
   //  depth-prepass, followed by G-buffer, followed by some post-processing,
   //  etc. Rename this renderer to scene_renderer?
+  // TODO: When rendering transparent geometry, we need to turn off depth
+  //  writes.
   // Opaque.
   state.filter = RenderOpaqueAndAlphaMasked;
   draw_recursively(&state, mat4_id(), gfx_get_scene_root(scene));
diff --git a/src/scene/light.c b/src/scene/light.c
new file mode 100644
index 0000000..4233330
--- /dev/null
+++ b/src/scene/light.c
@@ -0,0 +1,39 @@
+#include "light_impl.h"
+
+#include "memory.h"
+
+#include <cassert.h>
+#include <error.h>
+
+static void make_environment_light(
+    Light* light, const EnvironmentLightDesc* desc) {
+  assert(light);
+  assert(desc);
+  light->type                        = EnvironmentLightType;
+  light->environment.environment_map = desc->environment_map;
+}
+
+Light* gfx_make_light(const LightDesc* desc) {
+  assert(desc);
+
+  Light* light = mem_alloc_light();
+
+  switch (desc->type) {
+  case EnvironmentLightType:
+    make_environment_light(light, &desc->light.environment);
+    break;
+  default:
+    log_error("Unhandled light type");
+    gfx_destroy_light(&light);
+    return 0;
+  }
+
+  return light;
+}
+
+void gfx_destroy_light(Light** light) {
+  assert(light);
+  if (*light) {
+    mem_free_light(light);
+  }
+}
diff --git a/src/scene/light_impl.h b/src/scene/light_impl.h
new file mode 100644
index 0000000..3191a50
--- /dev/null
+++ b/src/scene/light_impl.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <gfx/scene.h>
+
+/// An environment light.
+typedef struct EnvironmentLight {
+  const Texture* environment_map;
+  const Texture* irradiance_map;              // Renderer implementation.
+  const Texture* prefiltered_environment_map; // Renderer implementation.
+  int max_reflection_lod; // Mandatory when prefiltered_environment_map is
+  // given.
+} EnvironmentLight;
+
+/// A scene light.
+typedef struct Light {
+  LightType type;
+  union {
+    EnvironmentLight environment;
+  };
+} Light;
diff --git a/src/scene/material.c b/src/scene/material.c
new file mode 100644
index 0000000..9fe6c1b
--- /dev/null
+++ b/src/scene/material.c
@@ -0,0 +1,24 @@
+#include "material_impl.h"
+
+#include "memory.h"
+
+static void material_make(Material* material, const MaterialDesc* desc) {
+  assert(material);
+  assert(desc);
+  assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
+  material->alpha_mode   = desc->alpha_mode;
+  material->alpha_cutoff = desc->alpha_cutoff;
+  material->num_uniforms = (int8_t)desc->num_uniforms;
+  for (int i = 0; i < desc->num_uniforms; ++i) {
+    material->uniforms[i] = desc->uniforms[i];
+  }
+}
+
+Material* gfx_make_material(const MaterialDesc* desc) {
+  assert(desc);
+  Material* material = mem_alloc_material();
+  material_make(material, desc);
+  return material;
+}
+
+void gfx_destroy_material(Material** material) { mem_free_material(material); }
diff --git a/src/scene/material_impl.h b/src/scene/material_impl.h
new file mode 100644
index 0000000..488ffc7
--- /dev/null
+++ b/src/scene/material_impl.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <gfx/scene.h>
+#include <gfx/sizes.h>
+
+typedef struct ShaderProgram ShaderProgram;
+
+typedef struct Material {
+  AlphaMode     alpha_mode;
+  float         alpha_cutoff;
+  int8_t        num_uniforms;
+  ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
+} Material;
diff --git a/src/scene/mesh.c b/src/scene/mesh.c
new file mode 100644
index 0000000..770c3fb
--- /dev/null
+++ b/src/scene/mesh.c
@@ -0,0 +1,26 @@
+#include "mesh_impl.h"
+
+#include <gfx/scene.h>
+
+#include "memory.h"
+
+#include <cassert.h>
+
+static void mesh_make(Mesh* mesh, const MeshDesc* desc) {
+  assert(mesh);
+  assert(desc);
+  assert(desc->geometry);
+  assert(desc->material);
+  assert(desc->shader);
+  mesh->geometry = desc->geometry;
+  mesh->material = desc->material;
+  mesh->shader   = desc->shader;
+}
+
+Mesh* gfx_make_mesh(const MeshDesc* desc) {
+  Mesh* mesh = mem_alloc_mesh();
+  mesh_make(mesh, desc);
+  return mesh;
+}
+
+void gfx_destroy_mesh(Mesh** mesh) { mem_free_mesh(mesh); }
diff --git a/src/scene/mesh_impl.h b/src/scene/mesh_impl.h
new file mode 100644
index 0000000..c7e2211
--- /dev/null
+++ b/src/scene/mesh_impl.h
@@ -0,0 +1,11 @@
+#pragma once
+
+typedef struct Geometry      Geometry;
+typedef struct Material      Material;
+typedef struct ShaderProgram ShaderProgram;
+
+typedef struct Mesh {
+  const Geometry* geometry;
+  const Material* material;
+  ShaderProgram*  shader; // TODO: Move this back to Material?
+} Mesh;
diff --git a/src/scene/object.c b/src/scene/object.c
index 7004ce1..ac86b39 100644
--- a/src/scene/object.c
+++ b/src/scene/object.c
@@ -3,8 +3,9 @@
 #include <gfx/core.h>
 
 #include "memory.h"
-#include "node_impl.h"
 #include "render/llr_impl.h"
+#include "scene/mesh_impl.h"
+#include "scene/node_impl.h"
 
 #include <assert.h>
 
diff --git a/src/util/geometry.c b/src/util/geometry.c
index afe0109..2ea0c82 100644
--- a/src/util/geometry.c
+++ b/src/util/geometry.c
@@ -17,12 +17,13 @@ static void make_quad_01_positions(vec2 positions[4]) {
 }
 
 static GeometryDesc make_quad_desc(vec2 positions[4]) {
-  GeometryDesc desc           = (GeometryDesc){0};
-  desc.positions2d.data       = positions;
-  desc.positions2d.size_bytes = 4 * sizeof(vec2);
-  desc.num_verts              = 4;
-  desc.type                   = TriangleStrip;
-  return desc;
+  return (GeometryDesc){
+      .positions2d = (BufferView2d){.data       = positions,
+                                    .size_bytes = 4 * sizeof(vec2),
+                                    .count      = 4},
+      .num_verts   = 4,
+      .type        = TriangleStrip
+  };
 }
 
 Geometry* gfx_make_quad_11(GfxCore* gfxcore) {