18 files changed, 440 insertions, 540 deletions

diff --git a/src/asset/model.c b/src/asset/model.c
index 402b2e1..0c57470 100644
--- a/src/asset/model.c
+++ b/src/asset/model.c
@@ -84,13 +84,12 @@
 #include "asset/texture.h"
 #include "gfx/core.h"
 #include "gfx/gfx.h"
+#include "gfx/llr/material.h"
+#include "gfx/llr/mesh.h"
 #include "gfx/scene/animation.h"
 #include "gfx/scene/camera.h"
-#include "gfx/scene/material.h"
-#include "gfx/scene/mesh.h"
 #include "gfx/scene/node.h"
 #include "gfx/scene/object.h"
-#include "gfx/scene/scene.h"
 #include "gfx/sizes.h"
 #include "gfx/util/shader.h"
 
diff --git a/src/core/core.c b/src/core/core.c
index 90038c6..e1671ea 100644
--- a/src/core/core.c
+++ b/src/core/core.c
@@ -420,6 +420,10 @@ void gfx_destroy_shader_program(GfxCore* gfxcore, ShaderProgram** prog) {
     // Remove the shader program from the cache.
     ProgramCache*            cache = &gfxcore->program_cache;
     ShaderProgramCacheEntry* entry = find_program_cache_entry(cache, *prog);
+    // TODO: The following assertion is too restrictive. Clients can end up
+    //  re-using the same shader by virtue of the cache. The assertion assumes
+    //  that no two "different" clients use the same set of shaders. This can
+    //  be relaxed by reference-counting the shaders in the cache.
     assert(entry); // Must be there, shaders can't go untracked.
     mempool_free(cache, &entry);
 
diff --git a/src/gfx.c b/src/gfx.c
index cd2ac90..4291ae7 100644
--- a/src/gfx.c
+++ b/src/gfx.c
@@ -2,20 +2,20 @@
 
 #include "asset/asset_cache.h"
 #include "core/core_impl.h"
+#include "llr/llr_impl.h"
 #include "renderer/imm_renderer_impl.h"
 #include "renderer/renderer_impl.h"
 #include "scene/scene_memory.h"
 
-#include <log/log.h>
-
 #include <assert.h>
 #include <stdlib.h>
 
 typedef struct Gfx {
   AssetCache  asset_cache;
   GfxCore     gfxcore;
-  Renderer    renderer;
+  LLR         llr;
   ImmRenderer imm_renderer;
+  Renderer    renderer;
 } Gfx;
 
 Gfx* gfx_init(void) {
@@ -24,16 +24,20 @@ Gfx* gfx_init(void) {
     return 0;
   }
   gfx_init_gfxcore(&gfx->gfxcore);
-  if (!renderer_make(&gfx->renderer, &gfx->gfxcore)) {
+  if (!gfx_llr_make(&gfx->llr, &gfx->gfxcore)) {
     gfx_destroy(&gfx);
     return 0;
   }
-  if (!imm_renderer_make(&gfx->imm_renderer, &gfx->gfxcore)) {
+  if (!gfx_imm_make(&gfx->imm_renderer, &gfx->gfxcore, &gfx->llr)) {
     // TODO: Add error logs to the initialization failure cases here and inside
     // the renderers.
     gfx_destroy(&gfx);
     return 0;
   }
+  if (!gfx_renderer_make(&gfx->renderer, &gfx->llr, &gfx->gfxcore)) {
+    gfx_destroy(&gfx);
+    return 0;
+  }
   gfx_init_asset_cache(&gfx->asset_cache);
   scene_mem_init();
   return gfx;
@@ -45,8 +49,9 @@ void gfx_destroy(Gfx** gfx) {
   }
   scene_mem_destroy();
   gfx_destroy_asset_cache(&(*gfx)->asset_cache);
-  renderer_destroy(&(*gfx)->renderer);
-  imm_renderer_destroy(&(*gfx)->imm_renderer);
+  gfx_renderer_destroy(&(*gfx)->renderer);
+  gfx_imm_destroy(&(*gfx)->imm_renderer);
+  gfx_llr_destroy(&(*gfx)->llr);
   gfx_del_gfxcore(&(*gfx)->gfxcore);
   free(*gfx);
   *gfx = 0;
@@ -67,6 +72,11 @@ ImmRenderer* gfx_get_imm_renderer(Gfx* gfx) {
   return &gfx->imm_renderer;
 }
 
+LLR* gfx_get_llr(Gfx* gfx) {
+  assert(gfx);
+  return &gfx->llr;
+}
+
 AssetCache* gfx_get_asset_cache(Gfx* gfx) {
   assert(gfx);
   return &gfx->asset_cache;
diff --git a/src/llr/light.c b/src/llr/light.c
index 168f16a..1d1c40d 100644
--- a/src/llr/light.c
+++ b/src/llr/light.c
@@ -1,4 +1,4 @@
-#include "../scene/light_impl.h"
+#include "light_impl.h"
 
 #include "../scene/node_impl.h"
 #include "../scene/scene_memory.h"
diff --git a/src/llr/llr.c b/src/llr/llr.c
index 62a7c30..74cfaed 100644
--- a/src/llr/llr.c
+++ b/src/llr/llr.c
@@ -1,17 +1,14 @@
-#include "imm_renderer_impl.h"
 #include "light_impl.h"
+#include "llr_impl.h"
 #include "mesh_impl.h"
 
+#include "llr/material_impl.h"
 #include "scene/animation_impl.h"
 
 #include <gfx/core.h>
 #include <gfx/util/ibl.h>
-#include <gfx/util/shader.h>
-
-#include <math/aabb3.h>
 
 #include <cassert.h>
-#include <string.h> // memcpy
 
 static const int IRRADIANCE_MAP_WIDTH               = 1024;
 static const int IRRADIANCE_MAP_HEIGHT              = 1024;
@@ -21,7 +18,7 @@ static const int BRDF_INTEGRATION_MAP_WIDTH         = 512;
 static const int BRDF_INTEGRATION_MAP_HEIGHT        = 512;
 
 /// Initialize renderer state for IBL.
-static bool init_ibl(ImmRenderer* renderer) {
+static bool init_ibl(LLR* renderer) {
   assert(renderer);
   assert(!renderer->ibl);
   assert(!renderer->brdf_integration_map);
@@ -44,8 +41,7 @@ static bool init_ibl(ImmRenderer* renderer) {
 //
 /// Compute irradiance and prefiltered environment maps for the light if they
 /// have not been already computed.
-static bool set_up_environment_light(
-    ImmRenderer* renderer, EnvironmentLight* light) {
+static bool set_up_environment_light(LLR* renderer, EnvironmentLight* light) {
   assert(renderer);
   assert(light);
   assert(renderer->ibl);
@@ -92,7 +88,7 @@ cleanup:
   return false;
 }
 
-static void configure_light(ImmRenderer* renderer, Light* light) {
+static void configure_light(LLR* renderer, Light* light) {
   assert(renderer);
   assert(light);
 
@@ -127,20 +123,35 @@ static void configure_light(ImmRenderer* renderer, Light* light) {
   }
 }
 
-static void configure_state(ImmRenderer* renderer) {
+static void configure_state(LLR* renderer) {
   assert(renderer);
 
   // Check if anything changed first so that we don't call gfx_apply_uniforms()
   // unnecessarily.
-  const bool anything_changed =
-      renderer->camera_changed || renderer->lights_changed ||
-      renderer->skeleton_changed || renderer->shader_changed;
-  if (!anything_changed) {
+  const bool nothing_changed = (renderer->changed_flags == 0);
+  if (nothing_changed) {
+    return;
+  }
+  // Setting a null shader is also allowed, in which case there is nothing to
+  // configure.
+  if (renderer->shader == 0) {
+    renderer->shader_changed = false;
     return;
   }
 
   // For convenience.
   ShaderProgram* const shader = renderer->shader;
+  const mat4* const    model = &renderer->matrix_stack[renderer->stack_pointer];
+
+  // TODO: Check to see which ones the shader actually uses and avoid
+  //  computing the unnecessary matrices.
+
+  if (renderer->matrix_changed || renderer->shader_changed) {
+    renderer->matrix_changed = false;
+
+    gfx_set_mat4_uniform(shader, "Model", model);
+    gfx_set_mat4_uniform(shader, "ModelMatrix", model);
+  }
 
   // TODO: camera_changed is not set anywhere. Need to think how imm primitive
   //  rendering and imm mesh rendering work together. We could treat imm
@@ -150,20 +161,19 @@ static void configure_state(ImmRenderer* renderer) {
 
     // Set all supported camera-related uniforms. Shaders can choose which ones
     // to use.
-    // TODO: Check to see which ones the shader actually uses and avoid
-    //  computing the unnecessary matrices.
-    const mat4* const model = &renderer->matrix_stack[renderer->stack_pointer];
-    const mat4        modelview = mat4_mul(renderer->view, *model);
+    const mat4 modelview = mat4_mul(renderer->view, *model);
     const mat4 view_proj = mat4_mul(renderer->projection, renderer->view);
     const mat4 mvp       = mat4_mul(renderer->projection, modelview);
 
-    gfx_set_mat4_uniform(shader, "ModelMatrix", model);
     gfx_set_mat4_uniform(shader, "Modelview", &modelview);
     gfx_set_mat4_uniform(shader, "View", &renderer->view);
     gfx_set_mat4_uniform(shader, "Projection", &renderer->projection);
     gfx_set_mat4_uniform(shader, "ViewProjection", &view_proj);
     gfx_set_mat4_uniform(shader, "MVP", &mvp);
     gfx_set_vec3_uniform(shader, "CameraPosition", renderer->camera_position);
+    gfx_set_mat4_uniform(shader, "CameraRotation", &renderer->camera_rotation);
+    gfx_set_float_uniform(shader, "Fovy", renderer->fovy);
+    gfx_set_float_uniform(shader, "Aspect", renderer->aspect);
   }
 
   if (renderer->lights_changed || renderer->shader_changed) {
@@ -181,9 +191,11 @@ static void configure_state(ImmRenderer* renderer) {
   if (renderer->skeleton_changed || renderer->shader_changed) {
     renderer->skeleton_changed = false;
 
-    gfx_set_mat4_array_uniform(
-        shader, "JointMatrices", renderer->joint_matrices,
-        renderer->num_joints);
+    if (renderer->num_joints > 0) {
+      gfx_set_mat4_array_uniform(
+          shader, "JointMatrices", renderer->joint_matrices,
+          renderer->num_joints);
+    }
   }
 
   if (renderer->shader_changed) {
@@ -195,58 +207,29 @@ static void configure_state(ImmRenderer* renderer) {
   gfx_apply_uniforms(renderer->shader);
 }
 
-bool gfx_imm_make(ImmRenderer* renderer, GfxCore* gfxcore) {
+bool gfx_llr_make(LLR* renderer, GfxCore* gfxcore) {
   assert(renderer);
   assert(gfxcore);
 
-  const size_t num_triangle_verts = IMM_MAX_NUM_TRIANGLES * 3;
-
   renderer->gfxcore = gfxcore;
-
-  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)}});
-  if (!renderer->triangles) {
-    goto cleanup;
-  }
-
-  renderer->imm_shader = gfx_make_immediate_mode_shader(gfxcore);
-  if (!renderer->imm_shader) {
-    goto cleanup;
-  }
-  renderer->shader = renderer->imm_shader;
-
   if (!init_ibl(renderer)) {
     goto cleanup;
   }
-
-  gfx_imm_load_identity(renderer);
-  gfx_imm_set_colour(renderer, vec4_make(0.0f, 0.0f, 0.0f, 1.0f));
-
+  gfx_llr_load_identity(renderer);
+  renderer->view            = mat4_id();
+  renderer->projection      = mat4_id();
+  renderer->camera_rotation = mat4_id();
   return true;
 
 cleanup:
-  gfx_imm_destroy(renderer);
+  gfx_llr_destroy(renderer);
   return false;
 }
 
-void gfx_imm_destroy(ImmRenderer* renderer) {
+void gfx_llr_destroy(LLR* renderer) {
   assert(renderer);
   assert(renderer->gfxcore);
 
-  if (renderer->triangles) {
-    gfx_destroy_geometry(renderer->gfxcore, &renderer->triangles);
-    // TODO: Could also destroy the geometry's buffers here.
-  }
-
-  if (renderer->imm_shader) {
-    gfx_destroy_shader_program(renderer->gfxcore, &renderer->imm_shader);
-  }
-
   if (renderer->brdf_integration_map) {
     gfx_destroy_texture(renderer->gfxcore, &renderer->brdf_integration_map);
   }
@@ -257,43 +240,9 @@ void gfx_imm_destroy(ImmRenderer* renderer) {
   }
 }
 
-void gfx_imm_flush(ImmRenderer* renderer) {
-  assert(renderer);
-
-  if (renderer->num_triangle_verts > 0) {
-    configure_state(renderer);
-
-    gfx_update_geometry(
-        renderer->triangles,
-        &(GeometryDesc){
-            .num_verts   = renderer->num_triangle_verts,
-            .positions3d = (BufferView3d){
-                                          .data       = renderer->triangle_verts,
-                                          .size_bytes = renderer->num_triangle_verts * sizeof(vec3)}
-    });
-
-    gfx_apply_uniforms(renderer->shader);
-    gfx_render_geometry(renderer->triangles);
-
-    renderer->num_triangle_verts = 0;
-  }
-}
-
-void gfx_imm_set_shader(ImmRenderer* renderer, ShaderProgram* shader) {
+void gfx_llr_set_shader(LLR* renderer, ShaderProgram* shader) {
   assert(renderer);
-  assert(shader);
-
-  // TODO: It would probably be best to make the imm renderer work in terms of a
-  //  new LLR renderer. Otherwise we need to constantly flush stuff everywhere
-  //  "just in case". This would still allow the imm to render meshes with
-  //  lighting etc. We just need to create an actual Mesh out of the 'triangles'
-  //  Geometry that imm currently has. The change would greatly simplify the
-  //  implementation of this otherwise coupled LLR-IMM renderer.
-  //  Need to decide where to put the matrix stack manipulation. Might be good
-  //  to move to the LLR. (Currently, manipulating the stack causes an imm
-  //  flush, but that's because we have coupled imm with stack manipulation,
-  //  which the new design seems like would address.)
-  gfx_imm_flush(renderer);
+  // null shader is allowed, so do not assert it.
 
   // It's important to not set shader_changed unnecessarily, since that would
   // re-trigger the setting of uniforms.
@@ -303,36 +252,17 @@ void gfx_imm_set_shader(ImmRenderer* renderer, ShaderProgram* shader) {
   }
 }
 
-void gfx_imm_start(ImmRenderer* renderer) {
-  assert(renderer);
-
-  // Shader uniforms are applied lazily.
-  // TODO: In the event that gfx_activate_shader_program() activates uniforms
-  //  automatically for convenience, call an overload here that doesn't do so.
-  gfx_activate_shader_program(renderer->shader);
-}
-
-void gfx_imm_end(ImmRenderer* renderer) {
-  assert(renderer);
-
-  gfx_imm_flush(renderer);
-  gfx_deactivate_shader_program(renderer->shader);
-
-  // TODO: Should we clear all of the render state here as well? At least set
-  //  the 'changed' variables to false, for example.
-}
-
-void gfx_imm_push_light(ImmRenderer* renderer, Light* light) {
+void gfx_llr_push_light(LLR* renderer, Light* light) {
   assert(renderer);
   assert(light);
   assert(renderer->num_lights >= 0);
-  ASSERT(renderer->num_lights < IMM_MAX_NUM_LIGHTS);
+  ASSERT(renderer->num_lights < GFX_LLR_MAX_NUM_LIGHTS);
 
   renderer->lights[renderer->num_lights++] = light;
   renderer->lights_changed                 = true;
 }
 
-void gfx_imm_pop_light(ImmRenderer* renderer) {
+void gfx_llr_pop_light(LLR* renderer) {
   assert(renderer);
   ASSERT(renderer->num_lights > 0);
 
@@ -340,8 +270,8 @@ void gfx_imm_pop_light(ImmRenderer* renderer) {
   renderer->lights_changed                 = true;
 }
 
-void gfx_imm_set_skeleton(
-    ImmRenderer* renderer, const Anima* anima, const Skeleton* skeleton) {
+void gfx_llr_set_skeleton(
+    LLR* renderer, const Anima* anima, const Skeleton* skeleton) {
   assert(renderer);
   assert(anima);
   assert(skeleton);
@@ -356,150 +286,73 @@ void gfx_imm_set_skeleton(
   renderer->skeleton_changed = true;
 }
 
-void gfx_imm_unset_skeleton(ImmRenderer* renderer) {
+void gfx_llr_clear_skeleton(LLR* renderer) {
   assert(renderer);
 
   renderer->num_joints       = 0;
   renderer->skeleton_changed = true;
 }
 
-void gfx_imm_render_mesh(ImmRenderer* renderer, const Mesh* mesh) {
+void gfx_llr_set_camera(LLR* renderer, const Camera* camera) {
   assert(renderer);
-  assert(mesh);
-  assert(mesh->geometry);
-  assert(mesh->material);
 
-  configure_state(renderer);
-  gfx_render_geometry(mesh->geometry);
-}
-
-void gfx_imm_draw_triangles(
-    ImmRenderer* renderer, const vec3 verts[], size_t num_triangles) {
-  assert(renderer);
-  assert(verts);
-  const size_t new_verts = num_triangles * 3;
-  assert(
-      renderer->num_triangle_verts + new_verts < (IMM_MAX_NUM_TRIANGLES * 3));
-
-  memcpy(
-      renderer->triangle_verts + renderer->num_triangle_verts, verts,
-      new_verts * sizeof(vec3));
-
-  renderer->num_triangle_verts += new_verts;
-}
-
-void gfx_imm_draw_triangle(ImmRenderer* renderer, const vec3 verts[3]) {
-  gfx_imm_draw_triangles(renderer, verts, 1);
+  renderer->camera_position = camera->spatial.p;
+  renderer->camera_rotation =
+      mat4_rotation(spatial3_transform(&camera->spatial));
+  renderer->view       = spatial3_inverse_transform(&camera->spatial);
+  renderer->projection = camera->projection;
+  // Assuming a perspective matrix.
+  renderer->fovy = (R)atan(1.0 / (mat4_at(camera->projection, 1, 1))) * 2;
+  renderer->camera_changed = true;
 }
 
-void gfx_imm_draw_aabb2(ImmRenderer* renderer, aabb2 box) {
+void gfx_llr_set_aspect(LLR* renderer, float aspect) {
   assert(renderer);
 
-  // clang-format off
-  const vec3 verts[4] = {
-      vec3_make(box.min.x, box.min.y, 0),    // 3 ---- 2
-      vec3_make(box.max.x, box.min.y, 0),    // |      |
-      vec3_make(box.max.x, box.max.y, 0),    // |      |
-      vec3_make(box.min.x, box.max.y, 0)};   // 0 ---- 1
-  // clang-format on
-
-#define tri(i0, i1, i2) verts[i0], verts[i1], verts[i2]
-  const vec3 tris[6] = {tri(0, 1, 2), tri(0, 2, 3)};
-#undef tri
-
-  gfx_imm_draw_triangles(renderer, tris, 2);
+  renderer->aspect         = aspect;
+  renderer->camera_changed = true;
 }
 
-void gfx_imm_draw_aabb3(ImmRenderer* renderer, aabb3 box) {
+void gfx_llr_render_geometry(LLR* renderer, const Geometry* geometry) {
   assert(renderer);
+  assert(geometry);
 
-  // clang-format off
-  const vec3 vertices[8] = {
-      vec3_make(box.min.x, box.min.y, box.max.z), //     7 ----- 6
-      vec3_make(box.max.x, box.min.y, box.max.z), //    /       /|
-      vec3_make(box.max.x, box.max.y, box.max.z), //   3 ----- 2 |
-      vec3_make(box.min.x, box.max.y, box.max.z), //   |       | |
-      vec3_make(box.min.x, box.min.y, box.min.z), //   | 4 ----- 5
-      vec3_make(box.max.x, box.min.y, box.min.z), //   |/      |/
-      vec3_make(box.max.x, box.max.y, box.min.z), //   0 ----- 1
-      vec3_make(box.min.x, box.max.y, box.min.z)};
-  // clang-format on
-
-  gfx_imm_draw_box3(renderer, vertices);
-}
-
-void gfx_imm_draw_box3(ImmRenderer* renderer, const vec3 vertices[8]) {
-  assert(renderer);
-  assert(vertices);
-
-  //     7 ----- 6
-  //    /       /|
-  //   3 ----- 2 |
-  //   |       | |
-  //   | 4 ----- 5
-  //   |/      |/
-  //   0 ----- 1
-
-#define tri(i0, i1, i2) vertices[i0], vertices[i1], vertices[i2]
-  const vec3 tris[36] = {
-      // Front.
-      tri(0, 1, 2), tri(0, 2, 3),
-      // Right.
-      tri(1, 5, 6), tri(1, 6, 2),
-      // Back.
-      tri(5, 4, 7), tri(5, 7, 6),
-      // Left.
-      tri(4, 0, 03), tri(4, 3, 7),
-      // Top.
-      tri(3, 2, 6), tri(3, 6, 7),
-      // Bottom.
-      tri(0, 4, 5), tri(0, 5, 1)};
-
-  gfx_imm_draw_triangles(renderer, tris, 12);
+  configure_state(renderer);
+  gfx_render_geometry(geometry);
 }
 
-void gfx_imm_set_colour(ImmRenderer* renderer, vec4 colour) {
+void gfx_llr_render_mesh(LLR* renderer, const Mesh* mesh) {
   assert(renderer);
   assert(renderer->shader);
+  assert(mesh);
+  assert(mesh->geometry);
+  assert(mesh->material);
 
-  gfx_imm_flush(renderer);
-
-  gfx_set_vec4_uniform(renderer->shader, "Colour", colour);
-}
-
-// Load the top of the matrix stack into the shader.
-static void update_shader_model_matrix(ImmRenderer* renderer) {
-  assert(renderer);
-
-  gfx_imm_flush(renderer);
-
-  gfx_set_mat4_uniform(
-      renderer->shader, "Model",
-      &renderer->matrix_stack[renderer->stack_pointer]);
+  gfx_material_activate(renderer->shader, mesh->material);
+  gfx_llr_render_geometry(renderer, mesh->geometry);
 }
 
-void gfx_imm_load_identity(ImmRenderer* renderer) {
+void gfx_llr_load_identity(LLR* renderer) {
   assert(renderer);
 
   renderer->matrix_stack[0] = mat4_id();
   renderer->stack_pointer   = 0;
-  update_shader_model_matrix(renderer);
+  renderer->matrix_changed  = true;
 }
 
-void gfx_imm_push_matrix(ImmRenderer* renderer, const mat4* matrix) {
+void gfx_llr_push_matrix(LLR* renderer, const mat4* matrix) {
   assert(renderer);
   assert(matrix);
   assert(renderer->stack_pointer >= 0);
-  ASSERT(renderer->stack_pointer < IMM_MAX_NUM_MATRICES);
+  ASSERT(renderer->stack_pointer < GFX_LLR_MAX_NUM_MATRICES);
 
   renderer->stack_pointer += 1;
   renderer->matrix_stack[renderer->stack_pointer] =
       mat4_mul(*matrix, renderer->matrix_stack[renderer->stack_pointer - 1]);
-
-  update_shader_model_matrix(renderer);
+  renderer->matrix_changed = true;
 }
 
-void gfx_imm_pop_matrix(ImmRenderer* renderer) {
+void gfx_llr_pop_matrix(LLR* renderer) {
   assert(renderer);
   ASSERT(renderer->stack_pointer > 0);
 
@@ -508,47 +361,21 @@ void gfx_imm_pop_matrix(ImmRenderer* renderer) {
       &renderer->matrix_stack[renderer->stack_pointer], 0,
       sizeof(renderer->matrix_stack[0]));
   renderer->stack_pointer -= 1;
-
-  update_shader_model_matrix(renderer);
+  renderer->matrix_changed = true;
 }
 
-void gfx_imm_translate(ImmRenderer* renderer, vec3 offset) {
+void gfx_llr_translate(LLR* renderer, vec3 offset) {
   assert(renderer);
 
   const mat4 mat = mat4_translate(offset);
-  gfx_imm_push_matrix(renderer, &mat);
+  gfx_llr_push_matrix(renderer, &mat);
 }
 
-void gfx_imm_set_model_matrix(ImmRenderer* renderer, const mat4* model) {
+void gfx_llr_set_model_matrix(LLR* renderer, const mat4* model) {
   assert(renderer);
   assert(model);
 
-  gfx_imm_flush(renderer);
-
   renderer->matrix_stack[0] = *model;
   renderer->stack_pointer   = 0;
-  update_shader_model_matrix(renderer);
-}
-
-void gfx_imm_set_camera(ImmRenderer* renderer, const Camera* camera) {
-  assert(renderer);
-  assert(renderer->shader);
-
-  gfx_imm_flush(renderer);
-
-  const mat4 view = spatial3_inverse_transform(&camera->spatial);
-  // const mat4 view_proj = mat4_mul(camera->projection, view);
-  // gfx_imm_set_view_projection_matrix(renderer, &view_proj);
-  renderer->view           = view;
-  renderer->projection     = camera->projection;
-  renderer->camera_changed = true;
+  renderer->matrix_changed  = true;
 }
-
-// void gfx_imm_set_view_projection_matrix(
-//     ImmRenderer* renderer, const mat4* view_proj) {
-//   assert(renderer);
-//   assert(renderer->shader);
-//
-//   gfx_imm_flush(renderer);
-//   gfx_set_mat4_uniform(renderer->shader, "ViewProjection", view_proj);
-// }
diff --git a/src/llr/llr_impl.h b/src/llr/llr_impl.h
index 5ccabd1..ada2d79 100644
--- a/src/llr/llr_impl.h
+++ b/src/llr/llr_impl.h
@@ -8,6 +8,7 @@
 
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 
 typedef struct Geometry      Geometry;
 typedef struct GfxCore       GfxCore;
@@ -33,67 +34,50 @@ typedef struct Texture       Texture;
 /// Note that the shader program API has its own level of caching as well, so
 /// reconfiguration at the level of the renderer does not result in the
 /// worst-case set of graphics API calls.
-///
-/// Currently, the immediate mode renderer can only draw up to a maximum number
-/// of primitives per frame. It does not adjust this number dynamically. Keeps
-/// things simple while the extra complexity is not needed.
-/// TODO: Flush the buffer when it reaches its maximum size to remove this
-///  constraint.
-typedef struct ImmRenderer {
+typedef struct LLR {
   GfxCore* gfxcore;
 
-  vec3 camera_position;
-  mat4 view;           // Camera view matrix.
-  mat4 projection;     // Camera projection matrix.
-  bool camera_changed; // Whether the camera parameters have changed.
-
-  // -------------------------------------------
-  // Immediate-mode rendering of scene elements.
+  union {
+    struct {
+      bool shader_changed   : 1; // Whether the shader has changed.
+      bool camera_changed   : 1; // Whether the camera parameters have changed.
+      bool lights_changed   : 1; // Whether the lights have changed.
+      bool skeleton_changed : 1; // Whether the skeleton has changed.
+      bool matrix_changed   : 1; // Whether the matrix stack has changed.
+    };
+    uint8_t changed_flags;
+  };
 
   IBL*     ibl;
   Texture* brdf_integration_map;
 
-  ShaderProgram* shader;         // Active shader. Not owned.
-  bool           shader_changed; // Whether the shader has changed.
+  ShaderProgram* shader; // Active shader. Not owned.
+
+  vec3 camera_position;
+  mat4 camera_rotation;
+  mat4 view;       // Camera view matrix.
+  mat4 projection; // Camera projection matrix.
+  R    fovy;       // Camera vertical field of view.
+  R    aspect;     // Aspect ratio.
 
   // Lights are not const because environment lights store lazily-computed
   // irradiance maps.
-  Light* lights[IMM_MAX_NUM_LIGHTS]; // Lights stack.
-  int    num_lights;   // Number of lights enabled at a given point in time. It
-                       // points to one past the top of the stack.
-  bool lights_changed; // Whether the lights have changed.
+  Light* lights[GFX_LLR_MAX_NUM_LIGHTS]; // Lights stack.
+  int    num_lights; // Number of lights enabled at a given point in time. It
+                     // points to one past the top of the stack.
 
-  bool   skeleton_changed;
   size_t num_joints;
   mat4   joint_matrices[GFX_MAX_NUM_JOINTS];
 
-  // ---------------------------------------
-  // Immediate-mode rendering of primitives.
-
-  ShaderProgram* imm_shader; // Immediate-mode shader program for primitives.
-  Geometry*      triangles;
-  size_t         num_triangle_verts; // Number of triangle verts this frame.
-  // TODO: wireframe rendering.
-  struct {
-    bool wireframe : 1;
-  } flags;
-  vec3 triangle_verts[IMM_MAX_NUM_TRIANGLES * 3];
-
-  // -------------
-  // Matrix stack.
-
   // The matrix stack contains pre-multiplied matrices.
   // It is also never empty. The top of the stack is an identity matrix when the
   // stack is "empty" from the user's perspective.
-  mat4 matrix_stack[IMM_MAX_NUM_MATRICES];
+  mat4 matrix_stack[GFX_LLR_MAX_NUM_MATRICES];
   int  stack_pointer; // Points to the top of the stack.
-} ImmRenderer;
+} LLR;
 
 /// Create a new immediate mode renderer.
-bool gfx_imm_make(ImmRenderer*, GfxCore*);
+bool gfx_llr_make(LLR*, GfxCore*);
 
 /// Destroy the immediate mode renderer.
-void gfx_imm_destroy(ImmRenderer*);
-
-/// Flush draw commands.
-void gfx_imm_flush(ImmRenderer*);
+void gfx_llr_destroy(LLR*);
diff --git a/src/llr/material.c b/src/llr/material.c
index 47cb45f..4014482 100644
--- a/src/llr/material.c
+++ b/src/llr/material.c
@@ -48,7 +48,7 @@ static void set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) {
   }
 }
 
-void material_activate(ShaderProgram* shader, const Material* material) {
+void gfx_material_activate(ShaderProgram* shader, const Material* material) {
   assert(material);
   for (int i = 0; i < material->num_uniforms; ++i) {
     const ShaderUniform* uniform = &material->uniforms[i];
diff --git a/src/llr/material_impl.h b/src/llr/material_impl.h
index f27bf4d..138497f 100644
--- a/src/llr/material_impl.h
+++ b/src/llr/material_impl.h
@@ -11,6 +11,5 @@ typedef struct Material {
 
 /// Activate the material.
 ///
-/// This activates the material's shader and configures the shader uniforms that
-/// are specific to the material.
-void material_activate(ShaderProgram* shader, const Material* material);
+/// This configures the shader uniforms that are specific to the material.
+void gfx_material_activate(ShaderProgram* shader, const Material* material);
diff --git a/src/llr/mesh.c b/src/llr/mesh.c
index ae75d8c..3aebb04 100644
--- a/src/llr/mesh.c
+++ b/src/llr/mesh.c
@@ -1,4 +1,4 @@
-#include "../scene/mesh_impl.h"
+#include "mesh_impl.h"
 
 #include "../scene/scene_memory.h"
 
diff --git a/src/renderer/imm_renderer.c b/src/renderer/imm_renderer.c
new file mode 100644
index 0000000..01cc5bb
--- /dev/null
+++ b/src/renderer/imm_renderer.c
@@ -0,0 +1,192 @@
+#include "imm_renderer_impl.h"
+
+#include <gfx/core.h>
+#include <gfx/llr/llr.h>
+#include <gfx/renderer/imm_renderer.h>
+#include <gfx/util/shader.h>
+
+#include <math/aabb3.h>
+
+#include <assert.h>
+#include <string.h> // memcpy
+
+bool gfx_imm_make(ImmRenderer* renderer, GfxCore* gfxcore, LLR* llr) {
+  assert(renderer);
+  assert(gfxcore);
+  assert(llr);
+
+  const size_t num_triangle_verts = GFX_IMM_MAX_NUM_TRIANGLES * 3;
+
+  renderer->gfxcore = gfxcore;
+  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)}});
+  if (!renderer->triangles) {
+    goto cleanup;
+  }
+
+  renderer->shader = gfx_make_immediate_mode_shader(gfxcore);
+  if (!renderer->shader) {
+    goto cleanup;
+  }
+
+  gfx_imm_set_colour(renderer, vec4_make(0.0f, 0.0f, 0.0f, 1.0f));
+
+  return true;
+
+cleanup:
+  gfx_imm_destroy(renderer);
+  return false;
+}
+
+void gfx_imm_destroy(ImmRenderer* renderer) {
+  assert(renderer);
+  assert(renderer->gfxcore);
+
+  if (renderer->triangles) {
+    gfx_destroy_geometry(renderer->gfxcore, &renderer->triangles);
+    // TODO: Could also destroy the geometry's buffers here.
+  }
+
+  if (renderer->shader) {
+    gfx_destroy_shader_program(renderer->gfxcore, &renderer->shader);
+  }
+}
+
+void gfx_imm_flush(ImmRenderer* renderer) {
+  assert(renderer);
+
+  if (renderer->num_triangle_verts > 0) {
+    gfx_update_geometry(
+        renderer->triangles,
+        &(GeometryDesc){
+            .num_verts   = renderer->num_triangle_verts,
+            .positions3d = (BufferView3d){
+                                          .data       = renderer->triangle_verts,
+                                          .size_bytes = renderer->num_triangle_verts * sizeof(vec3)}
+    });
+
+    gfx_llr_render_geometry(renderer->llr, renderer->triangles);
+
+    renderer->num_triangle_verts = 0;
+  }
+}
+
+void gfx_imm_start(ImmRenderer* renderer) {
+  assert(renderer);
+
+  // Shader uniforms are applied lazily.
+  // TODO: In the event that gfx_activate_shader_program() activates uniforms
+  //  automatically for convenience, call an overload here that doesn't do so.
+  // gfx_activate_shader_program(renderer->shader);
+  gfx_llr_set_shader(renderer->llr, renderer->shader);
+}
+
+void gfx_imm_end(ImmRenderer* renderer) {
+  assert(renderer);
+
+  gfx_imm_flush(renderer);
+  // gfx_deactivate_shader_program(renderer->shader);
+  gfx_llr_set_shader(renderer->llr, 0);
+}
+
+void gfx_imm_draw_triangles(
+    ImmRenderer* renderer, const vec3 verts[], size_t num_triangles) {
+  assert(renderer);
+  assert(verts);
+  const size_t new_verts = num_triangles * 3;
+  assert(
+      renderer->num_triangle_verts + new_verts <
+      (GFX_IMM_MAX_NUM_TRIANGLES * 3));
+
+  memcpy(
+      renderer->triangle_verts + renderer->num_triangle_verts, verts,
+      new_verts * sizeof(vec3));
+
+  renderer->num_triangle_verts += new_verts;
+}
+
+void gfx_imm_draw_triangle(ImmRenderer* renderer, const vec3 verts[3]) {
+  gfx_imm_draw_triangles(renderer, verts, 1);
+}
+
+void gfx_imm_draw_aabb2(ImmRenderer* renderer, aabb2 box) {
+  assert(renderer);
+
+  // clang-format off
+  const vec3 verts[4] = {
+      vec3_make(box.min.x, box.min.y, 0),    // 3 ---- 2
+      vec3_make(box.max.x, box.min.y, 0),    // |      |
+      vec3_make(box.max.x, box.max.y, 0),    // |      |
+      vec3_make(box.min.x, box.max.y, 0)};   // 0 ---- 1
+  // clang-format on
+
+#define tri(i0, i1, i2) verts[i0], verts[i1], verts[i2]
+  const vec3 tris[6] = {tri(0, 1, 2), tri(0, 2, 3)};
+#undef tri
+
+  gfx_imm_draw_triangles(renderer, tris, 2);
+}
+
+void gfx_imm_draw_aabb3(ImmRenderer* renderer, aabb3 box) {
+  assert(renderer);
+
+  // clang-format off
+  const vec3 vertices[8] = {
+      vec3_make(box.min.x, box.min.y, box.max.z), //     7 ----- 6
+      vec3_make(box.max.x, box.min.y, box.max.z), //    /       /|
+      vec3_make(box.max.x, box.max.y, box.max.z), //   3 ----- 2 |
+      vec3_make(box.min.x, box.max.y, box.max.z), //   |       | |
+      vec3_make(box.min.x, box.min.y, box.min.z), //   | 4 ----- 5
+      vec3_make(box.max.x, box.min.y, box.min.z), //   |/      |/
+      vec3_make(box.max.x, box.max.y, box.min.z), //   0 ----- 1
+      vec3_make(box.min.x, box.max.y, box.min.z)};
+  // clang-format on
+
+  gfx_imm_draw_box3(renderer, vertices);
+}
+
+void gfx_imm_draw_box3(ImmRenderer* renderer, const vec3 vertices[8]) {
+  assert(renderer);
+  assert(vertices);
+
+  //     7 ----- 6
+  //    /       /|
+  //   3 ----- 2 |
+  //   |       | |
+  //   | 4 ----- 5
+  //   |/      |/
+  //   0 ----- 1
+
+#define tri(i0, i1, i2) vertices[i0], vertices[i1], vertices[i2]
+  const vec3 tris[36] = {
+      // Front.
+      tri(0, 1, 2), tri(0, 2, 3),
+      // Right.
+      tri(1, 5, 6), tri(1, 6, 2),
+      // Back.
+      tri(5, 4, 7), tri(5, 7, 6),
+      // Left.
+      tri(4, 0, 03), tri(4, 3, 7),
+      // Top.
+      tri(3, 2, 6), tri(3, 6, 7),
+      // Bottom.
+      tri(0, 4, 5), tri(0, 5, 1)};
+
+  gfx_imm_draw_triangles(renderer, tris, 12);
+}
+
+void gfx_imm_set_colour(ImmRenderer* renderer, vec4 colour) {
+  assert(renderer);
+  assert(renderer->shader);
+
+  gfx_imm_flush(renderer);
+
+  gfx_set_vec4_uniform(renderer->shader, "Colour", colour);
+}
diff --git a/src/renderer/imm_renderer_impl.h b/src/renderer/imm_renderer_impl.h
new file mode 100644
index 0000000..61b49a7
--- /dev/null
+++ b/src/renderer/imm_renderer_impl.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <gfx/sizes.h>
+
+#include <math/vec3.h>
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct Geometry      Geometry;
+typedef struct GfxCore       GfxCore;
+typedef struct IBL           IBL;
+typedef struct LLR           LLR;
+typedef struct Material      Material;
+typedef struct ShaderProgram ShaderProgram;
+typedef struct Texture       Texture;
+
+/// Immediate mode renderer.
+///
+/// Currently, the immediate mode renderer can only draw up to a maximum number
+/// of primitives per frame. It does not adjust this number dynamically. Keeps
+/// things simple while the extra complexity is not needed.
+/// TODO: Flush the buffer when it reaches its maximum size to remove this
+///  constraint.
+typedef struct ImmRenderer {
+  GfxCore* gfxcore;
+  LLR*     llr;
+
+  ShaderProgram* shader; // Immediate-mode shader program for primitives.
+  Geometry*      triangles;
+  size_t         num_triangle_verts; // Number of triangle verts this frame.
+  // TODO: wireframe rendering.
+  struct {
+    bool wireframe : 1;
+  } flags;
+  vec3 triangle_verts[GFX_IMM_MAX_NUM_TRIANGLES * 3];
+} ImmRenderer;
+
+/// Create a new immediate mode renderer.
+bool gfx_imm_make(ImmRenderer*, GfxCore*, LLR*);
+
+/// Destroy the immediate mode renderer.
+void gfx_imm_destroy(ImmRenderer*);
diff --git a/src/renderer/renderer.c b/src/renderer/renderer.c
index c2a7dda..29a1813 100644
--- a/src/renderer/renderer.c
+++ b/src/renderer/renderer.c
@@ -1,10 +1,9 @@
 #include "renderer_impl.h"
 
+#include "llr/light_impl.h"
+#include "llr/mesh_impl.h"
 #include "scene/animation_impl.h"
 #include "scene/camera_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"
@@ -12,41 +11,30 @@
 #include "scene/scene_memory.h"
 
 #include <gfx/core.h>
-#include <gfx/util/ibl.h>
+#include <gfx/llr/llr.h>
 #include <gfx/util/shader.h>
 
-#include <log/log.h>
 #include <math/mat4.h>
-#include <math/spatial3.h>
 
 #include <assert.h>
 
-// TODO: Move to a header like "constants.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 PREFILTERED_ENVIRONMENT_MAP_HEIGHT = 128;
-static const int BRDF_INTEGRATION_MAP_WIDTH         = 512;
-static const int BRDF_INTEGRATION_MAP_HEIGHT        = 512;
-
-bool renderer_make(Renderer* renderer, GfxCore* gfxcore) {
+bool gfx_renderer_make(Renderer* renderer, LLR* llr, GfxCore* gfxcore) {
   assert(renderer);
+  assert(llr);
   assert(gfxcore);
 
   renderer->gfxcore = gfxcore;
+  renderer->llr     = llr;
 
   return true;
 }
 
-void renderer_destroy(Renderer* renderer) {
+void gfx_renderer_destroy(Renderer* renderer) {
   if (!renderer) {
     return;
   }
   assert(renderer->gfxcore);
   GfxCore* gfxcore = renderer->gfxcore;
-  if (renderer->ibl) {
-    gfx_destroy_ibl(gfxcore, &renderer->ibl);
-  }
   if (renderer->shaders.debug) {
     gfx_destroy_shader_program(gfxcore, &renderer->shaders.debug);
   }
@@ -62,24 +50,6 @@ void renderer_destroy(Renderer* renderer) {
   }
 }
 
-/// Initialize renderer state for IBL if not already initialized.
-static bool init_ibl(Renderer* renderer) {
-  assert(renderer);
-
-  if (!renderer->ibl && !(renderer->ibl = gfx_make_ibl(renderer->gfxcore))) {
-    return false;
-  }
-
-  if (!renderer->brdf_integration_map &&
-      !(renderer->brdf_integration_map = gfx_make_brdf_integration_map(
-            renderer->ibl, renderer->gfxcore, BRDF_INTEGRATION_MAP_WIDTH,
-            BRDF_INTEGRATION_MAP_HEIGHT))) {
-    return false;
-  }
-
-  return true;
-}
-
 static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) {
   assert(renderer);
 
@@ -117,89 +87,17 @@ static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) {
 //   }
 // }
 
-/// Computes irradiance and prefiltered environment maps for the light if they
-/// have not been already computed.
-static bool setup_environment_light(
-    Renderer* renderer, GfxCore* gfxcore, EnvironmentLight* light) {
-  assert(renderer);
-  assert(light);
-
-  if (!init_ibl(renderer)) {
-    return false;
-  }
-
-  if (light->irradiance_map) {
-    assert(light->prefiltered_environment_map);
-    return true;
-  }
-
-  Texture* irradiance_map              = 0;
-  Texture* prefiltered_environment_map = 0;
-
-  if (!(irradiance_map = gfx_make_irradiance_map(
-            renderer->ibl, gfxcore, light->environment_map,
-            IRRADIANCE_MAP_WIDTH, IRRADIANCE_MAP_HEIGHT))) {
-    goto cleanup;
-  }
-
-  int max_mip_level = 0;
-  if (!(prefiltered_environment_map = gfx_make_prefiltered_environment_map(
-            renderer->ibl, gfxcore, light->environment_map,
-            PREFILTERED_ENVIRONMENT_MAP_WIDTH,
-            PREFILTERED_ENVIRONMENT_MAP_HEIGHT, &max_mip_level))) {
-    goto cleanup;
-  }
-
-  light->irradiance_map              = irradiance_map;
-  light->prefiltered_environment_map = prefiltered_environment_map;
-  light->max_reflection_lod          = max_mip_level;
-
-  return true;
-
-cleanup:
-  if (irradiance_map) {
-    gfx_destroy_texture(gfxcore, &irradiance_map);
-  }
-  if (prefiltered_environment_map) {
-    gfx_destroy_texture(gfxcore, &prefiltered_environment_map);
-  }
-  return false;
-}
-
 typedef struct RenderState {
   GfxCore*       gfxcore;
+  LLR*           llr;
   Renderer*      renderer;
   ShaderProgram* shader; // Null to use scene shaders.
   const Scene*   scene;
-  const Camera*  camera;
-  const mat4*    camera_rotation; // From camera to world space, rotation only.
-  const mat4*    view_matrix;
-  const mat4*    projection;
-  const float    fovy;
-  const float    aspect;
-  Light*         environment_light;
   const Anima*   anima;
-  size_t         num_joints;
-  mat4           joint_matrices[GFX_MAX_NUM_JOINTS];
 } RenderState;
 
-/// Load joint matrices into the render state.
-static void load_skeleton(RenderState* state, skeleton_idx skeleton_index) {
-  assert(state);
-  assert(skeleton_index.val != 0);
-
-  const Skeleton* skeleton = mem_get_skeleton(skeleton_index);
-  assert(skeleton);
-  assert(skeleton->num_joints <= GFX_MAX_NUM_JOINTS);
-
-  state->num_joints = skeleton->num_joints;
-
-  for (size_t i = 0; i < skeleton->num_joints; ++i) {
-    const joint_idx joint_index = skeleton->joints[i];
-    const Joint*    joint       = &state->anima->joints[joint_index];
-    state->joint_matrices[i]    = joint->joint_matrix;
-  }
-}
+static void draw_children(
+    RenderState* state, const mat4* node_transform, const SceneNode* node);
 
 /// Draw the scene recursively.
 static void draw_recursively(
@@ -209,26 +107,27 @@ static void draw_recursively(
 
   // Anima.
   if (node->type == AnimaNode) {
+    // Save the anima so that we can animate objects.
     state->anima = gfx_get_node_anima(node);
+
+    draw_children(state, &node_transform, node);
   }
   // Activate light.
   else if (node->type == LightNode) {
     Light* light = mem_get_light(node->light);
     assert(light);
-
-    if (light->type == EnvironmentLightType) {
-      bool result = setup_environment_light(
-          state->renderer, state->gfxcore, &light->environment);
-      // TODO: Handle the result in a better way.
-      assert(result);
-      state->environment_light = light;
+    gfx_llr_push_light(state->llr, light);
+    {
+      draw_children(state, &node_transform, node);
     }
+    gfx_llr_pop_light(state->llr);
   }
   // Model.
   else if (node->type == ModelNode) {
     const Model*     model = gfx_get_node_model(node);
     const SceneNode* root  = mem_get_node(model->root);
     draw_recursively(state, parent_transform, root);
+    draw_children(state, &node_transform, node);
   }
   // Render object.
   else if (node->type == ObjectNode) {
@@ -237,16 +136,15 @@ static void draw_recursively(
 
     // TODO: Here we would frustum-cull the object.
 
-    // TODO: Avoid computing matrices like Modelview or MVP if the shader does
-    // not use them.
-    const mat4 model_matrix = node_transform;
-    const mat4 modelview    = mat4_mul(*state->view_matrix, model_matrix);
-    const mat4 mvp          = mat4_mul(*state->projection, modelview);
-
+    // A model/anima can have many skeletons. We need to animate the given
+    // object using its skeleton, not just any skeleton of the anima.
     if (object->skeleton.val) {
-      load_skeleton(state, object->skeleton);
+      const Skeleton* skeleton = mem_get_skeleton(object->skeleton);
+      gfx_llr_set_skeleton(state->llr, state->anima, skeleton);
     }
 
+    const mat4 model_matrix = node_transform;
+
     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);
@@ -256,63 +154,34 @@ static void draw_recursively(
       if (!mesh) {
         continue;
       }
-      assert(mesh->geometry);
-      assert(mesh->material);
 
       // TODO: Here we would frustum-cull the mesh. The AABB would have to be
-      // transformed by the model matrix. Rotation would make the AABB
-      // relatively large, but still, the culling would be conservative.
+      //  transformed by the model matrix. Rotation would make the AABB
+      //  relatively large, but still, the culling would be conservative.
 
-      // Apply common shader uniforms not captured by materials.
       ShaderProgram* shader = state->shader ? state->shader : mesh->shader;
-      gfx_set_mat4_uniform(shader, "ModelMatrix", &model_matrix);
-      gfx_set_mat4_uniform(shader, "Modelview", &modelview);
-      gfx_set_mat4_uniform(shader, "View", state->view_matrix);
-      gfx_set_mat4_uniform(shader, "Projection", state->projection);
-      gfx_set_mat4_uniform(shader, "MVP", &mvp);
-      gfx_set_mat4_uniform(shader, "CameraRotation", state->camera_rotation);
-      gfx_set_float_uniform(shader, "Fovy", state->fovy);
-      gfx_set_float_uniform(shader, "Aspect", state->aspect);
-      if (state->camera) {
-        gfx_set_vec3_uniform(
-            shader, "CameraPosition", state->camera->spatial.p);
-      }
-      if (state->num_joints > 0) {
-        gfx_set_mat4_array_uniform(
-            shader, "JointMatrices", state->joint_matrices, state->num_joints);
-      }
-      // Apply lights.
-      if (state->environment_light) {
-        const EnvironmentLight* light = &state->environment_light->environment;
-        assert(light->environment_map);
-        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, "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);
-      }
-      material_activate(shader, mesh->material);
-      gfx_activate_shader_program(shader);
-      gfx_apply_uniforms(shader);
-      gfx_render_geometry(mesh->geometry);
+      gfx_llr_set_shader(state->llr, shader);
+      gfx_llr_set_model_matrix(state->llr, &model_matrix);
+      gfx_llr_render_mesh(state->llr, mesh);
     }
 
-    // Reset state for next object.
-    state->num_joints = 0;
+    if (object->skeleton.val) {
+      gfx_llr_clear_skeleton(state->llr);
+    }
+
+    draw_children(state, &node_transform, node);
+  } else {
+    draw_children(state, &node_transform, node);
   }
+}
 
+/// Draw the node's children.
+static void draw_children(
+    RenderState* state, const mat4* node_transform, const SceneNode* node) {
   // Render children recursively.
   for (node_idx child_index = node->child; child_index.val;) {
     const SceneNode* child = mem_get_node(child_index);
-    draw_recursively(state, node_transform, child);
+    draw_recursively(state, *node_transform, child);
     child_index = child->next;
   }
 }
@@ -324,41 +193,23 @@ void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) {
 
   ShaderProgram* const shader = load_shader(renderer, params->mode);
 
-  const Scene*       scene  = params->scene;
-  const SceneCamera* camera = params->camera;
-
-  GfxCore* gfxcore = renderer->gfxcore;
-
-  mat4 projection, camera_rotation, view_matrix;
-  if (camera) {
-    projection = camera->camera.projection;
-    camera_rotation =
-        mat4_rotation(spatial3_transform(&camera->camera.spatial));
-    view_matrix = spatial3_inverse_transform(&camera->camera.spatial);
-  } else {
-    projection      = mat4_id();
-    camera_rotation = mat4_id();
-    view_matrix     = mat4_id();
-  }
+  const Scene*       scene   = params->scene;
+  const SceneCamera* camera  = params->camera;
+  GfxCore* const     gfxcore = renderer->gfxcore;
 
   int x, y, width, height;
   gfx_get_viewport(gfxcore, &x, &y, &width, &height);
-  const float aspect = (float)width / (float)height;
+  const R aspect = (R)width / (R)height;
 
   RenderState state = {
-      .gfxcore           = gfxcore,
-      .renderer          = renderer,
-      .shader            = shader,
-      .scene             = scene,
-      .camera            = &camera->camera,
-      .camera_rotation   = &camera_rotation,
-      .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};
-
+      .gfxcore  = gfxcore,
+      .llr      = renderer->llr,
+      .renderer = renderer,
+      .shader   = shader,
+      .scene    = scene};
+
+  gfx_llr_set_camera(renderer->llr, &camera->camera);
+  gfx_llr_set_aspect(renderer->llr, aspect);
   draw_recursively(&state, mat4_id(), scene->root);
 }
 
diff --git a/src/renderer/renderer_impl.h b/src/renderer/renderer_impl.h
index fc14dcb..7395915 100644
--- a/src/renderer/renderer_impl.h
+++ b/src/renderer/renderer_impl.h
@@ -4,14 +4,12 @@
 
 #include <stdbool.h>
 
-typedef struct IBL           IBL;
+typedef struct LLR           LLR;
 typedef struct ShaderProgram ShaderProgram;
-typedef struct Texture       Texture;
 
 typedef struct Renderer {
   GfxCore* gfxcore;
-  IBL*     ibl;
-  Texture* brdf_integration_map;
+  LLR*     llr;
   struct {
     ShaderProgram* debug;
     ShaderProgram* normals;
@@ -21,7 +19,7 @@ typedef struct Renderer {
 } Renderer;
 
 /// Create a new renderer.
-bool renderer_make(Renderer*, GfxCore*);
+bool gfx_renderer_make(Renderer*, LLR*, GfxCore*);
 
 /// Destroy the renderer.
-void renderer_destroy(Renderer*);
+void gfx_renderer_destroy(Renderer*);
diff --git a/src/scene/node.c b/src/scene/node.c
index 67ce93c..e359f73 100644
--- a/src/scene/node.c
+++ b/src/scene/node.c
@@ -2,7 +2,7 @@
 
 #include "animation_impl.h"
 #include "camera_impl.h"
-#include "light_impl.h"
+#include "llr/light_impl.h"
 #include "model_impl.h"
 #include "object_impl.h"
 #include "scene_graph.h"
diff --git a/src/scene/object.c b/src/scene/object.c
index e8e3ee6..27ff5db 100644
--- a/src/scene/object.c
+++ b/src/scene/object.c
@@ -2,7 +2,7 @@
 
 #include <gfx/core.h>
 
-#include "mesh_impl.h"
+#include "llr/mesh_impl.h"
 #include "node_impl.h"
 #include "scene_memory.h"
 
diff --git a/src/scene/object_impl.h b/src/scene/object_impl.h
index ead93f1..e864e53 100644
--- a/src/scene/object_impl.h
+++ b/src/scene/object_impl.h
@@ -4,8 +4,6 @@
 
 #include "types.h"
 
-#include <math/mat4.h>
-
 typedef struct MeshLink {
   mesh_idx      mesh;
   mesh_link_idx next; // Next MeshLink in the list.
diff --git a/src/scene/scene_memory.c b/src/scene/scene_memory.c
index 91880bb..3a01325 100644
--- a/src/scene/scene_memory.c
+++ b/src/scene/scene_memory.c
@@ -4,9 +4,9 @@
 
 #include "animation_impl.h"
 #include "camera_impl.h"
-#include "light_impl.h"
-#include "material_impl.h"
-#include "mesh_impl.h"
+#include "llr/light_impl.h"
+#include "llr/material_impl.h"
+#include "llr/mesh_impl.h"
 #include "model_impl.h"
 #include "node_impl.h"
 #include "object_impl.h"
diff --git a/src/util/skyquad.c b/src/util/skyquad.c
index 08fa044..094de67 100644
--- a/src/util/skyquad.c
+++ b/src/util/skyquad.c
@@ -1,18 +1,14 @@
 #include <gfx/util/skyquad.h>
 
 #include <gfx/core.h>
-#include <gfx/gfx.h>
-#include <gfx/scene/light.h>
-#include <gfx/scene/material.h>
-#include <gfx/scene/mesh.h>
+#include <gfx/llr/light.h>
+#include <gfx/llr/material.h>
+#include <gfx/llr/mesh.h>
 #include <gfx/scene/node.h>
 #include <gfx/scene/object.h>
-#include <gfx/scene/scene.h>
 #include <gfx/util/geometry.h>
 #include <gfx/util/shader.h>
 
-#include <math/vec4.h>
-
 #include <assert.h>
 
 SceneObject* gfx_make_skyquad(GfxCore* gfxcore, const Texture* texture) {
@@ -36,10 +32,9 @@ SceneObject* gfx_make_skyquad(GfxCore* gfxcore, const Texture* texture) {
   }
 
   MaterialDesc material_desc = (MaterialDesc){0};
-  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);
   if (!material) {