14 files changed, 303 insertions, 279 deletions

diff --git a/gfx/include/gfx/scene/README.md b/gfx/include/gfx/scene/README.md
index 916596b..1910abe 100644
--- a/gfx/include/gfx/scene/README.md
+++ b/gfx/include/gfx/scene/README.md
@@ -21,7 +21,7 @@ former, the API could create the illusion that the hierarchy can be a DAG.
 The strict tree hierarchy should not be that restrictive in practice. Even the
 glTF 2.0 spec [enforces this](https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#nodes-and-hierarchy):
 
-*For Version 2.0 conformance, the glTF node hierarchy is not a directed acyclic
-graph (DAG) or scene graph, but a disjoint union of strict trees. That is, no
-node may be a direct descendant of more than one node. This restriction is meant
-to simplify implementation and facilitate conformance.*
+> *For Version 2.0 conformance, the glTF node hierarchy is not a directed
+> acyclic graph (DAG) or scene graph, but a disjoint union of strict trees. That
+> is, no node may be a direct descendant of more than one node. This restriction
+> is meant to simplify implementation and facilitate conformance.*
diff --git a/gfx/include/gfx/scene/material.h b/gfx/include/gfx/scene/material.h
index 6c22515..07e31d4 100644
--- a/gfx/include/gfx/scene/material.h
+++ b/gfx/include/gfx/scene/material.h
@@ -11,13 +11,8 @@ typedef struct Material Material;
 /// variables. Two materials can share the same shader, but shader parameters
 /// generally give two materials a different appearance.
 typedef struct MaterialDesc {
-  ShaderProgram* shader; // TODO: Move to Mesh? Cannot fully determine shader
-                         // permutation without geometry. Or move the creation
-                         // of permutations to the renderer? A multi-pass
-                         // renderer will juggle multiple shader programs
-                         // anyway.
   ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
-  int num_uniforms;
+  int           num_uniforms;
 } MaterialDesc;
 
 /// Create a material.
diff --git a/gfx/include/gfx/scene/mesh.h b/gfx/include/gfx/scene/mesh.h
index f16572a..0d3b4d4 100644
--- a/gfx/include/gfx/scene/mesh.h
+++ b/gfx/include/gfx/scene/mesh.h
@@ -1,7 +1,8 @@
 #pragma once
 
-typedef struct Geometry Geometry;
-typedef struct Material Material;
+typedef struct Geometry      Geometry;
+typedef struct Material      Material;
+typedef struct ShaderProgram ShaderProgram;
 
 typedef struct Mesh Mesh;
 
@@ -9,6 +10,7 @@ typedef struct Mesh Mesh;
 typedef struct MeshDesc {
   const Geometry* geometry;
   const Material* material;
+  ShaderProgram*  shader;
 } MeshDesc;
 
 /// Create a mesh.
diff --git a/gfx/include/gfx/util/scene.h b/gfx/include/gfx/util/scene.h
index 98267aa..7340d1d 100644
--- a/gfx/include/gfx/util/scene.h
+++ b/gfx/include/gfx/util/scene.h
@@ -24,7 +24,10 @@ typedef struct LoadSceneCmd {
 /// Load a scene.
 ///
 /// |root_node| is the node under which scene elements are loaded.
-/// |shader| is the shader program assigned to the loaded scene objects.
+///
+/// |shader| is an optional shader program assigned to the loaded scene objects.
+/// If no shader is given, a Cook-Torrance shader based on the object's
+/// characteristics (presence of normals, tangents, etc) is assigned.
 ///
 /// Currently only supports the GLTF format.
 bool gfx_load_scene(
diff --git a/gfx/shaders/cook_torrance.frag b/gfx/shaders/cook_torrance.frag
index b4cf590..b2bfd7d 100644
--- a/gfx/shaders/cook_torrance.frag
+++ b/gfx/shaders/cook_torrance.frag
@@ -11,6 +11,7 @@ uniform sampler2D EmissiveTexture;
 uniform sampler2D AmbientOcclusionTexture;
 uniform sampler2D NormalMap;
 
+// TODO: Handle case in which there is no sky. Pass a boolean.
 uniform samplerCube Sky;
 uniform samplerCube IrradianceMap;
 uniform samplerCube PrefilteredEnvironmentMap;
diff --git a/gfx/shaders/cook_torrance.vert b/gfx/shaders/cook_torrance.vert
index c66efa6..56dfeda 100644
--- a/gfx/shaders/cook_torrance.vert
+++ b/gfx/shaders/cook_torrance.vert
@@ -4,6 +4,7 @@ uniform mat4 ModelMatrix;
 uniform mat4 MVP;
 
 layout (location = 0) in vec3 vPosition;
+// TODO: Add HAS_NORMALS
 layout (location = 1) in vec3 vNormal;
 #ifdef HAS_TANGENTS
 layout (location = 2) in vec4 vTangent;
diff --git a/gfx/src/renderer/renderer.c b/gfx/src/renderer/renderer.c
index ed781c9..6b77ffe 100644
--- a/gfx/src/renderer/renderer.c
+++ b/gfx/src/renderer/renderer.c
@@ -18,12 +18,12 @@
 
 #include <assert.h>
 
-static const int IRRADIANCE_MAP_WIDTH = 1024;
-static const int IRRADIANCE_MAP_HEIGHT = 1024;
-static const int PREFILTERED_ENVIRONMENT_MAP_WIDTH = 128;
+static const int IRRADIANCE_MAP_WIDTH               = 1024;
+static const int IRRADIANCE_MAP_HEIGHT              = 1024;
+static const int PREFILTERED_ENVIRONMENT_MAP_WIDTH  = 128;
 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 const int BRDF_INTEGRATION_MAP_WIDTH         = 512;
+static const int BRDF_INTEGRATION_MAP_HEIGHT        = 512;
 
 bool renderer_make(Renderer* renderer, RenderBackend* render_backend) {
   assert(renderer);
@@ -63,9 +63,9 @@ void renderer_destroy(Renderer* renderer, RenderBackend* render_backend) {
 
 /// Computes irradiance and prefiltered environment maps for the light if they
 /// have not been already computed.
-static bool setup_environment_light(Renderer* renderer,
-                                    RenderBackend* render_backend,
-                                    EnvironmentLight* light) {
+static bool setup_environment_light(
+    Renderer* renderer, RenderBackend* render_backend,
+    EnvironmentLight* light) {
   assert(renderer);
   assert(light);
   assert(renderer->ibl);
@@ -75,7 +75,7 @@ static bool setup_environment_light(Renderer* renderer,
     return true;
   }
 
-  Texture* irradiance_map = 0;
+  Texture* irradiance_map              = 0;
   Texture* prefiltered_environment_map = 0;
 
   if (!(irradiance_map = gfx_make_irradiance_map(
@@ -92,9 +92,9 @@ static bool setup_environment_light(Renderer* renderer,
     goto cleanup;
   }
 
-  light->irradiance_map = irradiance_map;
+  light->irradiance_map              = irradiance_map;
   light->prefiltered_environment_map = prefiltered_environment_map;
-  light->max_reflection_lod = max_mip_level;
+  light->max_reflection_lod          = max_mip_level;
 
   return true;
 
@@ -110,21 +110,21 @@ cleanup:
 
 typedef struct RenderState {
   RenderBackend* render_backend;
-  Renderer* renderer;
-  const Scene* scene;
-  const Camera* camera;
-  const mat4* view_matrix;
-  const mat4* projection;
-  Light* environment_light;
-  const float fovy;
-  const float aspect;
+  Renderer*      renderer;
+  const Scene*   scene;
+  const Camera*  camera;
+  const mat4*    view_matrix;
+  const mat4*    projection;
+  Light*         environment_light;
+  const float    fovy;
+  const float    aspect;
 } RenderState;
 
-static void draw_recursively(RenderState* state, mat4 parent_transform,
-                             node_idx node_index) {
+static void draw_recursively(
+    RenderState* state, mat4 parent_transform, node_idx node_index) {
   assert(state);
-  const SceneNode* node = mem_get_node(node_index);
-  const mat4 node_transform = mat4_mul(parent_transform, node->transform);
+  const SceneNode* node           = mem_get_node(node_index);
+  const mat4       node_transform = mat4_mul(parent_transform, node->transform);
 
   // Activate light.
   if (node->type == LightNode) {
@@ -145,13 +145,13 @@ static void draw_recursively(RenderState* state, mat4 parent_transform,
     assert(object);
 
     const mat4 model_matrix = mat4_mul(node_transform, object->transform);
-    const mat4 modelview = mat4_mul(*state->view_matrix, model_matrix);
-    const mat4 mvp = mat4_mul(*state->projection, modelview);
+    const mat4 modelview    = mat4_mul(*state->view_matrix, model_matrix);
+    const mat4 mvp          = mat4_mul(*state->projection, modelview);
 
     for (mesh_link_idx mesh_link_index = object->mesh_link;
          mesh_link_index.val;) {
       const MeshLink* mesh_link = mem_get_mesh_link(mesh_link_index);
-      mesh_link_index = mesh_link->next;
+      mesh_link_index           = mesh_link->next;
 
       const Mesh* mesh = mem_get_mesh(mesh_link->mesh);
       if (!mesh) {
@@ -159,11 +159,10 @@ static void draw_recursively(RenderState* state, mat4 parent_transform,
       }
       assert(mesh->geometry);
       assert(mesh->material);
-      material_activate(mesh->material);
       // Apply common shader uniforms not captured by materials.
       // TODO: Avoid computing matrices like Modelview or MVP if the shader does
       // not use them.
-      ShaderProgram* shader = mesh->material->shader;
+      ShaderProgram* shader = mesh->shader;
       gfx_set_mat4_uniform(shader, "ModelMatrix", &model_matrix);
       gfx_set_mat4_uniform(shader, "Modelview", &modelview);
       gfx_set_mat4_uniform(shader, "Projection", state->projection);
@@ -177,19 +176,19 @@ static void draw_recursively(RenderState* state, mat4 parent_transform,
         assert(light->irradiance_map);
         assert(light->prefiltered_environment_map);
         assert(state->renderer->brdf_integration_map);
-        gfx_set_texture_uniform(shader, "BRDFIntegrationMap",
-                                state->renderer->brdf_integration_map);
+        gfx_set_texture_uniform(
+            shader, "BRDFIntegrationMap",
+            state->renderer->brdf_integration_map);
         gfx_set_texture_uniform(shader, "Sky", light->environment_map);
         gfx_set_texture_uniform(shader, "IrradianceMap", light->irradiance_map);
-        gfx_set_texture_uniform(shader, "PrefilteredEnvironmentMap",
-                                light->prefiltered_environment_map);
-        gfx_set_float_uniform(shader, "MaxReflectionLOD",
-                              light->max_reflection_lod);
+        gfx_set_texture_uniform(
+            shader, "PrefilteredEnvironmentMap",
+            light->prefiltered_environment_map);
+        gfx_set_float_uniform(
+            shader, "MaxReflectionLOD", light->max_reflection_lod);
       }
-      // TODO: Remove this altogether.
-      // This is not needed because material_activate() already activates the
-      // shader.
-      // gfx_activate_shader_program(shader);
+      material_activate(shader, mesh->material);
+      gfx_activate_shader_program(shader);
       gfx_apply_uniforms(shader);
       gfx_render_geometry(mesh->geometry);
     }
@@ -200,12 +199,13 @@ static void draw_recursively(RenderState* state, mat4 parent_transform,
     draw_recursively(state, node_transform, child_index);
 
     const SceneNode* child = mem_get_node(child_index);
-    child_index = child->next;
+    child_index            = child->next;
   }
 }
 
-void gfx_render_scene(Renderer* renderer, RenderBackend* render_backend,
-                      const Scene* scene, const SceneCamera* camera) {
+void gfx_render_scene(
+    Renderer* renderer, RenderBackend* render_backend, const Scene* scene,
+    const SceneCamera* camera) {
   assert(renderer);
   assert(render_backend);
 
@@ -221,16 +221,17 @@ void gfx_render_scene(Renderer* renderer, RenderBackend* render_backend,
   gfx_get_viewport(render_backend, &width, &height);
   const float aspect = (float)width / (float)height;
 
-  RenderState state = {.render_backend = render_backend,
-                       .renderer = renderer,
-                       .scene = scene,
-                       .camera = &camera->camera,
-                       .view_matrix = &view_matrix,
-                       .projection = &projection,
-                       .environment_light = 0,
-                       // Assuming a perspective matrix.
-                       .fovy = atan(1.0 / (mat4_at(projection, 1, 1))) * 2,
-                       .aspect = aspect};
+  RenderState state = {
+      .render_backend    = render_backend,
+      .renderer          = renderer,
+      .scene             = scene,
+      .camera            = &camera->camera,
+      .view_matrix       = &view_matrix,
+      .projection        = &projection,
+      .environment_light = 0,
+      // Assuming a perspective matrix.
+      .fovy   = atan(1.0 / (mat4_at(projection, 1, 1))) * 2,
+      .aspect = aspect};
 
   gfx_start_frame(render_backend);
   draw_recursively(&state, mat4_id(), scene->root);
diff --git a/gfx/src/scene/material.c b/gfx/src/scene/material.c
index d44746a..e5856d0 100644
--- a/gfx/src/scene/material.c
+++ b/gfx/src/scene/material.c
@@ -8,7 +8,6 @@ static void material_make(Material* material, const MaterialDesc* desc) {
   assert(material);
   assert(desc);
   assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  material->shader = desc->shader;
   material->num_uniforms = desc->num_uniforms;
   for (int i = 0; i < desc->num_uniforms; ++i) {
     material->uniforms[i] = desc->uniforms[i];
@@ -47,11 +46,10 @@ static void set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) {
   }
 }
 
-void material_activate(const Material* material) {
+void material_activate(ShaderProgram* shader, const Material* material) {
   assert(material);
-  gfx_activate_shader_program(material->shader);
   for (int i = 0; i < material->num_uniforms; ++i) {
     const ShaderUniform* uniform = &material->uniforms[i];
-    set_uniform(material->shader, uniform);
+    set_uniform(shader, uniform);
   }
 }
diff --git a/gfx/src/scene/material_impl.h b/gfx/src/scene/material_impl.h
index c680ccf..a6aa95b 100644
--- a/gfx/src/scene/material_impl.h
+++ b/gfx/src/scene/material_impl.h
@@ -5,13 +5,12 @@
 typedef struct ShaderProgram ShaderProgram;
 
 typedef struct Material {
-  ShaderProgram* shader;
   ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
-  int num_uniforms;
+  int           num_uniforms;
 } Material;
 
 /// Activate the material.
 ///
 /// This activates the material's shader and configures the shader uniforms that
 /// are specific to the material.
-void material_activate(const Material* material);
+void material_activate(ShaderProgram* shader, const Material* material);
diff --git a/gfx/src/scene/mesh.c b/gfx/src/scene/mesh.c
index 722eae7..689105c 100644
--- a/gfx/src/scene/mesh.c
+++ b/gfx/src/scene/mesh.c
@@ -9,8 +9,10 @@ static void mesh_make(Mesh* mesh, const MeshDesc* desc) {
   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) {
diff --git a/gfx/src/scene/mesh_impl.h b/gfx/src/scene/mesh_impl.h
index 858b147..560b77e 100644
--- a/gfx/src/scene/mesh_impl.h
+++ b/gfx/src/scene/mesh_impl.h
@@ -5,6 +5,7 @@
 typedef struct Mesh {
   const Geometry* geometry;
   const Material* material;
+  ShaderProgram*  shader;
 } Mesh;
 
 // TODO: a mesh_render() that takes a transform, applies the material and the
diff --git a/gfx/src/util/scene.c b/gfx/src/util/scene.c
index 9511a71..dc97259 100644
--- a/gfx/src/util/scene.c
+++ b/gfx/src/util/scene.c
@@ -141,8 +141,9 @@ typedef struct MeshPermutation {
   union {
     struct {
       // Vertex attributes.
-      bool has_normals  : 1;
-      bool has_tangents : 1;
+      bool has_texcoords : 1;
+      bool has_normals   : 1;
+      bool has_tangents  : 1;
       // Textures.
       bool has_normal_map        : 1;
       bool has_occlusion_texture : 1;
@@ -282,36 +283,31 @@ cleanup:
   return 0;
 }
 
-/// Load all textures from the glTF scene.
+/// Lazily load all textures from the glTF scene.
 ///
-/// Return an array of Textures such that the index of each glTF texture in the
-/// original array matches the same Texture in the resulting array.
+/// Colour textures like albedo are in sRGB colour space. Non-colour textures
+/// like normal maps are in linear space (e.g. DamagedHelmet sample). Since we
+/// don't know how the texture is going to be used at this point, we can't tell
+/// what colour space it should be loaded in (ideally this would be part of the
+/// image file format, but not all formats specify colour space.) Therefore, we
+/// load the textures lazily and don't actually commit them to GPU memory until
+/// we know their colour space when loading glTF materials.
 ///
-/// Most textures are in sRGB colour space. One exception is normal maps, which
-/// are typically authored in linear space (e.g. DamagedHelmet sample). Since
-/// we don't know what colour space we should use at this point, we load the
-/// textures lazily and don't actually commit them to GPU memory until we know
-/// their colour space.
+/// Return an array of LoadTextureCmds such that the index of each cmd matches
+/// the index of each glTF texture in the scene. Also return the number of
+/// textures.
 ///
-/// This function returns an array of Texture objects, all of which are null due
-/// to lazy loading. It also returns an array of LoadTextureCmd which describes
-/// how each Texture in the first array should be loaded.
-static Texture** load_textures(
+/// Return true on success (all textures processed or no textures in the
+/// scene), false otherwise.
+static bool load_textures_lazy(
     const cgltf_data* data, RenderBackend* render_backend,
     const char* directory, LoadTextureCmd** load_texture_cmds,
     cgltf_size* num_textures) {
   assert(data);
   assert(render_backend);
+  assert(load_texture_cmds);
   assert(num_textures);
 
-  Texture** textures = 0;
-  *load_texture_cmds = 0;
-
-  textures = calloc(data->textures_count, sizeof(Texture*));
-  if (!textures) {
-    goto cleanup;
-  }
-
   *load_texture_cmds = calloc(data->textures_count, sizeof(LoadTextureCmd));
   if (!*load_texture_cmds) {
     goto cleanup;
@@ -374,29 +370,21 @@ static Texture** load_textures(
   }
 
   *num_textures = data->textures_count;
-  return textures;
+  return true;
 
 cleanup:
-  if (textures) {
-    for (cgltf_size i = 0; i < data->textures_count; ++i) {
-      if (textures[i]) {
-        gfx_destroy_texture(render_backend, &textures[i]);
-      }
-    }
-    free(textures);
-  }
   if (*load_texture_cmds) {
     free(*load_texture_cmds);
   }
   *num_textures = 0;
-  return 0;
+  return false;
 }
 
 /// Load a texture uniform.
 ///
 /// This determines a texture's colour space based on its intended use, loads
 /// the texture, and then defines the sampler shader uniform.
-static bool load_texture_uniform(
+static bool load_texture_and_uniform(
     const cgltf_data* data, RenderBackend* render_backend,
     const cgltf_texture_view* texture_view, TextureType texture_type,
     Texture** textures, LoadTextureCmd* load_texture_cmds, int* next_uniform,
@@ -412,24 +400,31 @@ static bool load_texture_uniform(
   const size_t texture_index = texture_view->texture - data->textures;
   assert(texture_index < data->textures_count);
 
-  LoadTextureCmd* cmd = &load_texture_cmds[texture_index];
-  if (texture_type == NormalMap) {
-    cmd->colour_space = LinearColourSpace;
-  }
-
-  LOGD(
-      "Load texture: %s (mipmaps: %d, filtering: %d)",
-      mstring_cstring(&cmd->data.texture.filepath), cmd->mipmaps,
-      cmd->filtering);
-
-  textures[texture_index] = gfx_load_texture(render_backend, cmd);
+  // Here we are assuming that if a texture is re-used, it is re-used with the
+  // same texture view. This should be fine because, e.g., a normal map would
+  // not be used as albedo and vice versa.
   if (!textures[texture_index]) {
-    gfx_prepend_error(
-        "Failed to load texture: %s",
-        mstring_cstring(&cmd->data.texture.filepath));
-    return false;
+    LoadTextureCmd* cmd = &load_texture_cmds[texture_index];
+    // TODO: Check for colour textures and default to LinearColourSpace instead.
+    if (texture_type == NormalMap) {
+      cmd->colour_space = LinearColourSpace;
+    }
+
+    LOGD(
+        "Load texture: %s (mipmaps: %d, filtering: %d)",
+        mstring_cstring(&cmd->data.texture.filepath), cmd->mipmaps,
+        cmd->filtering);
+
+    textures[texture_index] = gfx_load_texture(render_backend, cmd);
+    if (!textures[texture_index]) {
+      gfx_prepend_error(
+          "Failed to load texture: %s",
+          mstring_cstring(&cmd->data.texture.filepath));
+      return false;
+    }
   }
 
+  assert(*next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
   desc->uniforms[(*next_uniform)++] = (ShaderUniform){
       .name          = sstring_make(TextureUniformName(texture_type)),
       .type          = UniformTexture,
@@ -440,97 +435,102 @@ static bool load_texture_uniform(
 
 /// Load all materials from the glTF scene.
 ///
-/// Return an array of Materials such that the index of each glTF material in
-/// the original array matches the same Material in the resulting array.
+/// Return an array of Materials such that the index of each descriptor matches
+/// the index of each glTF material in the scene. Also return the number of
+/// materials and the textures used by them.
 static Material** load_materials(
     const cgltf_data* data, RenderBackend* render_backend,
-    ShaderProgram* shader, Texture** textures,
-    LoadTextureCmd* load_texture_cmds, cgltf_size* num_materials) {
+    LoadTextureCmd* load_texture_cmds, Texture*** textures,
+    cgltf_size* num_materials) {
   assert(data);
   assert(render_backend);
-  assert(shader);
-  assert(textures);
   assert(load_texture_cmds);
+  assert(textures);
   assert(num_materials);
 
-  Material** materials = 0;
-
-  materials = calloc(data->materials_count, sizeof(Material*));
+  Material** materials = calloc(data->materials_count, sizeof(Material*));
   if (!materials) {
     goto cleanup;
   }
 
+  *textures = calloc(data->textures_count, sizeof(Texture*));
+  if (!*textures) {
+    goto cleanup;
+  }
+
   for (cgltf_size i = 0; i < data->materials_count; ++i) {
     const cgltf_material* mat = &data->materials[i];
 
     int          next_uniform = 0;
-    MaterialDesc desc         = (MaterialDesc){.shader = shader};
+    MaterialDesc desc         = {0};
 
     // TODO: emissive texture/factor and other material parameters.
     if (mat->has_pbr_metallic_roughness) {
       const cgltf_pbr_metallic_roughness* pbr = &mat->pbr_metallic_roughness;
 
-      assert(next_uniform + 3 < GFX_MAX_UNIFORMS_PER_MATERIAL);
-
+      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
       desc.uniforms[next_uniform++] = (ShaderUniform){
           .name       = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
           .type       = UniformVec4,
           .value.vec4 = vec4_from_array(pbr->base_color_factor)};
 
+      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
       desc.uniforms[next_uniform++] = (ShaderUniform){
           .name         = sstring_make(UNIFORM_METALLIC_FACTOR),
           .type         = UniformFloat,
           .value.scalar = pbr->metallic_factor};
 
+      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
       desc.uniforms[next_uniform++] = (ShaderUniform){
           .name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
           .type         = UniformFloat,
           .value.scalar = pbr->roughness_factor};
 
+      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
+      desc.uniforms[next_uniform++] = (ShaderUniform){
+          .name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
+          .type       = UniformVec3,
+          .value.vec3 = vec3_from_array(mat->emissive_factor)};
+
       if (pbr->base_color_texture.texture) {
-        if (!load_texture_uniform(
+        if (!load_texture_and_uniform(
                 data, render_backend, &pbr->base_color_texture,
-                BaseColorTexture, textures, load_texture_cmds, &next_uniform,
+                BaseColorTexture, *textures, load_texture_cmds, &next_uniform,
                 &desc)) {
           goto cleanup;
         }
       }
 
       if (pbr->metallic_roughness_texture.texture) {
-        if (!load_texture_uniform(
+        if (!load_texture_and_uniform(
                 data, render_backend, &pbr->metallic_roughness_texture,
-                MetallicRoughnessTexture, textures, load_texture_cmds,
+                MetallicRoughnessTexture, *textures, load_texture_cmds,
                 &next_uniform, &desc)) {
           goto cleanup;
         }
       }
     }
 
-    desc.uniforms[next_uniform++] = (ShaderUniform){
-        .name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
-        .type       = UniformVec3,
-        .value.vec3 = vec3_from_array(mat->emissive_factor)};
-
     if (mat->emissive_texture.texture) {
-      if (!load_texture_uniform(
+      if (!load_texture_and_uniform(
               data, render_backend, &mat->emissive_texture, EmissiveTexture,
-              textures, load_texture_cmds, &next_uniform, &desc)) {
+              *textures, load_texture_cmds, &next_uniform, &desc)) {
         goto cleanup;
       }
     }
 
     if (mat->occlusion_texture.texture) {
-      if (!load_texture_uniform(
+      if (!load_texture_and_uniform(
               data, render_backend, &mat->occlusion_texture,
-              AmbientOcclusionTexture, textures, load_texture_cmds,
+              AmbientOcclusionTexture, *textures, load_texture_cmds,
               &next_uniform, &desc)) {
         goto cleanup;
       }
     }
 
     if (mat->normal_texture.texture) {
-      if (!load_texture_uniform(
-              data, render_backend, &mat->normal_texture, NormalMap, textures,
+      if (!load_texture_and_uniform(
+              data, render_backend, &mat->normal_texture, NormalMap, *textures,
               load_texture_cmds, &next_uniform, &desc)) {
         goto cleanup;
       }
@@ -557,28 +557,25 @@ cleanup:
     }
     free(materials);
   }
+  if (*textures) {
+    for (cgltf_size i = 0; i < data->textures_count; ++i) {
+      if ((*textures)[i]) {
+        gfx_destroy_texture(render_backend, &(*textures)[i]);
+      }
+    }
+    free(*textures);
+    *textures = 0;
+  }
   *num_materials = 0;
   return 0;
 }
 
-/// Configures the MeshPermutation based on the given material.
-static void configure_material_permutation(
-    MeshPermutation* perm, cgltf_material* material) {
-  assert(perm);
-  assert(material);
-
-  perm->has_normal_map        = material->normal_texture.texture != 0;
-  perm->has_occlusion_texture = material->occlusion_texture.texture != 0;
-  perm->has_emissive_texture  = material->emissive_texture.texture != 0;
-}
-
 /// Load all meshes from the glTF scene.
 static SceneObject** load_meshes(
     const cgltf_data* data, Gfx* gfx, Buffer** buffers,
-    Buffer** tangent_buffers, Material** materials,
-    const cgltfTangentBuffer* cgltf_tangent_buffers,
-    cgltf_size num_tangent_buffers, Geometry*** geometries, Mesh*** meshes,
-    MeshPermutation** mesh_permutations, cgltf_size* num_geometries,
+    Buffer** tangent_buffers, const cgltfTangentBuffer* cgltf_tangent_buffers,
+    cgltf_size num_tangent_buffers, Material** materials, ShaderProgram* shader,
+    Geometry*** geometries, Mesh*** meshes, cgltf_size* num_geometries,
     cgltf_size* num_meshes, cgltf_size* num_scene_objects) {
   // Walk through the mesh primitives to create Meshes. A GLTF mesh primitive
   // has a material (Mesh) and vertex data (Geometry). A GLTF mesh maps to
@@ -594,9 +591,9 @@ static SceneObject** load_meshes(
   assert(gfx);
   assert(buffers);
   assert(materials);
+  assert(shader);
   assert(geometries);
   assert(meshes);
-  assert(mesh_permutations);
   assert(num_geometries);
   assert(num_meshes);
   assert(num_scene_objects);
@@ -618,10 +615,6 @@ static SceneObject** load_meshes(
   if (!*meshes) {
     goto cleanup;
   }
-  *mesh_permutations = calloc(primitive_count, sizeof(MeshPermutation));
-  if (!*mesh_permutations) {
-    goto cleanup;
-  }
   SceneObject** objects = calloc(data->meshes_count, sizeof(SceneObject*));
   if (!objects) {
     goto cleanup;
@@ -642,7 +635,12 @@ static SceneObject** load_meshes(
     for (cgltf_size p = 0; p < mesh->primitives_count; ++p) {
       assert(next_mesh < primitive_count);
       const cgltf_primitive* prim = &mesh->primitives[p];
-      MeshPermutation*       perm = mesh_permutations[next_mesh];
+      const cgltf_material*  mat  = prim->material;
+
+      MeshPermutation perm       = {0};
+      perm.has_normal_map        = mat->normal_texture.texture != 0;
+      perm.has_occlusion_texture = mat->occlusion_texture.texture != 0;
+      perm.has_emissive_texture  = mat->emissive_texture.texture != 0;
 
       GeometryDesc geometry_desc = {
           .type = from_gltf_primitive_type(prim->type)};
@@ -693,18 +691,21 @@ static SceneObject** load_meshes(
             assert(false);
             break;
           }
+          // It is assumed that meshes have positions, so there is nothing to
+          // do for the mesh permutation in this case.
           break;
         }
         case cgltf_attribute_type_normal:
-          buffer_view_3d    = &geometry_desc.normals;
-          perm->has_normals = true;
+          buffer_view_3d   = &geometry_desc.normals;
+          perm.has_normals = true;
           break;
         case cgltf_attribute_type_tangent:
-          buffer_view_4d     = &geometry_desc.tangents;
-          perm->has_tangents = true;
+          buffer_view_4d    = &geometry_desc.tangents;
+          perm.has_tangents = true;
           break;
         case cgltf_attribute_type_texcoord:
-          buffer_view_2d = &geometry_desc.texcoords;
+          buffer_view_2d     = &geometry_desc.texcoords;
+          perm.has_texcoords = true;
           break;
         default:
           // Attribute ignored.
@@ -747,8 +748,8 @@ static SceneObject** load_meshes(
       }
 
       // Set the number of vertices in the geometry. Since a geometry can have
-      // either 2d or 3d positions but not both, here we can perform addition to
-      // compute the total number of vertices.
+      // 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));
@@ -771,17 +772,40 @@ static SceneObject** load_meshes(
             geometry_desc.num_verts);
       }
 
-      (*geometries)[next_mesh] =
-          gfx_make_geometry(render_backend, &geometry_desc);
-
       const cgltf_size material_index = prim->material - data->materials;
       assert(material_index < data->materials_count);
-      const Material* material = materials[material_index];
+      Material* material = materials[material_index];
+
+      // TODO: We need a better way to handle clean-up, specifically of
+      // materials. One is to add materials to a dynamically-allocated list or
+      // vector. Another is to expose some kind of scene purge that deletes the
+      // resources of a given scene. The latter would make clean-up much simpler
+      // in general, not just for materials.
+
+      (*geometries)[next_mesh] =
+          gfx_make_geometry(render_backend, &geometry_desc);
+      if (!(*geometries)[next_mesh]) {
+        goto cleanup;
+      }
 
-      configure_material_permutation(perm, prim->material);
+      // If the user specifies a custom shader, use that instead.
+      // else TODO: Build a shader based on permutation.
+      //
+      // TODO: We should cache shader permutations to re-use shader programs.
+      // Caching should not be done locally here because a caller may call
+      // gfx_load_scene() multiple times to load multiple scenes, and we want
+      // shader re-use across scenes too.
+      //
+      // On the other hand, caching materials is not necessary since, provided
+      // they can share shaders, the renderer can check later whether uniforms
+      // have the same values. Also, changing uniforms is much faster than
+      // swapping shaders, so shader caching is the most important thing here.
+      assert(shader);
 
       (*meshes)[next_mesh] = gfx_make_mesh(&(MeshDesc){
-          .geometry = (*geometries)[next_mesh], .material = material});
+          .geometry = (*geometries)[next_mesh],
+          .material = material,
+          .shader   = shader});
 
       gfx_add_object_mesh(objects[m], (*meshes)[next_mesh]);
 
@@ -814,10 +838,6 @@ cleanup:
     free(*meshes);
     *meshes = 0;
   }
-  if (*mesh_permutations) {
-    free(*mesh_permutations);
-    mesh_permutations = 0;
-  }
   if (objects) {
     for (cgltf_size i = 0; i < data->meshes_count; ++i) {
       if (objects[i]) {
@@ -939,8 +959,8 @@ static SceneNode** load_nodes(
     gfx_set_node_transform(nodes[n], &transform);
 
     // By default, set nodes as children of the root node. The second pass will
-    // properly set the parent of the relevant nodes, and leave the root node
-    // as the parent for top-level nodes.
+    // properly set the parent of the relevant nodes, and leave the root node as
+    // the parent for top-level nodes.
     gfx_set_node_parent(nodes[n], root_node);
   } // SceneNode.
 
@@ -1010,26 +1030,28 @@ static bool load_scene(
   LOGD("Filepath: %s", filepath);
   LOGD("Directory: %s", mstring_cstring(&directory));
 
-  Buffer**         buffers           = 0;
-  Buffer**         tangent_buffers   = 0;
-  Geometry**       geometries        = 0;
-  Material**       materials         = 0;
-  Mesh**           meshes            = 0;
-  SceneObject**    scene_objects     = 0;
-  SceneCamera**    scene_cameras     = 0;
-  SceneNode**      scene_nodes       = 0;
-  Texture**        textures          = 0;
-  LoadTextureCmd*  load_texture_cmds = 0;
-  MeshPermutation* mesh_permutations = 0;
-  cgltf_size       num_buffers       = 0;
-  cgltf_size       num_geometries    = 0;
-  cgltf_size       num_materials     = 0;
-  cgltf_size       num_meshes        = 0;
-  cgltf_size       num_scene_objects = 0;
-  cgltf_size       num_scene_cameras = 0;
-  cgltf_size       num_scene_nodes   = 0;
-  cgltf_size       num_textures      = 0;
-
+  Buffer**        buffers           = 0;
+  Buffer**        tangent_buffers   = 0;
+  Geometry**      geometries        = 0;
+  Material**      materials         = 0;
+  Mesh**          meshes            = 0;
+  SceneObject**   scene_objects     = 0;
+  SceneCamera**   scene_cameras     = 0;
+  SceneNode**     scene_nodes       = 0;
+  Texture**       textures          = 0;
+  LoadTextureCmd* load_texture_cmds = 0;
+  cgltf_size      num_buffers       = 0;
+  cgltf_size      num_geometries    = 0;
+  cgltf_size      num_materials     = 0;
+  cgltf_size      num_meshes        = 0;
+  cgltf_size      num_scene_objects = 0;
+  cgltf_size      num_scene_cameras = 0;
+  cgltf_size      num_scene_nodes   = 0;
+  cgltf_size      num_textures      = 0;
+
+  // TODO: Let this function handle all the cleanup. Let the other functions
+  // return pass/failure booleans and the arrays as in/out parameters. This way
+  // we do not need the individual functions to duplicate cleanup code.
   buffers = load_buffers(data, render_backend, &num_buffers);
   if (!buffers) {
     goto cleanup;
@@ -1043,23 +1065,21 @@ static bool load_scene(
     }
   }
 
-  textures = load_textures(
-      data, render_backend, mstring_cstring(&directory), &load_texture_cmds,
-      &num_textures);
-  if (!textures || !load_texture_cmds) {
+  if (!load_textures_lazy(
+          data, render_backend, mstring_cstring(&directory), &load_texture_cmds,
+          &num_textures)) {
     goto cleanup;
   }
 
   materials = load_materials(
-      data, render_backend, shader, textures, load_texture_cmds,
-      &num_materials);
+      data, render_backend, load_texture_cmds, &textures, &num_materials);
   if (!materials) {
     goto cleanup;
   }
 
   scene_objects = load_meshes(
-      data, gfx, buffers, tangent_buffers, materials, cgltf_tangent_buffers,
-      num_tangent_buffers, &geometries, &meshes, &mesh_permutations,
+      data, gfx, buffers, tangent_buffers, cgltf_tangent_buffers,
+      num_tangent_buffers, materials, shader, &geometries, &meshes,
       &num_geometries, &num_meshes, &num_scene_objects);
   if (!scene_objects) {
     goto cleanup;
@@ -1132,9 +1152,6 @@ cleanup:
   if (load_texture_cmds) {
     free(load_texture_cmds);
   }
-  if (mesh_permutations) {
-    free(mesh_permutations);
-  }
   return false;
 }
 
@@ -1143,7 +1160,6 @@ bool gfx_load_scene(
     const LoadSceneCmd* cmd) {
   assert(gfx);
   assert(root_node);
-  assert(shader);
   assert(cmd);
 
   bool success = false;
diff --git a/gfx/src/util/skyquad.c b/gfx/src/util/skyquad.c
index 51c250b..2461f8c 100644
--- a/gfx/src/util/skyquad.c
+++ b/gfx/src/util/skyquad.c
@@ -22,11 +22,11 @@ SceneObject* gfx_make_skyquad(Gfx* gfx, Scene* scene, const Texture* texture) {
   RenderBackend* render_backend = gfx_get_render_backend(gfx);
   assert(render_backend);
 
-  ShaderProgram* shader = 0;
-  Geometry* geometry = 0;
-  Material* material = 0;
-  Mesh* mesh = 0;
-  SceneObject* object = 0;
+  ShaderProgram* shader   = 0;
+  Geometry*      geometry = 0;
+  Material*      material = 0;
+  Mesh*          mesh     = 0;
+  SceneObject*   object   = 0;
 
   shader = gfx_make_skyquad_shader(render_backend);
   if (!shader) {
@@ -39,12 +39,12 @@ SceneObject* gfx_make_skyquad(Gfx* gfx, Scene* scene, const Texture* texture) {
   }
 
   MaterialDesc material_desc = (MaterialDesc){0};
-  material_desc.shader = shader;
-  material_desc.uniforms[0] = (ShaderUniform){.type = UniformTexture,
-                                              .value.texture = texture,
-                                              .name = sstring_make("Skyquad")};
+  material_desc.uniforms[0]  = (ShaderUniform){
+       .type          = UniformTexture,
+       .value.texture = texture,
+       .name          = sstring_make("Skyquad")};
   material_desc.num_uniforms = 1;
-  material = gfx_make_material(&material_desc);
+  material                   = gfx_make_material(&material_desc);
   if (!material) {
     goto cleanup;
   }
@@ -52,7 +52,8 @@ SceneObject* gfx_make_skyquad(Gfx* gfx, Scene* scene, const Texture* texture) {
   MeshDesc mesh_desc = (MeshDesc){0};
   mesh_desc.geometry = geometry;
   mesh_desc.material = material;
-  mesh = gfx_make_mesh(&mesh_desc);
+  mesh_desc.shader   = shader;
+  mesh               = gfx_make_mesh(&mesh_desc);
   if (!mesh) {
     goto cleanup;
   }
diff --git a/gltfview/src/game.c b/gltfview/src/game.c
index d7352d4..f2e5a88 100644
--- a/gltfview/src/game.c
+++ b/gltfview/src/game.c
@@ -24,7 +24,7 @@
 #include <unistd.h> // usleep; TODO Remove.
 
 // Paths to various scene files.
-static const char* BOX = "/assets/models/box.gltf";
+static const char* BOX     = "/assets/models/box.gltf";
 static const char* SUZANNE = "/assets/models/suzanne.gltf";
 static const char* SPONZA =
     "/assets/glTF-Sample-Models/2.0/Sponza/glTF/Sponza.gltf";
@@ -37,8 +37,8 @@ static const char* DAMAGED_HELMET =
 
 static const char* CLOUDS1_TEXTURE = "/assets/skybox/clouds1/clouds1_west.bmp";
 
-static ShaderProgram* load_shader(RenderBackend* render_backend,
-                                  const char* view_mode) {
+static ShaderProgram* load_shader(
+    RenderBackend* render_backend, const char* view_mode) {
   ShaderProgram* shader = 0;
   if (strcmp(view_mode, "debug") == 0) {
     shader = gfx_make_debug3d_shader(render_backend);
@@ -59,23 +59,24 @@ static Texture* load_environment_map(RenderBackend* render_backend) {
   return gfx_load_texture(
       render_backend,
       &(LoadTextureCmd){
-          .origin = TextureFromFile,
-          .type = LoadCubemap,
-          .colour_space = sRGB,
-          .filtering = NearestFiltering,
-          .mipmaps = false,
+          .origin                 = TextureFromFile,
+          .type                   = LoadCubemap,
+          .colour_space           = sRGB,
+          .filtering              = NearestFiltering,
+          .mipmaps                = false,
           .data.cubemap.filepaths = {
-              mstring_make("/assets/skybox/clouds1/clouds1_east.bmp"),
-              mstring_make("/assets/skybox/clouds1/clouds1_west.bmp"),
-              mstring_make("/assets/skybox/clouds1/clouds1_up.bmp"),
-              mstring_make("/assets/skybox/clouds1/clouds1_down.bmp"),
-              mstring_make("/assets/skybox/clouds1/clouds1_north.bmp"),
-              mstring_make("/assets/skybox/clouds1/clouds1_south.bmp")}});
+                                     mstring_make("/assets/skybox/clouds1/clouds1_east.bmp"),
+                                     mstring_make("/assets/skybox/clouds1/clouds1_west.bmp"),
+                                     mstring_make("/assets/skybox/clouds1/clouds1_up.bmp"),
+                                     mstring_make("/assets/skybox/clouds1/clouds1_down.bmp"),
+                                     mstring_make("/assets/skybox/clouds1/clouds1_north.bmp"),
+                                     mstring_make("/assets/skybox/clouds1/clouds1_south.bmp")}
+  });
 }
 
 /// Creates an object to render the skyquad in the background.
-static SceneNode* make_skyquad_object_node(Game* game,
-                                           const Texture* environment_map) {
+static SceneNode* make_skyquad_object_node(
+    Game* game, const Texture* environment_map) {
   assert(game);
 
   SceneObject* skyquad_object =
@@ -92,12 +93,12 @@ static SceneNode* make_skyquad_object_node(Game* game,
 }
 
 /// Creates an environment light.
-static SceneNode* make_environment_light(Game* game,
-                                         const Texture* environment_light) {
+static SceneNode* make_environment_light(
+    Game* game, const Texture* environment_light) {
   assert(game);
 
   Light* light = gfx_make_light(&(LightDesc){
-      .type = EnvironmentLightType,
+      .type  = EnvironmentLightType,
       .light = (EnvironmentLightDesc){.environment_map = environment_light}});
   if (!light) {
     return 0;
@@ -127,8 +128,8 @@ static bool load_skyquad(Game* game, SceneNode** node) {
 }
 
 /// Loads the 3D scene.
-static bool load_scene(Game* game, const char* scene_filepath,
-                       const char* view_mode) {
+static bool load_scene(
+    Game* game, const char* scene_filepath, const char* view_mode) {
   assert(game);
 
   game->camera = gfx_make_camera();
@@ -151,9 +152,10 @@ static bool load_scene(Game* game, const char* scene_filepath,
     return false;
   }
 
-  if (!gfx_load_scene(game->gfx, sky_node, shader,
-                      &(LoadSceneCmd){.origin = SceneFromFile,
-                                      .filepath = scene_filepath})) {
+  if (!gfx_load_scene(
+          game->gfx, sky_node, shader,
+          &(LoadSceneCmd){
+              .origin = SceneFromFile, .filepath = scene_filepath})) {
     return false;
   }
 
@@ -164,14 +166,14 @@ static bool load_scene(Game* game, const char* scene_filepath,
 static bool load_texture_debugger_scene(Game* game) {
   assert(game);
 
-  Texture* texture =
-      gfx_load_texture(game->render_backend,
-                       &(LoadTextureCmd){.origin = TextureFromFile,
-                                         .type = LoadTexture,
-                                         .filtering = LinearFiltering,
-                                         .mipmaps = false,
-                                         .data.texture.filepath =
-                                             mstring_make(CLOUDS1_TEXTURE)});
+  Texture* texture = gfx_load_texture(
+      game->render_backend,
+      &(LoadTextureCmd){
+          .origin                = TextureFromFile,
+          .type                  = LoadTexture,
+          .filtering             = LinearFiltering,
+          .mipmaps               = false,
+          .data.texture.filepath = mstring_make(CLOUDS1_TEXTURE)});
 
   game->camera = gfx_make_camera();
   if (!game->camera) {
@@ -191,12 +193,12 @@ static bool load_texture_debugger_scene(Game* game) {
   }
 
   MaterialDesc material_desc = (MaterialDesc){0};
-  material_desc.shader = shader;
-  material_desc.uniforms[0] = (ShaderUniform){.type = UniformTexture,
-                                              .value.texture = texture,
-                                              .name = sstring_make("Texture")};
+  material_desc.uniforms[0]  = (ShaderUniform){
+       .type          = UniformTexture,
+       .value.texture = texture,
+       .name          = sstring_make("Texture")};
   material_desc.num_uniforms = 1;
-  Material* material = gfx_make_material(&material_desc);
+  Material* material         = gfx_make_material(&material_desc);
   if (!material) {
     return false;
   }
@@ -204,7 +206,8 @@ static bool load_texture_debugger_scene(Game* game) {
   MeshDesc mesh_desc = (MeshDesc){0};
   mesh_desc.geometry = geometry;
   mesh_desc.material = material;
-  Mesh* mesh = gfx_make_mesh(&mesh_desc);
+  mesh_desc.shader   = shader;
+  Mesh* mesh         = gfx_make_mesh(&mesh_desc);
   if (!mesh) {
     return false;
   }
@@ -224,7 +227,7 @@ static bool load_texture_debugger_scene(Game* game) {
 
 bool game_new(Game* game, int argc, const char** argv) {
   // TODO: getopt() to implement proper argument parsing.
-  const char* view_mode = argc > 1 ? argv[1] : "";
+  const char* view_mode      = argc > 1 ? argv[1] : "";
   const char* scene_filepath = argc > 2 ? argv[2] : DEFAULT_SCENE_FILE;
 
   game->gfx = gfx_init();
@@ -233,7 +236,7 @@ bool game_new(Game* game, int argc, const char** argv) {
   }
 
   game->render_backend = gfx_get_render_backend(game->gfx);
-  game->renderer = gfx_get_renderer(game->gfx);
+  game->renderer       = gfx_get_renderer(game->gfx);
 
   game->scene = gfx_make_scene(game->gfx);
   if (!game->scene) {
@@ -270,26 +273,27 @@ void game_update(Game* game, double t, double dt) {
     game->elapsed -= 1.0;
   }
   Camera* camera = gfx_get_camera_camera(game->camera);
-  spatial3_orbit(&camera->spatial, vec3_make(0, 0, 0),
-                 /*radius=*/2,
-                 /*azimuth=*/t * 0.5, /*zenith=*/0);
+  spatial3_orbit(
+      &camera->spatial, vec3_make(0, 0, 0),
+      /*radius=*/2,
+      /*azimuth=*/t * 0.5, /*zenith=*/0);
   spatial3_lookat(&camera->spatial, vec3_make(0, 0, 0));
 }
 
 void game_render(const Game* game) {
-  gfx_render_scene(game->renderer, game->render_backend, game->scene,
-                   game->camera);
+  gfx_render_scene(
+      game->renderer, game->render_backend, game->scene, game->camera);
 }
 
 void game_set_viewport(Game* game, int width, int height) {
   gfx_set_viewport(game->render_backend, width, height);
 
-  const R fovy = 90 * TO_RAD;
-  const R aspect = (R)width / (R)height;
-  const R near = 0.1;
-  const R far = 1000;
+  const R    fovy       = 90 * TO_RAD;
+  const R    aspect     = (R)width / (R)height;
+  const R    near       = 0.1;
+  const R    far        = 1000;
   const mat4 projection = mat4_perspective(fovy, aspect, near, far);
 
-  Camera* camera = gfx_get_camera_camera(game->camera);
+  Camera* camera     = gfx_get_camera_camera(game->camera);
   camera->projection = projection;
 }