159 files changed, 1515 insertions, 4185 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 25c7560..de5f0dd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,8 +1,96 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 
-project(gfx-all)
+add_subdirectory(contrib/cgltf)
+add_subdirectory(contrib/cgltf-tangents)
+add_subdirectory(contrib/stb)
 
 add_subdirectory(app)
-add_subdirectory(gfx)
-add_subdirectory(gfx-iso)
-add_subdirectory(game)
+
+project(gfx)
+
+include(cmake/shader.txt)
+
+set(CMAKE_C_STANDARD 23)
+set(CMAKE_C_STANDARD_REQUIRED On)
+set(CMAKE_C_EXTENSIONS Off)
+
+add_shader_library(shaders
+  shaders/brdf_integration_map.frag
+  shaders/cook_torrance.frag
+  shaders/cook_torrance.vert
+  shaders/cubemap_filtering.vert
+  shaders/debug3d.frag
+  shaders/debug3d.vert
+  shaders/immediate_mode.frag
+  shaders/immediate_mode.vert
+  shaders/irradiance_map.frag
+  shaders/prefiltered_environment_map.frag
+  shaders/quad.vert
+  shaders/skyquad.frag
+  shaders/skyquad.vert
+  shaders/view_normal_mapped_normals.frag
+  shaders/view_normal_mapped_normals.vert
+  shaders/view_normals.frag
+  shaders/view_normals.vert
+  shaders/view_tangents.frag
+  shaders/view_tangents.vert
+  shaders/view_texture.frag
+  shaders/view_texture.vert)
+
+add_library(gfx SHARED
+  src/asset/asset_cache.c
+  src/asset/model.c
+  src/asset/texture.c
+  src/core/buffer.c
+  src/core/core.c
+  src/core/framebuffer.c
+  src/core/geometry.c
+  src/core/renderbuffer.c
+  src/core/shader_program.c
+  src/core/shader.c
+  src/core/texture.c
+  src/llr/llr.c
+  src/llr/light.c
+  src/llr/material.c
+  src/llr/mesh.c
+  src/memory.c
+  src/renderer/imm_renderer.c
+  src/renderer/renderer.c
+  src/scene/animation.c
+  src/scene/camera.c
+  src/scene/model.c
+  src/scene/node.c
+  src/scene/object.c
+  src/scene/scene.c
+  src/gfx.c
+  src/util/geometry.c
+  src/util/ibl.c
+  src/util/shader.c
+  src/util/skyquad.c)
+
+target_include_directories(gfx PUBLIC
+  include)
+
+target_include_directories(gfx PRIVATE
+  src)
+
+target_compile_options(gfx PRIVATE -std=gnu11 -Wall -Wextra -Wpedantic)
+
+target_link_libraries(gfx PUBLIC
+  cstring
+  math)
+
+target_link_libraries(gfx PRIVATE
+  cassert
+  cgltf
+  cgltf-tangents
+  error
+  gfx-app
+  log
+  mempool
+  shaders
+  stb
+  # System libraries.
+  GL
+  # Required to initialize GLAD.
+  -ldl)
diff --git a/gfx/README.md b/README.md
index f0b103d..491761d 100644
--- a/gfx/README.md
+++ b/README.md
@@ -20,32 +20,35 @@ educational purposes.
 ### Gfx
 
 The `Gfx` object represents the graphics subsystem and is at the center of the
-library's high-level API. The `Gfx` object exposes a `Render` backend and a
-`Renderer` and allows the caller to create `Scene`s.
+library's high-level API. The `Gfx` object exposes a render backend (`GfxCore`)
+and a `Renderer`, and allows the caller to create `Scene`s.
 
 ### Render Backend
 
-The `Render` backend is a thin abstraction layer over low-level graphics APIs
-like OpenGL or Vulkan. It holds GPU resources such as geometry, textures,
-shaders, etc, and exposes functions to manipulate them.
+The render backend (`GfxCore`) is a thin abstraction layer over low-level
+graphics APIs like OpenGL or Vulkan. It holds GPU resources such as geometry,
+textures, shaders, etc, and exposes functions to manipulate them.
 
-Currently there is only one implementation of the `Render` backend based on
+Currently, there is only one implementation of the render backend based on
 OpenGL.
 
 #### Ownership
 
-The `Render` backend owns all rendering resources: buffers, geometries,
-textures, shaders, etc. Even resources that point to other resources do not own
-those other resources (geometries pointing to buffers).
+The render backend owns all rendering resources: buffers, geometries, textures,
+shaders, etc. Even resources that point to other resources do not own those
+other resources (geometries pointing to buffers).
 
-There is no ownership tracking in the render backend. It is up to the client to
+There is no lifetime tracking in the render backend. It is up to the client to
 manage resource lifetime.
 
+### Low-level Renderer
+
+`ImmRenderer` is a low-level, immediate mode renderer.
+
 ### Scene
 
-A `Scene` encapsulates a scene graph. A scene graph contains the elements that
-make up a scene: nodes, cameras, lights, objects, etc. The current scene graph
-implementation includes:
+A `Scene` graph contains the elements that make up a scene. The current scene
+graph implementation includes:
 
 - Camera
 - Light
@@ -64,7 +67,8 @@ functions to set the parent node of an object/camera/light. If we exposed the
 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):
+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
@@ -76,9 +80,9 @@ glTF 2.0 spec [enforces this](https://github.com/KhronosGroup/glTF/blob/master/s
 Two use cases for instancing seem to be:
 
 1. Creating N identical clones, but each with a unique transform. (Ex: N
-animated characters animated in unison but located in different locations.)
+   animated characters animated in unison but located in different locations.)
 2. Creating N copies of a sub-tree, each now being their own unique tree. (Ex:
-The same N animated characters, but each of them now being animated separately.)
+   The same N animated characters, but each of them now being animated separately.)
 
 Some scene graphs
 ([Panda3D](https://docs.panda3d.org/1.10/python/programming/scene-graph/instancing))
@@ -87,10 +91,10 @@ to have multiple parents. This turns the scene graph into a DAG and adds a
 number of complications for us:
 
 1. Shared ownership of children. We would now need some sort of ref counting or
-deferred GC to delete nodes and their subtrees.
+   deferred GC to delete nodes and their subtrees.
 2. Nodes no longer have a unique parent.
 3. Given a node, we can no longer determine its location (which parent link do
-you follow?), or any attribute that is derived from its parent(s).
+   you follow?), or any attribute that is derived from its parent(s).
 
 In our case, we stick to strict tree hierarchies.
 
@@ -131,6 +135,10 @@ Code under `util/` provides functionality that need not be in the core part
 of the library (Gfx, render backend, scene or renderer). This includes functions
 to compute irradiance maps, create procedural geometry, etc.
 
+### Memory management
+
+TODO
+
 ## Ideas for Future Work
 
 - Render graphs to allow for custom multi-pass rendering algorithms.
diff --git a/app/src/app.c b/app/src/app.c
index 9b816ee..e1edf88 100644
--- a/app/src/app.c
+++ b/app/src/app.c
@@ -112,10 +112,14 @@ bool gfx_app_run(const GfxAppDesc* desc, const GfxAppCallbacks* callbacks) {
   }
   glfwMakeContextCurrent(g_gfx_app.window);
 
-  // Load GL before calling the application init clalback.
-  if (!gladLoadGL()) {
-    LOGE("Failed loading glad!");
-    return 0;
+  // Request adaptive sync if supported.
+  glfwSwapInterval(-1);
+
+  // Load GL before calling the application init callback.
+  // Use the GLFW loader. See: https://github.com/apitrace/apitrace/issues/954
+  if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
+    LOGE("Failed loading glad");
+    goto cleanup;
   }
 
   // Initialize the application's state before setting any callbacks.
diff --git a/gfx/bin/txt2c.py b/bin/txt2c.py
index 1d8ff70..1d8ff70 100755
--- a/gfx/bin/txt2c.py
+++ b/bin/txt2c.py
diff --git a/gfx/cmake/shader.txt b/cmake/shader.txt
index 8273f4d..8273f4d 100644
--- a/gfx/cmake/shader.txt
+++ b/cmake/shader.txt
diff --git a/gfx/cmake/txt2c.txt b/cmake/txt2c.txt
index 0cb11a9..0cb11a9 100644
--- a/gfx/cmake/txt2c.txt
+++ b/cmake/txt2c.txt
diff --git a/gfx/contrib/cgltf-tangents/CMakeLists.txt b/contrib/cgltf-tangents/CMakeLists.txt
index 2c0771e..2c0771e 100644
--- a/gfx/contrib/cgltf-tangents/CMakeLists.txt
+++ b/contrib/cgltf-tangents/CMakeLists.txt
diff --git a/gfx/contrib/cgltf-tangents/LICENSE b/contrib/cgltf-tangents/LICENSE
index 7796e37..7796e37 100644
--- a/gfx/contrib/cgltf-tangents/LICENSE
+++ b/contrib/cgltf-tangents/LICENSE
diff --git a/gfx/contrib/cgltf-tangents/MikkTSpace/README.md b/contrib/cgltf-tangents/MikkTSpace/README.md
index 9fda155..9fda155 100644
--- a/gfx/contrib/cgltf-tangents/MikkTSpace/README.md
+++ b/contrib/cgltf-tangents/MikkTSpace/README.md
diff --git a/gfx/contrib/cgltf-tangents/MikkTSpace/mikktspace.c b/contrib/cgltf-tangents/MikkTSpace/mikktspace.c
index 0342ae0..0342ae0 100644
--- a/gfx/contrib/cgltf-tangents/MikkTSpace/mikktspace.c
+++ b/contrib/cgltf-tangents/MikkTSpace/mikktspace.c
diff --git a/gfx/contrib/cgltf-tangents/MikkTSpace/mikktspace.h b/contrib/cgltf-tangents/MikkTSpace/mikktspace.h
index 52c44a7..52c44a7 100644
--- a/gfx/contrib/cgltf-tangents/MikkTSpace/mikktspace.h
+++ b/contrib/cgltf-tangents/MikkTSpace/mikktspace.h
diff --git a/gfx/contrib/cgltf-tangents/README.md b/contrib/cgltf-tangents/README.md
index 2a68b27..2a68b27 100644
--- a/gfx/contrib/cgltf-tangents/README.md
+++ b/contrib/cgltf-tangents/README.md
diff --git a/gfx/contrib/cgltf-tangents/cgltf_tangents.c b/contrib/cgltf-tangents/cgltf_tangents.c
index 80b1e56..80b1e56 100644
--- a/gfx/contrib/cgltf-tangents/cgltf_tangents.c
+++ b/contrib/cgltf-tangents/cgltf_tangents.c
diff --git a/gfx/contrib/cgltf-tangents/cgltf_tangents.h b/contrib/cgltf-tangents/cgltf_tangents.h
index 79e3502..79e3502 100644
--- a/gfx/contrib/cgltf-tangents/cgltf_tangents.h
+++ b/contrib/cgltf-tangents/cgltf_tangents.h
diff --git a/gfx/contrib/cgltf-tangents/test/CMakeLists.txt b/contrib/cgltf-tangents/test/CMakeLists.txt
index 422c950..422c950 100644
--- a/gfx/contrib/cgltf-tangents/test/CMakeLists.txt
+++ b/contrib/cgltf-tangents/test/CMakeLists.txt
diff --git a/gfx/contrib/cgltf-tangents/test/main.c b/contrib/cgltf-tangents/test/main.c
index 0d70008..0d70008 100644
--- a/gfx/contrib/cgltf-tangents/test/main.c
+++ b/contrib/cgltf-tangents/test/main.c
diff --git a/gfx/contrib/cgltf/CMakeLists.txt b/contrib/cgltf/CMakeLists.txt
index 0ac840a..0ac840a 100644
--- a/gfx/contrib/cgltf/CMakeLists.txt
+++ b/contrib/cgltf/CMakeLists.txt
diff --git a/gfx/contrib/cgltf/LICENSE b/contrib/cgltf/LICENSE
index 0afe8c7..0afe8c7 100644
--- a/gfx/contrib/cgltf/LICENSE
+++ b/contrib/cgltf/LICENSE
diff --git a/gfx/contrib/cgltf/README.md b/contrib/cgltf/README.md
index 3b49d52..3b49d52 100644
--- a/gfx/contrib/cgltf/README.md
+++ b/contrib/cgltf/README.md
diff --git a/gfx/contrib/cgltf/cgltf.h b/contrib/cgltf/cgltf.h
index 077cf36..077cf36 100644
--- a/gfx/contrib/cgltf/cgltf.h
+++ b/contrib/cgltf/cgltf.h
diff --git a/gfx/contrib/cgltf/cgltf_write.h b/contrib/cgltf/cgltf_write.h
index 2096a5b..2096a5b 100644
--- a/gfx/contrib/cgltf/cgltf_write.h
+++ b/contrib/cgltf/cgltf_write.h
diff --git a/gfx/contrib/stb/CMakeLists.txt b/contrib/stb/CMakeLists.txt
index 8cee003..8cee003 100644
--- a/gfx/contrib/stb/CMakeLists.txt
+++ b/contrib/stb/CMakeLists.txt
diff --git a/gfx/contrib/stb/stb_image.h b/contrib/stb/stb_image.h
index 97038e6..97038e6 100644
--- a/gfx/contrib/stb/stb_image.h
+++ b/contrib/stb/stb_image.h
diff --git a/gfx/doc/extern/2013SiggraphPresentationsNotes-26915738.pdf b/doc/extern/2013SiggraphPresentationsNotes-26915738.pdf
index 989658e..989658e 100644
--- a/gfx/doc/extern/2013SiggraphPresentationsNotes-26915738.pdf
+++ b/doc/extern/2013SiggraphPresentationsNotes-26915738.pdf
diff --git a/gfx/doc/extern/Scene Graph - CSE 167.pdf b/doc/extern/Scene Graph - CSE 167.pdf
index 5fbbb10..5fbbb10 100644
--- a/gfx/doc/extern/Scene Graph - CSE 167.pdf
+++ b/doc/extern/Scene Graph - CSE 167.pdf
diff --git a/gfx/doc/gfx.png b/doc/gfx.png
index e64f6e1..e64f6e1 100644
--- a/gfx/doc/gfx.png
+++ b/doc/gfx.png
diff --git a/gfx/doc/gfx.txt b/doc/gfx.txt
index d3ce01b..d3ce01b 100644
--- a/gfx/doc/gfx.txt
+++ b/doc/gfx.txt
diff --git a/gfx/doc/gltfOverview-2.0.0b.png b/doc/gltfOverview-2.0.0b.png
index 6a5bb61..6a5bb61 100644
--- a/gfx/doc/gltfOverview-2.0.0b.png
+++ b/doc/gltfOverview-2.0.0b.png
diff --git a/gfx/doc/pipeline.png b/doc/pipeline.png
index 426f39e..426f39e 100644
--- a/gfx/doc/pipeline.png
+++ b/doc/pipeline.png
diff --git a/gfx/doc/pipeline.txt b/doc/pipeline.txt
index 51523d6..51523d6 100644
--- a/gfx/doc/pipeline.txt
+++ b/doc/pipeline.txt
diff --git a/gfx/doc/renderer.png b/doc/renderer.png
index d0516b0..d0516b0 100644
--- a/gfx/doc/renderer.png
+++ b/doc/renderer.png
diff --git a/gfx/doc/renderer.txt b/doc/renderer.txt
index 90b18f8..90b18f8 100644
--- a/gfx/doc/renderer.txt
+++ b/doc/renderer.txt
diff --git a/gfx/doc/scene.png b/doc/scene.png
index 85d2447..85d2447 100644
--- a/gfx/doc/scene.png
+++ b/doc/scene.png
diff --git a/gfx/doc/scene.txt b/doc/scene.txt
index a771488..a771488 100644
--- a/gfx/doc/scene.txt
+++ b/doc/scene.txt
diff --git a/game/CMakeLists.txt b/game/CMakeLists.txt
deleted file mode 100644
index 3a88bb7..0000000
--- a/game/CMakeLists.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-
-add_subdirectory(src/plugins)
-
-project(game)
-
-add_executable(game
-  src/game.c)
-
-target_include_directories(game PRIVATE
-  src/)
-
-target_link_libraries(game PRIVATE
-  cstring
-  error
-  gfx
-  gfx-app
-  list
-  log
-  math
-  mempool
-  plugin)
diff --git a/game/src/game.c b/game/src/game.c
deleted file mode 100644
index dc2248b..0000000
--- a/game/src/game.c
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * Main game module with entry point and game loop.
- *
- * The game module sets up the window and GL context and defers the core game
- * logic to a plugin.
- */
-#define _GNU_SOURCE 200112L // For readlink()
-
-#include "game.h"
-
-#include "plugins/plugin.h"
-
-#include <gfx/app.h>
-#include <gfx/core.h>
-#include <gfx/gfx.h>
-#include <gfx/renderer.h>
-#include <gfx/scene/camera.h>
-#include <gfx/scene/node.h>
-#include <gfx/scene/object.h>
-#include <gfx/scene/scene.h>
-
-#include <error.h>
-#include <log/log.h>
-#include <math/camera.h>
-#include <plugin.h>
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#include <linux/limits.h>
-
-#include <unistd.h>
-
-#undef _GNU_SOURCE
-
-static const int WIDTH   = 1350;
-static const int HEIGHT  = 900;
-static const int MAX_FPS = 60;
-
-typedef struct GfxAppState {
-  Game game;
-} GfxAppState;
-
-/// Initialize the game's plugin.
-static bool init_plugin(Game* game) {
-  assert(game);
-  assert(game->plugin);
-  // Plugin state is allowed to be null, either when the plugin does not
-  // expose an init() or when init() does not initialize a state.
-  if (plugin_resolve(game->plugin, plugin_init, "init")) {
-    State* plugin_state = 0;
-    if (!plugin_call(game->plugin, plugin_init, "init", game, &plugin_state)) {
-      return false;
-    }
-    set_plugin_state(game->plugin, plugin_state);
-  }
-  return true; // Plugin does not need to expose an init().
-}
-
-/// Shutdown the game's plugin.
-/// The game's plugin is allowed to be null in the call to this function.
-static void shutdown_plugin(Game* game) {
-  assert(game);
-  if (game->plugin &&
-      (plugin_resolve(game->plugin, plugin_shutdown, "shutdown"))) {
-    void* plugin_state = get_plugin_state(game->plugin);
-    plugin_call(game->plugin, plugin_shutdown, "shutdown", game, plugin_state);
-    set_plugin_state(game->plugin, 0);
-  }
-}
-
-/// Boot the game's plugin.
-static bool boot_plugin(Game* game) {
-  assert(game);
-  assert(game->plugin);
-  if (plugin_resolve(game->plugin, plugin_boot, "boot")) {
-    void* plugin_state = get_plugin_state(game->plugin);
-    return plugin_call(game->plugin, plugin_boot, "boot", game, plugin_state);
-  }
-  return true; // Plugin does not need to expose a boot().
-}
-
-/// Update the plugin's state.
-static void update_plugin(Game* game, double t, double dt) {
-  assert(game);
-  assert(game->plugin);
-  if (plugin_resolve(game->plugin, plugin_update, "update")) {
-    void* plugin_state = get_plugin_state(game->plugin);
-    plugin_call(
-        game->plugin, plugin_update, "update", game, plugin_state, t, dt);
-  }
-}
-
-/// Plugin render.
-static void render_plugin(const Game* game) {
-  assert(game);
-  assert(game->plugin);
-  if (plugin_resolve(game->plugin, plugin_render, "render")) {
-    void* plugin_state = get_plugin_state(game->plugin);
-    plugin_call(game->plugin, plugin_render, "render", game, plugin_state);
-  }
-}
-
-/// Plugin resize.
-static void resize_plugin(Game* game, int width, int height) {
-  assert(game);
-  assert(game->plugin);
-  if (plugin_resolve(game->plugin, plugin_resize, "resize")) {
-    void* plugin_state = get_plugin_state(game->plugin);
-    plugin_call(
-        game->plugin, plugin_resize, "resize", game, plugin_state, width,
-        height);
-  }
-}
-
-static void Shutdown(Game* game);
-
-static bool Init(Game* game, int argc, const char** argv) {
-  assert(game);
-
-  if (argc <= 1) {
-    LOGE("Usage: %s <plugin> [plugin args]", argv[0]);
-    return false;
-  }
-
-  // Syntax: game <plugin> [plugin args]
-  //
-  // Here we consume the <plugin> arg so that plugins receive the remainder
-  // args starting from 0.
-  game->argc = argc - 1;
-  game->argv = argv + 1;
-
-  char exe_path_buf[NAME_MAX] = {0};
-  if (readlink("/proc/self/exe", exe_path_buf, sizeof(exe_path_buf)) == -1) {
-    LOGE("readlink(/proc/self/exe) failed");
-    goto cleanup;
-  }
-
-  // Replace the last / with a null terminator to remove the exe file from the
-  // path. This gets the file's parent directory.
-  *strrchr(exe_path_buf, '/') = 0;
-
-  const mstring exe_dir      = mstring_make(exe_path_buf);
-  const mstring plugins_path = mstring_concat_cstr(exe_dir, "/src/plugins");
-
-  if (!(game->plugin_engine = new_plugin_engine(
-            &(PluginEngineDesc){.plugins_dir = mstring_cstr(&plugins_path)}))) {
-    goto cleanup;
-  }
-
-  const char* plugin = argv[1];
-  if (!(game->plugin = load_plugin(game->plugin_engine, plugin))) {
-    goto cleanup;
-  }
-
-  if (!(game->gfx = gfx_init())) {
-    goto cleanup;
-  }
-
-  if (!init_plugin(game)) {
-    goto cleanup;
-  }
-  if (!boot_plugin(game)) {
-    goto cleanup;
-  }
-
-  return true;
-
-cleanup:
-  LOGE("Gfx error: %s", get_error());
-  Shutdown(game);
-  return false;
-}
-
-static void Shutdown(Game* game) {
-  assert(game);
-  shutdown_plugin(game);
-  if (game->gfx) {
-    gfx_destroy(&game->gfx);
-  }
-  if (game->plugin) {
-    delete_plugin(&game->plugin);
-  }
-  if (game->plugin_engine) {
-    delete_plugin_engine(&game->plugin_engine);
-  }
-}
-
-static void Update(Game* game, double t, double dt) {
-  plugin_engine_update(game->plugin_engine);
-  if (plugin_reloaded(game->plugin)) {
-    shutdown_plugin(game);
-    const bool result = init_plugin(game);
-    assert(result); // TODO: handle error better.
-
-    // Trigger a resize just like the initial resize that occurs when the gfx
-    // application starts.
-    resize_plugin(game, game->width, game->height);
-  }
-
-  update_plugin(game, t, dt);
-}
-
-static void Render(const Game* game) {
-  GfxCore* gfxcore = gfx_get_core(game->gfx);
-  gfx_start_frame(gfxcore);
-  render_plugin(game);
-  gfx_end_frame(gfxcore);
-}
-
-static void Resize(Game* game, int width, int height) {
-  game->width  = width;
-  game->height = height;
-
-  GfxCore* gfxcore = gfx_get_core(game->gfx);
-  gfx_set_viewport(gfxcore, 0, 0, width, height);
-
-  resize_plugin(game, width, height);
-}
-
-GFX_APP_MAIN(WIDTH, HEIGHT, MAX_FPS, "Game");
diff --git a/game/src/game.h b/game/src/game.h
deleted file mode 100644
index 579ba3c..0000000
--- a/game/src/game.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Header file defining the game state, included by plugins.
- */
-#pragma once
-
-typedef struct PluginEngine PluginEngine;
-typedef struct Plugin       Plugin;
-typedef struct Gfx          Gfx;
-typedef struct Scene        Scene;
-typedef struct SceneCamera  SceneCamera;
-
-/// Game state.
-typedef struct {
-  int           argc;
-  const char**  argv;
-  PluginEngine* plugin_engine;
-  Plugin*       plugin;
-  Gfx*          gfx;
-  int           width;
-  int           height;
-} Game;
diff --git a/game/src/plugins/CMakeLists.txt b/game/src/plugins/CMakeLists.txt
deleted file mode 100644
index 8661598..0000000
--- a/game/src/plugins/CMakeLists.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-
-project(plugins)
-
-set(LINK_LIBRARIES cstring math gfx gfx-app)
-
-# Viewer
-
-add_library(viewer SHARED
-  viewer.c)
-
-target_link_libraries(viewer PUBLIC
-  ${LINK_LIBRARIES})
-
-# Texture viewer
-
-add_library(texture_view SHARED
-  texture_view.c)
-
-target_link_libraries(texture_view PUBLIC
-  ${LINK_LIBRARIES})
-
-# Pong
-
-add_library(pong SHARED
-  pong.c)
-
-target_link_libraries(pong PUBLIC
-  ${LINK_LIBRARIES})
diff --git a/game/src/plugins/plugin.h b/game/src/plugins/plugin.h
deleted file mode 100644
index f7219c6..0000000
--- a/game/src/plugins/plugin.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Game plugin.
- */
-#pragma once
-
-#include "../game.h"
-
-#include <gfx/gfx.h>
-#include <gfx/scene.h>
-
-#include <stdbool.h>
-
-typedef struct State State;
-
-/// Initialize the plugin, which may optionally return a state object.
-///
-/// This function is called every time the plugin is (re)loaded.
-///
-/// It is assumed that the plugin's state is fully encapsulated in the returned
-/// state object. The plugin should not store any (mutable) state outside of the
-/// returned state object (e.g., no mutable global variables.)
-bool init(Game*, State**);
-
-/// Shut down the plugin.
-///
-/// This function is called before the plugin is unloaded.
-///
-/// The plugin should perform any destruction needed, but not free the state
-/// object; freeing the state object's memory is handled by the caller.
-void shutdown(Game*, State*);
-
-/// Function called the first time the plugin is loaded throughout the
-/// application's lifetime. This allows the plugin to do one-time initialization
-/// of the game state.
-bool boot(Game*, State*);
-
-/// Update the plugin's and the game's state.
-void update(Game*, State*, double t, double dt);
-
-/// Render hook.
-void render(const Game*, const State*);
-
-/// Called when the game's window is resized.
-void resize(Game*, State*, int width, int height);
-
-// Signatures for the plugin's exposed functions.
-typedef bool (*plugin_init)(Game*, State**);
-typedef bool (*plugin_shutdown)(Game*, State*);
-typedef bool (*plugin_boot)(Game*, State*);
-typedef void (*plugin_update)(Game*, State*, double t, double dt);
-typedef void (*plugin_render)(const Game*, const State*);
-typedef void (*plugin_resize)(Game* game, State* state, int width, int height);
diff --git a/game/src/plugins/pong.c b/game/src/plugins/pong.c
deleted file mode 100644
index c1c55be..0000000
--- a/game/src/plugins/pong.c
+++ /dev/null
@@ -1,237 +0,0 @@
-#include "plugin.h"
-
-#include <gfx/app.h>
-#include <gfx/gfx.h>
-#include <gfx/renderer.h>
-
-#include <math/mat4.h>
-#include <math/vec2.h>
-#include <math/vec4.h>
-
-#include <stdlib.h>
-
-static const vec2 PAD_SIZE        = (vec2){120, 20};
-static const R    PLAYER_Y_OFFSET = 50;
-static const R    PLAYER_SPEED    = 800;
-
-static const R ENEMY_SPEED = 2;
-
-static const R BALL_SIZE  = 18;
-static const R BALL_SPEED = 360; // In each dimension.
-
-static const R EPS = (R)1e-3;
-
-typedef struct Player {
-  vec2 position;
-} Player;
-
-typedef struct Ball {
-  vec2 position;
-  vec2 velocity;
-} Ball;
-
-typedef struct State {
-  bool   game_started;
-  Player human;
-  Player enemy;
-  Ball   ball;
-  mat4   viewProjection;
-} State;
-
-bool init(Game* game, State** pp_state) {
-  assert(game);
-
-  State* state = calloc(1, sizeof(State));
-  if (!state) {
-    return false;
-  }
-
-  *pp_state = state;
-  return true;
-
-cleanup:
-  free(state);
-  return false;
-}
-
-void shutdown(Game* game, State* state) {
-  assert(game);
-  assert(state);
-}
-
-static void move_ball(Ball* ball, R dt, int width, int height) {
-  assert(ball);
-
-  const R offset = BALL_SIZE / 2;
-
-  ball->position = vec2_add(ball->position, vec2_scale(ball->velocity, dt));
-
-  // Right wall.
-  if (ball->position.x + offset > (R)width) {
-    ball->position.x = (R)width - offset - EPS;
-    ball->velocity.x = -ball->velocity.x;
-  }
-  // Left wall.
-  else if (ball->position.x - offset < 0) {
-    ball->position.x = offset + EPS;
-    ball->velocity.x = -ball->velocity.x;
-  }
-  // Top wall.
-  if (ball->position.y + offset > (R)height) {
-    ball->position.y = (R)height - offset - EPS;
-    ball->velocity.y = -ball->velocity.y;
-  }
-  // Bottom wall.
-  else if (ball->position.y - offset < 0) {
-    ball->position.y = offset + EPS;
-    ball->velocity.y = -ball->velocity.y;
-  }
-}
-
-void move_enemy_player(int width, Player* player, R t) {
-  const R half_width = (R)width / 2;
-  const R amplitude  = half_width - (PAD_SIZE.x / 2);
-  player->position.x = half_width + amplitude * sinf(t * ENEMY_SPEED);
-}
-
-void move_human_player(Player* player, R dt) {
-  assert(player);
-
-  R speed = 0;
-  if (gfx_app_is_key_pressed('a')) {
-    speed -= PLAYER_SPEED;
-  }
-  if (gfx_app_is_key_pressed('d')) {
-    speed += PLAYER_SPEED;
-  }
-
-  player->position.x += speed * dt;
-}
-
-void clamp_player(Player* player, int width) {
-  assert(player);
-
-  const R offset = PAD_SIZE.x / 2;
-
-  // Left wall.
-  if (player->position.x + offset > (R)width) {
-    player->position.x = (R)width - offset;
-  }
-  // Right wall.
-  else if (player->position.x - offset < 0) {
-    player->position.x = offset;
-  }
-}
-
-void collide_ball(vec2 old_ball_position, const Player* player, Ball* ball) {
-  assert(player);
-  assert(ball);
-
-  // Discrete but simple collision. Checks for intersection and moves the ball
-  // back by a small epsilon.
-
-  // Player bounding box.
-  const vec2 player_pmin = vec2_make(
-      player->position.x - PAD_SIZE.x / 2, player->position.y - PAD_SIZE.y / 2);
-  const vec2 player_pmax = vec2_make(
-      player->position.x + PAD_SIZE.x / 2, player->position.y + PAD_SIZE.y / 2);
-
-  // Ball bounding box.
-  const vec2 ball_pmin = vec2_make(
-      ball->position.x - BALL_SIZE / 2, ball->position.y - BALL_SIZE / 2);
-  const vec2 ball_pmax = vec2_make(
-      ball->position.x + BALL_SIZE / 2, ball->position.y + BALL_SIZE / 2);
-
-  // Check for intersection and update ball.
-  if (!((ball_pmax.x < player_pmin.x) || (ball_pmin.x > player_pmax.x) ||
-        (ball_pmax.y < player_pmin.y) || (ball_pmin.y > player_pmax.y))) {
-    ball->position =
-        vec2_add(old_ball_position, vec2_scale(ball->velocity, -EPS));
-    ball->velocity.y = -ball->velocity.y;
-  }
-}
-
-void update(Game* game, State* state, double t, double dt) {
-  assert(game);
-  assert(state);
-
-  // TODO: Move game width/height to GfxApp query functions?
-  const vec2 old_ball_position = state->ball.position;
-  move_ball(&state->ball, (R)dt, game->width, game->height);
-  move_human_player(&state->human, (R)dt);
-  move_enemy_player(game->width, &state->enemy, (R)t);
-  clamp_player(&state->human, game->width);
-  collide_ball(old_ball_position, &state->human, &state->ball);
-  collide_ball(old_ball_position, &state->enemy, &state->ball);
-}
-
-static void draw_player(ImmRenderer* imm, const Player* player) {
-  assert(imm);
-  assert(player);
-
-  const vec2 half_box = vec2_div(PAD_SIZE, vec2_make(2, 2));
-
-  const vec2  pmin = vec2_sub(player->position, half_box);
-  const vec2  pmax = vec2_add(player->position, half_box);
-  const aabb2 box  = aabb2_make(pmin, pmax);
-
-  gfx_imm_draw_aabb2(imm, box);
-}
-
-static void draw_ball(ImmRenderer* imm, const Ball* ball) {
-  assert(imm);
-  assert(ball);
-
-  const vec2  half_box = vec2_make(BALL_SIZE / 2, BALL_SIZE / 2);
-  const vec2  pmin     = vec2_sub(ball->position, half_box);
-  const vec2  pmax     = vec2_add(ball->position, half_box);
-  const aabb2 box      = aabb2_make(pmin, pmax);
-
-  gfx_imm_draw_aabb2(imm, box);
-}
-
-void render(const Game* game, const State* state) {
-  assert(game);
-  assert(state);
-
-  ImmRenderer* imm = gfx_get_imm_renderer(game->gfx);
-  gfx_imm_start(imm);
-  gfx_imm_set_view_projection_matrix(imm, &state->viewProjection);
-  gfx_imm_load_identity(imm);
-  gfx_imm_set_colour(imm, vec4_make(1, 1, 1, 1));
-  draw_player(imm, &state->human);
-  draw_player(imm, &state->enemy);
-  draw_ball(imm, &state->ball);
-  gfx_imm_end(imm);
-}
-
-static R clamp_to_width(int width, R x, R extent) {
-  return min(x, (R)width - extent);
-}
-
-void resize(Game* game, State* state, int width, int height) {
-  assert(game);
-  assert(state);
-
-  state->viewProjection = mat4_ortho(0, (R)width, 0, (R)height, -1, 1);
-
-  state->human.position.y = PLAYER_Y_OFFSET;
-  state->enemy.position.y = (R)height - PLAYER_Y_OFFSET;
-
-  if (!state->game_started) {
-    state->human.position.x = (R)width / 2;
-    state->enemy.position.x = (R)width / 2;
-
-    state->ball.position =
-        vec2_div(vec2_make((R)width, (R)height), vec2_make(2, 2));
-
-    state->ball.velocity = vec2_make(BALL_SPEED, BALL_SPEED);
-
-    state->game_started = true;
-  } else {
-    state->human.position.x =
-        clamp_to_width(width, state->human.position.x, PAD_SIZE.x / 2);
-    state->enemy.position.x =
-        clamp_to_width(width, state->enemy.position.x, PAD_SIZE.x / 2);
-  }
-}
diff --git a/game/src/plugins/texture_view.c b/game/src/plugins/texture_view.c
deleted file mode 100644
index a8b2a94..0000000
--- a/game/src/plugins/texture_view.c
+++ /dev/null
@@ -1,144 +0,0 @@
-#include "plugin.h"
-
-#include <gfx/asset.h>
-#include <gfx/core.h>
-#include <gfx/renderer.h>
-#include <gfx/scene.h>
-#include <gfx/util/geometry.h>
-#include <gfx/util/shader.h>
-
-#include <math/camera.h>
-
-#include <assert.h>
-#include <stdlib.h>
-
-// Default texture to load if no texture is provided.
-static const char* DEFAULT_TEXTURE = "/assets/skybox/clouds1/clouds1_west.bmp";
-// static const char* DEFAULT_TEXTURE = "/assets/checkerboard.jpg";
-
-struct State {
-  Scene*       scene;
-  SceneCamera* camera;
-};
-
-bool init(Game* game, State** pp_state) {
-  assert(game);
-  assert(pp_state);
-
-  State* state = calloc(1, sizeof(State));
-  if (!state) {
-    goto cleanup;
-  }
-
-  // Usage: [texture file]
-  const char* texture_file = game->argc > 1 ? game->argv[1] : DEFAULT_TEXTURE;
-
-  GfxCore* gfxcore = gfx_get_core(game->gfx);
-
-  const Texture* texture = gfx_load_texture(
-      game->gfx, &(LoadTextureCmd){
-                     .origin                = AssetFromFile,
-                     .type                  = LoadTexture,
-                     .filtering             = LinearFiltering,
-                     .mipmaps               = false,
-                     .data.texture.filepath = mstring_make(texture_file)});
-  if (!texture) {
-    goto cleanup;
-  }
-
-  ShaderProgram* shader = gfx_make_view_texture_shader(gfxcore);
-  if (!shader) {
-    goto cleanup;
-  }
-
-  Geometry* geometry = gfx_make_quad_11(gfxcore);
-  if (!geometry) {
-    goto cleanup;
-  }
-
-  MaterialDesc material_desc = (MaterialDesc){.num_uniforms = 1};
-  material_desc.uniforms[0]  = (ShaderUniform){
-       .type          = UniformTexture,
-       .value.texture = texture,
-       .name          = sstring_make("Texture")};
-  Material* material = gfx_make_material(&material_desc);
-  if (!material) {
-    goto cleanup;
-  }
-
-  const MeshDesc mesh_desc =
-      (MeshDesc){.geometry = geometry, .material = material, .shader = shader};
-  Mesh* mesh = gfx_make_mesh(&mesh_desc);
-  if (!mesh) {
-    goto cleanup;
-  }
-
-  SceneObject* object =
-      gfx_make_object(&(ObjectDesc){.num_meshes = 1, .meshes = {mesh}});
-  if (!object) {
-    goto cleanup;
-  }
-
-  if (!(state->scene = gfx_make_scene())) {
-    goto cleanup;
-  }
-
-  SceneNode* node = gfx_make_object_node(object);
-  if (!node) {
-    goto cleanup;
-  }
-  SceneNode* root = gfx_get_scene_root(state->scene);
-  if (!root) {
-    goto cleanup;
-  }
-  gfx_set_node_parent(node, root);
-
-  if (!(state->camera = gfx_make_camera())) {
-    goto cleanup;
-  }
-
-  *pp_state = state;
-  return true;
-
-cleanup:
-  shutdown(game, state);
-  if (state) {
-    free(state);
-  }
-  return false;
-}
-
-void shutdown(Game* game, State* state) {
-  assert(game);
-  if (state) {
-    gfx_destroy_camera(&state->camera);
-    gfx_destroy_scene(&state->scene);
-    // State freed by plugin engine.
-  }
-}
-
-void render(const Game* game, const State* state) {
-  assert(game);
-  assert(state);
-
-  Renderer* renderer = gfx_get_renderer(game->gfx);
-  gfx_render_scene(
-      renderer, &(RenderSceneParams){
-                    .mode   = RenderDefault,
-                    .scene  = state->scene,
-                    .camera = state->camera});
-}
-
-void resize(Game* game, State* state, int width, int height) {
-  assert(game);
-  assert(state);
-
-  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(state->camera);
-  camera->projection = projection;
-}
diff --git a/game/src/plugins/viewer.c b/game/src/plugins/viewer.c
deleted file mode 100644
index 5fc4be7..0000000
--- a/game/src/plugins/viewer.c
+++ /dev/null
@@ -1,366 +0,0 @@
-#include "plugin.h"
-
-#include <gfx/app.h>
-#include <gfx/asset.h>
-#include <gfx/renderer.h>
-#include <gfx/scene.h>
-#include <gfx/util/skyquad.h>
-#include <math/camera.h>
-#include <math/spatial3.h>
-
-#include <log/log.h>
-
-#include <stdlib.h>
-
-// Paths to various scene files.
-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";
-static const char* FLIGHT_HELMET =
-    "/assets/glTF-Sample-Models/2.0/FlightHelmet/glTF/FlightHelmet.gltf";
-static const char* DAMAGED_HELMET =
-    "/assets/glTF-Sample-Models/2.0/DamagedHelmet/glTF/DamagedHelmet.gltf";
-static const char* GIRL =
-    "/home/jeanne/Nextcloud/assets/models/girl/girl-with-ground.gltf";
-static const char* BOXES =
-    "/home/jeanne/Nextcloud/assets/models/boxes/boxes.gltf";
-
-#define DEFAULT_SCENE_FILE GIRL
-
-static const bool RenderBoundingBoxes     = false;
-static const R    DefaultCameraSpeed      = (R)6.0;
-static const R    DefaultMouseSensitivity = (R)(10 * TO_RAD);
-static const vec3 DefaultCameraPosition   = (vec3){0, 2, 5};
-
-typedef struct CameraCommand {
-  bool CameraMoveLeft     : 1;
-  bool CameraMoveRight    : 1;
-  bool CameraMoveForward  : 1;
-  bool CameraMoveBackward : 1;
-} CameraCommand;
-
-typedef struct CameraController {
-  R camera_speed;           // Camera movement speed.
-  R mouse_sensitivity;      // Controls the degree with which mouse movements
-                            // rotate the camera.
-  vec2 prev_mouse_position; // Mouse position in the previous frame.
-  bool rotating;            // When true, subsequent mouse movements cause the
-                            // camera to rotate.
-} CameraController;
-
-typedef struct State {
-  Scene*           scene;
-  Model*           model;
-  SceneCamera*     camera;
-  CameraController camera_controller;
-} State;
-
-/// Load the skyquad texture.
-static const Texture* load_environment_map(Gfx* gfx) {
-  assert(gfx);
-  return gfx_load_texture(
-      gfx, &(LoadTextureCmd){
-               .origin                 = AssetFromFile,
-               .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_south.bmp"),
-                                          mstring_make("/assets/skybox/clouds1/clouds1_north.bmp")}
-  });
-}
-
-/// Load the skyquad and return the environment light node.
-static SceneNode* load_skyquad(Gfx* gfx, SceneNode* root) {
-  assert(gfx);
-  assert(root);
-
-  GfxCore* gfxcore = gfx_get_core(gfx);
-
-  const Texture* environment_map = load_environment_map(gfx);
-  if (!environment_map) {
-    return 0;
-  }
-
-  return gfx_setup_skyquad(gfxcore, root, environment_map);
-}
-
-/// Load the 3D scene.
-/// Return the loaded model.
-static Model* load_scene(Game* game, State* state, const char* scene_filepath) {
-  assert(game);
-  assert(game->gfx);
-  assert(state);
-  assert(state->scene);
-
-  Camera* camera = gfx_get_camera_camera(state->camera);
-  spatial3_set_position(&camera->spatial, vec3_make(0, 0, 2));
-
-  SceneNode* root           = gfx_get_scene_root(state->scene);
-  SceneNode* sky_light_node = load_skyquad(game->gfx, root);
-  if (!sky_light_node) {
-    return 0; // test
-  }
-
-  Model* model = gfx_load_model(
-      game->gfx,
-      &(LoadModelCmd){
-          .origin = AssetFromFile, .filepath = mstring_make(scene_filepath)});
-  if (!model) {
-    return 0;
-  }
-  SceneNode* model_node = gfx_make_model_node(model);
-  if (!model_node) {
-    return 0;
-  }
-  gfx_set_node_parent(model_node, sky_light_node);
-
-  gfx_log_node_hierarchy(root);
-
-  return model;
-}
-
-bool init(Game* game, State** pp_state) {
-  assert(game);
-
-  // Usage: <scene file>
-  const char* scene_filepath =
-      game->argc > 1 ? game->argv[1] : DEFAULT_SCENE_FILE;
-
-  State* state = calloc(1, sizeof(State));
-  if (!state) {
-    goto cleanup;
-  }
-
-  if (!(state->scene = gfx_make_scene())) {
-    goto cleanup;
-  }
-  if (!(state->camera = gfx_make_camera())) {
-    goto cleanup;
-  }
-
-  state->model = load_scene(game, state, scene_filepath);
-  if (!state->model) {
-    goto cleanup;
-  }
-
-  Anima* anima = gfx_get_model_anima(state->model);
-  if (anima) {
-    gfx_play_animation(
-        anima, &(AnimationPlaySettings){.name = "Walk", .loop = true});
-    // TODO: Interpolate animations.
-    /*gfx_play_animation(
-        anima,
-        &(AnimationPlaySettings){.name = "Jumping-jack-lower", .loop = true});
-    gfx_play_animation(
-        anima, &(AnimationPlaySettings){
-                   .name = "Jumping-jack-arms-mid", .loop = true});*/
-  }
-
-  spatial3_set_position(
-      &gfx_get_camera_camera(state->camera)->spatial, DefaultCameraPosition);
-
-  state->camera_controller.camera_speed      = DefaultCameraSpeed;
-  state->camera_controller.mouse_sensitivity = DefaultMouseSensitivity;
-
-  *pp_state = state;
-  return true;
-
-cleanup:
-  shutdown(game, state);
-  if (state) {
-    free(state);
-  }
-  return false;
-}
-
-void shutdown(Game* game, State* state) {
-  assert(game);
-  if (state) {
-    gfx_destroy_camera(&state->camera);
-    gfx_destroy_scene(&state->scene);
-    // State freed by plugin engine.
-  }
-}
-
-static void update_camera(
-    CameraController* controller, R dt, vec2 mouse_position,
-    CameraCommand command, Spatial3* camera) {
-  assert(controller);
-  assert(camera);
-
-  // Translation.
-  const R move_x = (R)(command.CameraMoveLeft ? -1 : 0) +
-                   (R)(command.CameraMoveRight ? 1 : 0);
-  const R move_y = (R)(command.CameraMoveForward ? 1 : 0) +
-                   (R)(command.CameraMoveBackward ? -1 : 0);
-  const vec2 translation =
-      vec2_scale(vec2_make(move_x, move_y), controller->camera_speed * dt);
-  spatial3_move_right(camera, translation.x);
-  spatial3_move_forwards(camera, translation.y);
-
-  // Rotation.
-  if (controller->rotating) {
-    const vec2 mouse_delta =
-        vec2_sub(mouse_position, controller->prev_mouse_position);
-
-    const vec2 rotation =
-        vec2_scale(mouse_delta, controller->mouse_sensitivity * dt);
-
-    spatial3_global_yaw(camera, -rotation.x);
-    spatial3_pitch(camera, -rotation.y);
-  }
-
-  // Update controller state.
-  controller->prev_mouse_position = mouse_position;
-}
-
-void update(Game* game, State* state, double t, double dt) {
-  assert(game);
-  assert(state);
-  assert(state->scene);
-  assert(state->camera);
-
-  double mouse_x, mouse_y;
-  gfx_app_get_mouse_position(&mouse_x, &mouse_y);
-  const vec2 mouse_position = {(R)mouse_x, (R)mouse_y};
-
-  const CameraCommand camera_command = (CameraCommand){
-      .CameraMoveLeft     = gfx_app_is_key_pressed(KeyA),
-      .CameraMoveRight    = gfx_app_is_key_pressed(KeyD),
-      .CameraMoveForward  = gfx_app_is_key_pressed(KeyW),
-      .CameraMoveBackward = gfx_app_is_key_pressed(KeyS),
-  };
-
-  state->camera_controller.rotating = gfx_app_is_mouse_button_pressed(LMB);
-
-  update_camera(
-      &state->camera_controller, (R)dt, mouse_position, camera_command,
-      &gfx_get_camera_camera(state->camera)->spatial);
-
-  //  const vec3 orbit_point = vec3_make(0, 2, 0);
-  //  Camera*    camera      = gfx_get_camera_camera(state->camera);
-  //  spatial3_orbit(
-  //      &camera->spatial, orbit_point,
-  //      /*radius=*/5,
-  //      /*azimuth=*/(R)(t * 0.5), /*zenith=*/0);
-  //  spatial3_lookat(&camera->spatial, orbit_point);
-
-  gfx_update(state->scene, state->camera, (R)t);
-}
-
-/// Render the bounding boxes of all scene objects.
-static void render_bounding_boxes_rec(
-    ImmRenderer* imm, const Anima* anima, const mat4* parent_model_matrix,
-    const SceneNode* node) {
-  assert(imm);
-  assert(node);
-
-  const mat4 model_matrix =
-      mat4_mul(*parent_model_matrix, gfx_get_node_transform(node));
-
-  const NodeType node_type = gfx_get_node_type(node);
-
-  if (node_type == ModelNode) {
-    const Model*     model = gfx_get_node_model(node);
-    const SceneNode* root  = gfx_get_model_root(model);
-    render_bounding_boxes_rec(imm, anima, &model_matrix, root);
-  } else if (node_type == AnimaNode) {
-    anima = gfx_get_node_anima(node);
-  } else if (node_type == ObjectNode) {
-    gfx_imm_set_model_matrix(imm, &model_matrix);
-
-    const SceneObject* obj      = gfx_get_node_object(node);
-    const Skeleton*    skeleton = gfx_get_object_skeleton(obj);
-
-    if (skeleton) { // Animated model.
-      assert(anima);
-      const size_t num_joints = gfx_get_skeleton_num_joints(skeleton);
-      for (size_t i = 0; i < num_joints; ++i) {
-        if (gfx_joint_has_box(anima, skeleton, i)) {
-          const Box box = gfx_get_joint_box(anima, skeleton, i);
-          gfx_imm_draw_box3(imm, box.vertices);
-        }
-      }
-    } else { // Static model.
-      const aabb3 box = gfx_get_object_aabb(obj);
-      gfx_imm_draw_aabb3(imm, box);
-    }
-  }
-
-  // Render children's boxes.
-  const SceneNode* child = gfx_get_node_child(node);
-  while (child) {
-    render_bounding_boxes_rec(imm, anima, &model_matrix, child);
-    child = gfx_get_node_sibling(child);
-  }
-}
-
-/// Render the bounding boxes of all scene objects.
-static void render_bounding_boxes(const Game* game, const State* state) {
-  assert(game);
-  assert(state);
-
-  GfxCore*     gfxcore = gfx_get_core(game->gfx);
-  ImmRenderer* imm     = gfx_get_imm_renderer(game->gfx);
-  assert(gfxcore);
-  assert(imm);
-
-  const mat4 id    = mat4_id();
-  Anima*     anima = 0;
-
-  gfx_set_blending(gfxcore, true);
-  gfx_set_depth_mask(gfxcore, false);
-  gfx_set_polygon_offset(gfxcore, -1.5f, -1.0f);
-
-  gfx_imm_start(imm);
-  gfx_imm_set_camera(imm, gfx_get_camera_camera(state->camera));
-  gfx_imm_set_colour(imm, vec4_make(0.3, 0.3, 0.9, 0.1));
-  render_bounding_boxes_rec(imm, anima, &id, gfx_get_scene_root(state->scene));
-  gfx_imm_end(imm);
-
-  gfx_reset_polygon_offset(gfxcore);
-  gfx_set_depth_mask(gfxcore, true);
-  gfx_set_blending(gfxcore, false);
-}
-
-void render(const Game* game, const State* state) {
-  assert(state);
-  assert(game);
-  assert(game->gfx);
-  assert(state->scene);
-  assert(state->camera);
-
-  Renderer* renderer = gfx_get_renderer(game->gfx);
-  assert(renderer);
-
-  gfx_render_scene(
-      renderer, &(RenderSceneParams){
-                    .mode   = RenderDefault,
-                    .scene  = state->scene,
-                    .camera = state->camera});
-
-  if (RenderBoundingBoxes) {
-    render_bounding_boxes(game, state);
-  }
-}
-
-void resize(Game* game, State* state, int width, int height) {
-  assert(game);
-  assert(state);
-
-  const R    fovy       = 60 * 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(state->camera);
-  camera->projection = projection;
-}
diff --git a/gfx-iso/CMakeLists.txt b/gfx-iso/CMakeLists.txt
deleted file mode 100644
index e4a677d..0000000
--- a/gfx-iso/CMakeLists.txt
+++ /dev/null
@@ -1,42 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-
-project(isogfx)
-
-set(CMAKE_C_STANDARD 17)
-set(CMAKE_C_STANDARD_REQUIRED On)
-set(CMAKE_C_EXTENSIONS Off)
-
-# isogfx
-
-add_library(isogfx
-  src/isogfx.c)
-
-target_include_directories(isogfx PUBLIC
-  include)
-
-target_link_libraries(isogfx PUBLIC
-  filesystem
-  mem
-  mempool)
-
-target_compile_options(isogfx PRIVATE -Wall -Wextra -Wpedantic)
-
-# Backend
-
-add_library(isogfx-backend
-  src/backend.c)
-
-target_include_directories(isogfx-backend PUBLIC
-  include)
-
-target_link_libraries(isogfx-backend PUBLIC
-  isogfx)
-
-target_link_libraries(isogfx-backend PRIVATE
-  gfx)
-
-target_compile_options(isogfx-backend PRIVATE -Wall -Wextra -Wpedantic)
-
-# Demos
-
-add_subdirectory(demos)
diff --git a/gfx-iso/demos/CMakeLists.txt b/gfx-iso/demos/CMakeLists.txt
deleted file mode 100644
index c0a4101..0000000
--- a/gfx-iso/demos/CMakeLists.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-add_subdirectory(checkerboard)
-add_subdirectory(isomap)
diff --git a/gfx-iso/demos/checkerboard/CMakeLists.txt b/gfx-iso/demos/checkerboard/CMakeLists.txt
deleted file mode 100644
index d1691c6..0000000
--- a/gfx-iso/demos/checkerboard/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-
-project(checkerboard)
-
-set(CMAKE_C_STANDARD 17)
-set(CMAKE_C_STANDARD_REQUIRED On)
-set(CMAKE_C_EXTENSIONS Off)
-
-add_executable(checkerboard
-  checkerboard.c)
-
-target_link_libraries(checkerboard PRIVATE
-  gfx-app
-  isogfx-backend)
-
-target_compile_options(checkerboard PRIVATE -Wall -Wextra -Wpedantic)
diff --git a/gfx-iso/demos/checkerboard/checkerboard.c b/gfx-iso/demos/checkerboard/checkerboard.c
deleted file mode 100644
index dbc817c..0000000
--- a/gfx-iso/demos/checkerboard/checkerboard.c
+++ /dev/null
@@ -1,166 +0,0 @@
-#include <isogfx/backend.h>
-#include <isogfx/isogfx.h>
-
-#include <gfx/app.h>
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-static const int WINDOW_WIDTH  = 1408;
-static const int WINDOW_HEIGHT = 960;
-static const int MAX_FPS       = 60;
-
-// Virtual screen dimensions.
-static const int SCREEN_WIDTH  = 704;
-static const int SCREEN_HEIGHT = 480;
-
-static const int TILE_WIDTH   = 32;
-static const int TILE_HEIGHT  = TILE_WIDTH / 2;
-static const int WORLD_WIDTH  = 20;
-static const int WORLD_HEIGHT = 20;
-
-static const TileDesc tile_set[] = {
-    {.type   = TileFromColour,
-     .width  = TILE_WIDTH,
-     .height = TILE_HEIGHT,
-     .colour = (Pixel){.r = 0x38, .g = 0x3b, .b = 0x46, .a = 0xff}},
-    {.type   = TileFromColour,
-     .width  = TILE_WIDTH,
-     .height = TILE_HEIGHT,
-     .colour = (Pixel){.r = 0xA5, .g = 0xb3, .b = 0xc0, .a = 0xff}},
-    {.type   = TileFromColour,
-     .width  = TILE_WIDTH,
-     .height = TILE_HEIGHT,
-     .colour = (Pixel){.r = 0xdc, .g = 0x76, .b = 0x84, .a = 0xff}},
-};
-
-typedef enum Colour {
-  Black,
-  White,
-  Red,
-} Colour;
-
-typedef struct GfxAppState {
-  IsoBackend* backend;
-  IsoGfx*     iso;
-  Tile        red;
-  int         xpick;
-  int         ypick;
-} GfxAppState;
-
-static void make_checkerboard(IsoGfx* iso, Tile black, Tile white) {
-  assert(iso);
-  for (int y = 0; y < isogfx_world_height(iso); ++y) {
-    for (int x = 0; x < isogfx_world_width(iso); ++x) {
-      const int  odd_col = x & 1;
-      const int  odd_row = y & 1;
-      const Tile value   = (odd_row ^ odd_col) == 0 ? black : white;
-      isogfx_set_tile(iso, x, y, value);
-    }
-  }
-}
-
-static bool init(GfxAppState* state, int argc, const char** argv) {
-  assert(state);
-
-  (void)argc;
-  (void)argv;
-
-  if (!(state->iso = isogfx_new(&(IsoGfxDesc){
-            .screen_width = SCREEN_WIDTH, .screen_height = SCREEN_HEIGHT}))) {
-    return false;
-  }
-  IsoGfx* iso = state->iso;
-
-  isogfx_resize(iso, SCREEN_WIDTH, SCREEN_HEIGHT);
-
-  if (!isogfx_make_world(
-          iso, &(WorldDesc){
-                   .tile_width   = TILE_WIDTH,
-                   .tile_height  = TILE_HEIGHT,
-                   .world_width  = WORLD_WIDTH,
-                   .world_height = WORLD_HEIGHT})) {
-    return false;
-  }
-
-  const Tile black = isogfx_make_tile(iso, &tile_set[Black]);
-  const Tile white = isogfx_make_tile(iso, &tile_set[White]);
-  state->red       = isogfx_make_tile(iso, &tile_set[Red]);
-  make_checkerboard(iso, black, white);
-
-  if (!(state->backend = IsoBackendInit(iso))) {
-    return false;
-  }
-
-  return true;
-}
-
-static void shutdown(GfxAppState* state) {
-  assert(state);
-
-  IsoBackendShutdown(&state->backend);
-  isogfx_del(&state->iso);
-}
-
-static void update(GfxAppState* state, double t, double dt) {
-  assert(state);
-  (void)dt;
-
-  IsoGfx* iso = state->iso;
-
-  isogfx_update(iso, t);
-
-  // Get mouse position in window coordinates.
-  double mouse_x, mouse_y;
-  gfx_app_get_mouse_position(&mouse_x, &mouse_y);
-
-  // Map from window coordinates to virtual screen coordinates.
-  IsoBackendGetMousePosition(
-      state->backend, mouse_x, mouse_y, &mouse_x, &mouse_y);
-
-  isogfx_pick_tile(iso, mouse_x, mouse_y, &state->xpick, &state->ypick);
-
-  printf("Picked tile: (%d, %d)\n", state->xpick, state->ypick);
-}
-
-static void render(GfxAppState* state) {
-  assert(state);
-
-  IsoGfx* iso = state->iso;
-
-  isogfx_render(iso);
-
-  if ((state->xpick != -1) && (state->ypick != -1)) {
-    isogfx_draw_tile(iso, state->xpick, state->ypick, state->red);
-  }
-
-  IsoBackendRender(state->backend, iso);
-}
-
-static void resize(GfxAppState* state, int width, int height) {
-  assert(state);
-
-  IsoBackendResizeWindow(state->backend, state->iso, width, height);
-}
-
-int main(int argc, const char** argv) {
-  GfxAppState state = {0};
-  gfx_app_run(
-      &(GfxAppDesc){
-          .argc              = argc,
-          .argv              = argv,
-          .width             = WINDOW_WIDTH,
-          .height            = WINDOW_HEIGHT,
-          .max_fps           = MAX_FPS,
-          .update_delta_time = MAX_FPS > 0 ? 1.0 / (double)MAX_FPS : 0.0,
-          .title             = "Isometric Renderer",
-          .app_state         = &state},
-      &(GfxAppCallbacks){
-          .init     = init,
-          .update   = update,
-          .render   = render,
-          .resize   = resize,
-          .shutdown = shutdown});
-  return 0;
-}
diff --git a/gfx-iso/demos/isomap/CMakeLists.txt b/gfx-iso/demos/isomap/CMakeLists.txt
deleted file mode 100644
index 2dbfd32..0000000
--- a/gfx-iso/demos/isomap/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-
-project(isomap)
-
-set(CMAKE_C_STANDARD 17)
-set(CMAKE_C_STANDARD_REQUIRED On)
-set(CMAKE_C_EXTENSIONS Off)
-
-add_executable(isomap
-  isomap.c)
-
-target_link_libraries(isomap PRIVATE
-  gfx-app
-  isogfx-backend)
-
-target_compile_options(isomap PRIVATE -Wall -Wextra -Wpedantic)
diff --git a/gfx-iso/demos/isomap/isomap.c b/gfx-iso/demos/isomap/isomap.c
deleted file mode 100644
index a233659..0000000
--- a/gfx-iso/demos/isomap/isomap.c
+++ /dev/null
@@ -1,105 +0,0 @@
-#include <isogfx/backend.h>
-#include <isogfx/isogfx.h>
-
-#include <gfx/app.h>
-
-#include <assert.h>
-#include <stdbool.h>
-
-static const int WINDOW_WIDTH  = 1408;
-static const int WINDOW_HEIGHT = 960;
-static const int MAX_FPS       = 60;
-
-// Virtual screen dimensions.
-static const int SCREEN_WIDTH  = 704;
-static const int SCREEN_HEIGHT = 480;
-
-typedef struct GfxAppState {
-  IsoBackend* backend;
-  IsoGfx*     iso;
-  int         xpick;
-  int         ypick;
-  SpriteSheet stag_sheet;
-  Sprite      stag;
-} GfxAppState;
-
-static bool init(GfxAppState* state, int argc, const char** argv) {
-  assert(state);
-  (void)argc;
-  (void)argv;
-
-  if (!(state->iso = isogfx_new(&(IsoGfxDesc){
-            .screen_width = SCREEN_WIDTH, .screen_height = SCREEN_HEIGHT}))) {
-    return false;
-  }
-  IsoGfx* iso = state->iso;
-
-  isogfx_resize(iso, SCREEN_WIDTH, SCREEN_HEIGHT);
-
-  if (!isogfx_load_world(iso, "/home/jeanne/assets/tilemaps/demo1.tm")) {
-    return false;
-  }
-
-  if (!isogfx_load_sprite_sheet(
-          iso, "/home/jeanne/assets/tilesets/scrabling/critters/stag/stag.ss",
-          &state->stag_sheet)) {
-    return false;
-  }
-
-  state->stag = isogfx_make_sprite(iso, state->stag_sheet);
-  isogfx_set_sprite_position(iso, state->stag, 5, 4);
-
-  if (!(state->backend = IsoBackendInit(iso))) {
-    return false;
-  }
-
-  return true;
-}
-
-static void shutdown(GfxAppState* state) {
-  assert(state);
-  //
-}
-
-static void update(GfxAppState* state, double t, double dt) {
-  assert(state);
-  (void)dt;
-
-  IsoGfx* iso = state->iso;
-  isogfx_update(iso, t);
-}
-
-static void render(GfxAppState* state) {
-  assert(state);
-
-  IsoGfx* iso = state->iso;
-  isogfx_render(iso);
-  IsoBackendRender(state->backend, iso);
-}
-
-static void resize(GfxAppState* state, int width, int height) {
-  assert(state);
-
-  IsoBackendResizeWindow(state->backend, state->iso, width, height);
-}
-
-int main(int argc, const char** argv) {
-  GfxAppState state = {0};
-  gfx_app_run(
-      &(GfxAppDesc){
-          .argc              = argc,
-          .argv              = argv,
-          .width             = WINDOW_WIDTH,
-          .height            = WINDOW_HEIGHT,
-          .max_fps           = MAX_FPS,
-          .update_delta_time = MAX_FPS > 0 ? 1.0 / (double)MAX_FPS : 0.0,
-          .title             = "Isometric Renderer",
-          .app_state         = &state},
-      &(GfxAppCallbacks){
-          .init     = init,
-          .update   = update,
-          .render   = render,
-          .resize   = resize,
-          .shutdown = shutdown});
-  return 0;
-}
diff --git a/gfx-iso/include/isogfx/backend.h b/gfx-iso/include/isogfx/backend.h
deleted file mode 100644
index 172991d..0000000
--- a/gfx-iso/include/isogfx/backend.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-
-typedef struct Gfx    Gfx;
-typedef struct IsoGfx IsoGfx;
-
-typedef struct IsoBackend IsoBackend;
-
-/// Initialize the backend.
-IsoBackend* IsoBackendInit(const IsoGfx*);
-
-/// Shut down the backend.
-void IsoBackendShutdown(IsoBackend**);
-
-/// Notify the backend of a window resize event.
-/// This allows the backend to determine how to position and scale the iso
-/// screen buffer on the graphics window.
-void IsoBackendResizeWindow(IsoBackend*, const IsoGfx*, int width, int height);
-
-/// Render the iso screen to the graphics window.
-void IsoBackendRender(const IsoBackend*, const IsoGfx*);
-
-/// Map window coordinates to iso space coordinates.
-/// This takes into account any possible resizing done by the backend in
-/// response to calls to IsoBackendResizeWindow().
-bool IsoBackendGetMousePosition(
-    const IsoBackend*, double window_x, double window_y, double* x, double* y);
diff --git a/gfx-iso/include/isogfx/isogfx.h b/gfx-iso/include/isogfx/isogfx.h
deleted file mode 100644
index 3421a7b..0000000
--- a/gfx-iso/include/isogfx/isogfx.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * Isometric rendering engine.
- */
-#pragma once
-
-#include <stdbool.h>
-#include <stdint.h>
-
-typedef struct IsoGfx IsoGfx;
-
-/// Sprite sheet handle.
-typedef uint16_t SpriteSheet;
-
-/// Sprite handle.
-typedef uint16_t Sprite;
-
-/// Tile handle.
-typedef uint16_t Tile;
-
-/// Colour channel.
-typedef uint8_t Channel;
-
-typedef struct Pixel {
-  Channel r, g, b, a;
-} Pixel;
-
-typedef enum TileDescType {
-  TileFromColour,
-  TileFromFile,
-  TileFromMemory,
-} TileDescType;
-
-typedef struct TileDesc {
-  TileDescType type;
-  int          width;  /// Tile width in pixels.
-  int          height; /// Tile height in pixels.
-  union {
-    Pixel colour; /// Constant colour tile.
-    struct {
-      const char* path;
-    } file;
-    struct {
-      const uint8_t* data; /// sizeof(Pixel) * width * height
-    } mem;
-  };
-} TileDesc;
-
-typedef struct WorldDesc {
-  int tile_width;    /// Base tile width in pixels.
-  int tile_height;   /// Base tile height in pixels.
-  int world_width;   /// World width in tiles.
-  int world_height;  /// World height in tiles.
-  int max_num_tiles; /// 0 for an implementation-defined default.
-} WorldDesc;
-
-typedef struct IsoGfxDesc {
-  int screen_width;                 /// Screen width in pixels.
-  int screen_height;                /// Screen height in pixels.
-  int max_num_sprites;              /// 0 for an implementation-defined default.
-  int sprite_sheet_pool_size_bytes; /// 0 for an implementation-defined default.
-} IsoGfxDesc;
-
-/// Create a new isometric graphics engine.
-IsoGfx* isogfx_new(const IsoGfxDesc*);
-
-/// Destroy the isometric graphics engine.
-void isogfx_del(IsoGfx**);
-
-/// Create an empty world.
-bool isogfx_make_world(IsoGfx*, const WorldDesc*);
-
-/// Load a world from a tile map (.TM) file.
-bool isogfx_load_world(IsoGfx*, const char* filepath);
-
-/// Return the world's width.
-int isogfx_world_width(const IsoGfx*);
-
-/// Return the world's height.
-int isogfx_world_height(const IsoGfx*);
-
-/// Create a new tile.
-Tile isogfx_make_tile(IsoGfx*, const TileDesc*);
-
-/// Set the tile at position (x,y).
-void isogfx_set_tile(IsoGfx*, int x, int y, Tile);
-
-/// Set the tiles in positions in the range (x0,y0) - (x1,y1).
-void isogfx_set_tiles(IsoGfx*, int x0, int y0, int x1, int y1, Tile);
-
-/// Load a sprite sheet (.SS) file.
-bool isogfx_load_sprite_sheet(IsoGfx*, const char* filepath, SpriteSheet*);
-
-/// Create an animated sprite.
-Sprite isogfx_make_sprite(IsoGfx*, SpriteSheet);
-
-/// Destroy the sprite.
-void isogfx_del_sprite(IsoGfx*, Sprite);
-
-/// Destroy all the sprites.
-void isogfx_del_sprites(IsoGfx*);
-
-/// Set the sprite's position.
-void isogfx_set_sprite_position(IsoGfx*, Sprite, int x, int y);
-
-/// Set the sprite's current animation.
-void isogfx_set_sprite_animation(IsoGfx*, Sprite, int animation);
-
-/// Update the renderer.
-///
-/// Currently this updates the sprite animations.
-void isogfx_update(IsoGfx*, double t);
-
-/// Render the world.
-void isogfx_render(IsoGfx*);
-
-/// Draw/overlay a tile at position (x,y).
-///
-/// This function just renders a tile at position (x,y) and should be called
-/// after isogfx_render() to obtain the correct result. To set the tile at
-/// position (x,y) instead, use isogfx_set_tile().
-void isogfx_draw_tile(IsoGfx*, int x, int y, Tile);
-
-/// Resize the virtual screen's dimensions.
-bool isogfx_resize(IsoGfx*, int screen_width, int screen_height);
-
-/// Get the virtual screen's dimensions.
-void isogfx_get_screen_size(const IsoGfx*, int* width, int* height);
-
-/// Return a pointer to the virtual screen's colour buffer.
-///
-/// Call after each call to isogfx_render() to retrieve the render output.
-const Pixel* isogfx_get_screen_buffer(const IsoGfx*);
-
-/// Translate Cartesian to isometric coordinates.
-void isogfx_pick_tile(
-    const IsoGfx*, double xcart, double ycart, int* xiso, int* yiso);
diff --git a/gfx-iso/src/backend.c b/gfx-iso/src/backend.c
deleted file mode 100644
index db91647..0000000
--- a/gfx-iso/src/backend.c
+++ /dev/null
@@ -1,199 +0,0 @@
-#include <isogfx/backend.h>
-#include <isogfx/isogfx.h>
-
-#include <gfx/core.h>
-#include <gfx/gfx.h>
-#include <gfx/renderer.h>
-#include <gfx/scene.h>
-#include <gfx/util/geometry.h>
-#include <gfx/util/shader.h>
-
-#include <assert.h>
-#include <stdlib.h>
-
-typedef struct IsoBackend {
-  Gfx*   gfx;
-  Scene* scene;
-  /// The screen or "iso screen" refers to the colour buffer of the iso graphics
-  /// library. This texture is used to draw the iso screen onto the graphics
-  /// window.
-  Texture* screen_texture;
-  /// Window size.
-  int window_width;
-  int window_height;
-  /// The viewport refers to the area inside the window to which screen_texture
-  /// is drawn. It is a scaled version of the iso screen, scaled while
-  /// respecting the iso screen's aspect ratio to prevent distortion.
-  int    viewport_x, viewport_y, viewport_width, viewport_height;
-  double stretch; // Stretch factor from iso screen dimensions to viewport
-                  // dimensions.
-} IsoBackend;
-
-IsoBackend* IsoBackendInit(const IsoGfx* iso) {
-  assert(iso);
-
-  IsoBackend* backend = calloc(1, sizeof(IsoBackend));
-  if (!backend) {
-    return 0;
-  }
-
-  if (!(backend->gfx = gfx_init())) {
-    goto cleanup;
-  }
-  GfxCore* gfxcore = gfx_get_core(backend->gfx);
-
-  int screen_width, screen_height;
-  isogfx_get_screen_size(iso, &screen_width, &screen_height);
-
-  if (!(backend->screen_texture = gfx_make_texture(
-            gfxcore, &(TextureDesc){
-                         .width     = screen_width,
-                         .height    = screen_height,
-                         .dimension = Texture2D,
-                         .format    = TextureSRGBA8,
-                         .filtering = NearestFiltering,
-                         .wrap      = ClampToEdge,
-                         .mipmaps   = false}))) {
-    goto cleanup;
-  }
-
-  ShaderProgram* shader = gfx_make_view_texture_shader(gfxcore);
-  if (!shader) {
-    goto cleanup;
-  }
-
-  Geometry* geometry = gfx_make_quad_11(gfxcore);
-  if (!geometry) {
-    goto cleanup;
-  }
-
-  MaterialDesc material_desc = (MaterialDesc){.num_uniforms = 1};
-  material_desc.uniforms[0]  = (ShaderUniform){
-       .type          = UniformTexture,
-       .value.texture = backend->screen_texture,
-       .name          = sstring_make("Texture")};
-  Material* material = gfx_make_material(&material_desc);
-  if (!material) {
-    return false;
-  }
-
-  const MeshDesc mesh_desc =
-      (MeshDesc){.geometry = geometry, .material = material, .shader = shader};
-  Mesh* mesh = gfx_make_mesh(&mesh_desc);
-  if (!mesh) {
-    goto cleanup;
-  }
-
-  SceneObject* object =
-      gfx_make_object(&(ObjectDesc){.num_meshes = 1, .meshes = {mesh}});
-  if (!object) {
-    goto cleanup;
-  }
-
-  backend->scene  = gfx_make_scene();
-  SceneNode* node = gfx_make_object_node(object);
-  SceneNode* root = gfx_get_scene_root(backend->scene);
-  gfx_set_node_parent(node, root);
-
-  return backend;
-
-cleanup:
-  if (backend->gfx) {
-    gfx_destroy(&backend->gfx);
-  }
-  free(backend);
-  return 0;
-}
-
-void IsoBackendShutdown(IsoBackend** ppApp) {
-  assert(ppApp);
-
-  IsoBackend* app = *ppApp;
-  if (!app) {
-    return;
-  }
-
-  gfx_destroy(&app->gfx);
-}
-
-void IsoBackendResizeWindow(
-    IsoBackend* app, const IsoGfx* iso, int width, int height) {
-  assert(app);
-  assert(iso);
-
-  app->window_width  = width;
-  app->window_height = height;
-
-  // Virtual screen dimensions.
-  int screen_width, screen_height;
-  isogfx_get_screen_size(iso, &screen_width, &screen_height);
-
-  // Stretch the virtual screen onto the viewport while respecting the screen's
-  // aspect ratio to prevent distortion.
-  if (width > height) { // Wide screen.
-    app->stretch         = (double)height / (double)screen_height;
-    app->viewport_width  = (int)((double)screen_width * app->stretch);
-    app->viewport_height = height;
-    app->viewport_x      = (width - app->viewport_width) / 2;
-    app->viewport_y      = 0;
-  } else { // Tall screen.
-    app->stretch         = (double)width / (double)screen_width;
-    app->viewport_width  = width;
-    app->viewport_height = (int)((float)screen_height * app->stretch);
-    app->viewport_x      = 0;
-    app->viewport_y      = (height - app->viewport_height) / 2;
-  }
-}
-
-void IsoBackendRender(const IsoBackend* app, const IsoGfx* iso) {
-  assert(app);
-  assert(iso);
-
-  const Pixel* screen = isogfx_get_screen_buffer(iso);
-  assert(screen);
-  gfx_update_texture(app->screen_texture, &(TextureDataDesc){.pixels = screen});
-
-  GfxCore*  gfxcore  = gfx_get_core(app->gfx);
-  Renderer* renderer = gfx_get_renderer(app->gfx);
-
-  // Clear the whole window.
-  gfx_set_viewport(gfxcore, 0, 0, app->window_width, app->window_height);
-  gfx_clear(gfxcore, vec4_make(0, 0, 0, 0));
-
-  // Draw to the subregion where the virtual screen can stretch without
-  // distortion.
-  gfx_set_viewport(
-      gfxcore, app->viewport_x, app->viewport_y, app->viewport_width,
-      app->viewport_height);
-
-  // Render the iso screen.
-  gfx_start_frame(gfxcore);
-  gfx_render_scene(
-      renderer, &(RenderSceneParams){
-                    .mode = RenderDefault, .scene = app->scene, .camera = 0});
-  gfx_end_frame(gfxcore);
-}
-
-bool IsoBackendGetMousePosition(
-    const IsoBackend* app, double window_x, double window_y, double* x,
-    double* y) {
-  assert(app);
-
-  // Translate from window coordinates to the subregion where the stretched
-  // iso screen is rendered.
-  const double screen_x = window_x - app->viewport_x;
-  const double screen_y = window_y - app->viewport_y;
-
-  // Position may be out of bounds.
-  if ((0 <= screen_x) && (screen_x < app->viewport_width) && (0 <= screen_y) &&
-      (screen_y < app->viewport_height)) {
-    // Scale back from the stretched subregion to the iso screen dimensions.
-    *x = screen_x / app->stretch;
-    *y = screen_y / app->stretch;
-    return true;
-  } else {
-    *x = -1;
-    *y = -1;
-    return false;
-  }
-}
diff --git a/gfx-iso/src/isogfx.c b/gfx-iso/src/isogfx.c
deleted file mode 100644
index 52c4ae2..0000000
--- a/gfx-iso/src/isogfx.c
+++ /dev/null
@@ -1,952 +0,0 @@
-#include <isogfx/isogfx.h>
-
-#include <filesystem.h>
-#include <mem.h>
-#include <mempool.h>
-#include <path.h>
-
-#include <linux/limits.h>
-
-#include <assert.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-/// Maximum number of tiles unless the user specifies a value.
-#define DEFAULT_MAX_NUM_TILES 1024
-
-/// Maximum number of sprites unless the user specifies a value.
-#define DEFAULT_MAX_NUM_SPRITES 128
-
-/// Size of sprite sheet pool in bytes unless the user specifies a value.
-#define DEFAULT_SPRITE_SHEET_POOL_SIZE_BYTES (8 * 1024 * 1024)
-
-/// Default animation speed.
-#define ANIMATION_FPS 10
-
-/// Time between animation updates.
-#define ANIMATION_UPDATE_DELTA (1.0 / ANIMATION_FPS)
-
-typedef struct ivec2 {
-  int x, y;
-} ivec2;
-
-typedef struct vec2 {
-  double x, y;
-} vec2;
-
-// -----------------------------------------------------------------------------
-// Tile set (TS) and tile map (TM) file formats.
-// -----------------------------------------------------------------------------
-
-/// Maximum length of path strings in .TS and .TM files.
-#define MAX_PATH_LENGTH 128
-
-typedef struct Ts_Tile {
-  uint16_t width;     /// Tile width in pixels.
-  uint16_t height;    /// Tile height in pixels.
-  Pixel    pixels[1]; /// Count: width * height.
-} Ts_Tile;
-
-typedef struct Ts_TileSet {
-  uint16_t num_tiles;
-  uint16_t max_tile_width;  /// Maximum tile width in pixels.
-  uint16_t max_tile_height; /// Maximum tile height in pixels.
-  Ts_Tile  tiles[1];        /// Count: num_tiles.
-} Ts_TileSet;
-
-typedef struct Tm_Layer {
-  union {
-    char tileset_path[MAX_PATH_LENGTH]; // Relative to the Tm_Map file.
-  };
-  Tile tiles[1]; /// Count: world_width * world_height.
-} Tm_Layer;
-
-typedef struct Tm_Map {
-  uint16_t world_width;  /// World width in number of tiles.
-  uint16_t world_height; /// World height in number of tiles.
-  uint16_t base_tile_width;
-  uint16_t base_tile_height;
-  uint16_t num_layers;
-  Tm_Layer layers[1]; // Count: num_layers.
-} Tm_Map;
-
-static inline const Tm_Layer* tm_map_get_next_layer(
-    const Tm_Map* map, const Tm_Layer* layer) {
-  assert(map);
-  assert(layer);
-  return (const Tm_Layer*)((const uint8_t*)layer + sizeof(Tm_Layer) +
-                           ((map->world_width * map->world_height - 1) *
-                            sizeof(Tile)));
-}
-
-static inline const Ts_Tile* ts_tileset_get_next_tile(
-    const Ts_TileSet* tileset, const Ts_Tile* tile) {
-  assert(tileset);
-  assert(tile);
-  return (const Ts_Tile*)((const uint8_t*)tile + sizeof(Ts_Tile) +
-                          ((tile->width * tile->height - 1) * sizeof(Pixel)));
-}
-
-// -----------------------------------------------------------------------------
-// Sprite sheet file format.
-// -----------------------------------------------------------------------------
-
-/// A row of sprites in a sprite sheet.
-///
-/// Each row in a sprite sheet can have a different number of columns.
-///
-/// The pixels of the row follow a "sprite-major" order. It contains the
-/// 'sprite_width * sprite_height' pixels for the first column/sprite, then the
-/// second column/sprite, etc.
-///
-/// Pixels are 8-bit indices into the sprite sheet's colour palette.
-typedef struct Ss_Row {
-  uint16_t num_cols;  /// Number of columns in this row.
-  uint8_t  pixels[1]; /// Count: num_cols * sprite_width * sprite_height.
-} Ss_Row;
-
-typedef struct Ss_Palette {
-  uint16_t num_colours;
-  Pixel    colours[1]; /// Count: num_colors.
-} Ss_Palette;
-
-/// Sprite sheet top-level data definition.
-///
-/// Sprite width and height are assumed constant throughout the sprite sheet.
-typedef struct Ss_SpriteSheet {
-  uint16_t   sprite_width;  /// Sprite width in pixels.
-  uint16_t   sprite_height; /// Sprite height in pixels.
-  uint16_t   num_rows;
-  Ss_Palette palette; /// Variable size.
-  Ss_Row     rows[1]; /// Count: num_rows. Variable offset.
-} Ss_SpriteSheet;
-
-static inline const Ss_Row* get_sprite_sheet_row(
-    const Ss_SpriteSheet* sheet, int row) {
-  assert(sheet);
-  assert(row >= 0);
-  assert(row < sheet->num_rows);
-  // Skip over the palette.
-  const Ss_Row* rows =
-      (const Ss_Row*)(&sheet->palette.colours[0] + sheet->palette.num_colours);
-  return &rows[row];
-}
-
-static inline const uint8_t* get_sprite_sheet_sprite(
-    const Ss_SpriteSheet* sheet, const Ss_Row* row, int col) {
-  assert(sheet);
-  assert(row);
-  assert(col >= 0);
-  assert(col < row->num_cols);
-  const int sprite_offset = col * sheet->sprite_width * sheet->sprite_height;
-  const uint8_t* sprite   = &row->pixels[sprite_offset];
-  return sprite;
-}
-
-// -----------------------------------------------------------------------------
-// Renderer state.
-// -----------------------------------------------------------------------------
-
-typedef struct TileData {
-  uint16_t width;
-  uint16_t height;
-  uint16_t pixels_handle; // Handle to the tile's pixels in the pixel pool.
-} TileData;
-
-// File format is already convenient for working in memory.
-typedef Ss_Row         SpriteSheetRow;
-typedef Ss_SpriteSheet SpriteSheetData;
-
-typedef struct SpriteData {
-  SpriteSheet sheet; // Handle to the sprite's sheet.
-  ivec2       position;
-  int         animation; // Current animation.
-  int         frame;     // Current frame of animation.
-} SpriteData;
-
-DEF_MEMPOOL_DYN(TilePool, TileData)
-DEF_MEM_DYN(PixelPool, Pixel)
-
-DEF_MEMPOOL_DYN(SpritePool, SpriteData)
-DEF_MEM_DYN(SpriteSheetPool, SpriteSheetData)
-
-typedef struct IsoGfx {
-  int             screen_width;
-  int             screen_height;
-  int             tile_width;
-  int             tile_height;
-  int             world_width;
-  int             world_height;
-  int             max_num_sprites;
-  int             sprite_sheet_pool_size_bytes;
-  double          last_animation_time;
-  Tile*           world;
-  Pixel*          screen;
-  TilePool        tiles;
-  PixelPool       pixels;
-  SpritePool      sprites;
-  SpriteSheetPool sheets;
-} IsoGfx;
-
-// -----------------------------------------------------------------------------
-// Math and world / tile / screen access.
-// -----------------------------------------------------------------------------
-
-static inline ivec2 ivec2_add(ivec2 a, ivec2 b) {
-  return (ivec2){.x = a.x + b.x, .y = a.y + b.y};
-}
-
-static inline ivec2 ivec2_scale(ivec2 a, int s) {
-  return (ivec2){.x = a.x * s, .y = a.y * s};
-}
-
-static inline ivec2 iso2cart(ivec2 iso, int s, int t, int w) {
-  return (ivec2){
-      .x = (iso.x - iso.y) * (s / 2) + (w / 2), .y = (iso.x + iso.y) * (t / 2)};
-}
-
-// Method 1.
-// static inline vec2 cart2iso(vec2 cart, int s, int t, int w) {
-//  const double x    = cart.x - (double)(w / 2);
-//  const double xiso = (x * t + cart.y * s) / (double)(s * t);
-//  return (vec2){
-//      .x = (int)(xiso), .y = (int)((2.0 / (double)t) * cart.y - xiso)};
-//}
-
-// Method 2.
-static inline vec2 cart2iso(vec2 cart, int s, int t, int w) {
-  const double one_over_s = 1. / (double)s;
-  const double one_over_t = 1. / (double)t;
-  const double x          = cart.x - (double)(w / 2);
-  return (vec2){
-      .x = (one_over_s * x + one_over_t * cart.y),
-      .y = (-one_over_s * x + one_over_t * cart.y)};
-}
-
-static const Pixel* tile_xy_const_ref(
-    const IsoGfx* iso, const TileData* tile, int x, int y) {
-  assert(iso);
-  assert(tile);
-  assert(x >= 0);
-  assert(y >= 0);
-  assert(x < tile->width);
-  assert(y < tile->height);
-  return &mem_get_chunk(&iso->pixels, tile->pixels_handle)[y * tile->width + x];
-}
-
-// static Pixel tile_xy(const IsoGfx* iso, const TileData* tile, int x, int y) {
-//   return *tile_xy_const_ref(iso, tile, x, y);
-// }
-
-static Pixel* tile_xy_mut(const IsoGfx* iso, TileData* tile, int x, int y) {
-  return (Pixel*)tile_xy_const_ref(iso, tile, x, y);
-}
-
-static inline const Tile* world_xy_const_ref(const IsoGfx* iso, int x, int y) {
-  assert(iso);
-  assert(x >= 0);
-  assert(y >= 0);
-  assert(x < iso->world_width);
-  assert(y < iso->world_height);
-  return &iso->world[y * iso->world_width + x];
-}
-
-static inline Tile world_xy(const IsoGfx* iso, int x, int y) {
-  return *world_xy_const_ref(iso, x, y);
-}
-
-static inline Tile* world_xy_mut(IsoGfx* iso, int x, int y) {
-  return (Tile*)world_xy_const_ref(iso, x, y);
-}
-
-static inline const Pixel* screen_xy_const_ref(
-    const IsoGfx* iso, int x, int y) {
-  assert(iso);
-  assert(x >= 0);
-  assert(y >= 0);
-  assert(x < iso->screen_width);
-  assert(y < iso->screen_height);
-  return &iso->screen[y * iso->screen_width + x];
-}
-
-static inline Pixel screen_xy(IsoGfx* iso, int x, int y) {
-  return *screen_xy_const_ref(iso, x, y);
-}
-
-static inline Pixel* screen_xy_mut(IsoGfx* iso, int x, int y) {
-  return (Pixel*)screen_xy_const_ref(iso, x, y);
-}
-
-static int calc_num_tile_blocks(
-    int base_tile_width, int base_tile_height, int tile_width,
-    int tile_height) {
-  const int base_tile_size = base_tile_width * base_tile_height;
-  const int tile_size      = tile_width * tile_height;
-  const int num_blocks     = tile_size / base_tile_size;
-  return num_blocks;
-}
-
-// -----------------------------------------------------------------------------
-// Renderer, world and tile management.
-// -----------------------------------------------------------------------------
-
-IsoGfx* isogfx_new(const IsoGfxDesc* desc) {
-  assert(desc->screen_width > 0);
-  assert(desc->screen_height > 0);
-  // Part of our implementation assumes even widths and heights for precision.
-  assert((desc->screen_width & 1) == 0);
-  assert((desc->screen_height & 1) == 0);
-
-  IsoGfx* iso = calloc(1, sizeof(IsoGfx));
-  if (!iso) {
-    return 0;
-  }
-
-  iso->screen_width  = desc->screen_width;
-  iso->screen_height = desc->screen_height;
-
-  iso->last_animation_time = 0.0;
-
-  iso->max_num_sprites = desc->max_num_sprites == 0 ? DEFAULT_MAX_NUM_SPRITES
-                                                    : desc->max_num_sprites;
-  iso->sprite_sheet_pool_size_bytes = desc->sprite_sheet_pool_size_bytes == 0
-                                          ? DEFAULT_SPRITE_SHEET_POOL_SIZE_BYTES
-                                          : desc->sprite_sheet_pool_size_bytes;
-
-  const int screen_size = desc->screen_width * desc->screen_height;
-  if (!(iso->screen = calloc(screen_size, sizeof(Pixel)))) {
-    goto cleanup;
-  }
-
-  return iso;
-
-cleanup:
-  isogfx_del(&iso);
-  return 0;
-}
-
-/// Destroy the world, its tile set, and the underlying pools.
-static void destroy_world(IsoGfx* iso) {
-  assert(iso);
-  if (iso->world) {
-    free(iso->world);
-    iso->world = 0;
-  }
-  mempool_del(&iso->tiles);
-  mem_del(&iso->pixels);
-}
-
-/// Destroy all loaded sprites and the underlying pools.
-static void destroy_sprites(IsoGfx* iso) {
-  assert(iso);
-  mempool_del(&iso->sprites);
-  mem_del(&iso->sheets);
-}
-
-void isogfx_del(IsoGfx** pIso) {
-  assert(pIso);
-  IsoGfx* iso = *pIso;
-  if (iso) {
-    destroy_world(iso);
-    destroy_sprites(iso);
-    if (iso->screen) {
-      free(iso->screen);
-      iso->screen = 0;
-    }
-    free(iso);
-    *pIso = 0;
-  }
-}
-
-bool isogfx_make_world(IsoGfx* iso, const WorldDesc* desc) {
-  assert(iso);
-  assert(desc);
-  assert(desc->tile_width > 0);
-  assert(desc->tile_height > 0);
-  // Part of our implementation assumes even widths and heights for greater
-  // precision.
-  assert((desc->tile_width & 1) == 0);
-  assert((desc->tile_height & 1) == 0);
-
-  // Handle recreation by destroying the previous world.
-  destroy_world(iso);
-
-  iso->tile_width   = desc->tile_width;
-  iso->tile_height  = desc->tile_height;
-  iso->world_width  = desc->world_width;
-  iso->world_height = desc->world_height;
-
-  const int world_size      = desc->world_width * desc->world_height;
-  const int tile_size       = desc->tile_width * desc->tile_height;
-  const int tile_size_bytes = tile_size * (int)sizeof(Pixel);
-  const int tile_pool_size =
-      desc->max_num_tiles > 0 ? desc->max_num_tiles : DEFAULT_MAX_NUM_TILES;
-
-  if (!(iso->world = calloc(world_size, sizeof(Tile)))) {
-    goto cleanup;
-  }
-  if (!mempool_make_dyn(&iso->tiles, world_size, sizeof(TileData))) {
-    goto cleanup;
-  }
-  if (!mem_make_dyn(&iso->pixels, tile_pool_size, tile_size_bytes)) {
-    goto cleanup;
-  }
-
-  return true;
-
-cleanup:
-  destroy_world(iso);
-  return false;
-}
-
-bool isogfx_load_world(IsoGfx* iso, const char* filepath) {
-  assert(iso);
-  assert(filepath);
-
-  bool success = false;
-
-  // Handle recreation by destroying the previous world.
-  destroy_world(iso);
-
-  // Load the map.
-  printf("Load tile map: %s\n", filepath);
-  Tm_Map* map = read_file(filepath);
-  if (!map) {
-    goto cleanup;
-  }
-
-  // Allocate memory for the map and tile sets.
-  const int world_size           = map->world_width * map->world_height;
-  const int base_tile_size       = map->base_tile_width * map->base_tile_height;
-  const int base_tile_size_bytes = base_tile_size * (int)sizeof(Pixel);
-  // TODO: Need to get the total number of tiles from the map.
-  const int tile_pool_size = DEFAULT_MAX_NUM_TILES;
-
-  if (!(iso->world = calloc(world_size, sizeof(Tile)))) {
-    goto cleanup;
-  }
-  if (!mempool_make_dyn(&iso->tiles, tile_pool_size, sizeof(TileData))) {
-    goto cleanup;
-  }
-  if (!mem_make_dyn(&iso->pixels, tile_pool_size, base_tile_size_bytes)) {
-    goto cleanup;
-  }
-
-  // Load the tile sets.
-  const Tm_Layer* layer = &map->layers[0];
-  // TODO: Handle num_layers layers.
-  for (int i = 0; i < 1; ++i) {
-    const char* ts_path = layer->tileset_path;
-
-    // Tile set path is relative to the tile map file. Make it relative to the
-    // current working directory before loading.
-    char ts_path_cwd[PATH_MAX] = {0};
-    if (!path_make_relative(filepath, ts_path, ts_path_cwd, PATH_MAX)) {
-      goto cleanup;
-    }
-
-    Ts_TileSet* tileset = read_file(ts_path_cwd);
-    if (!tileset) {
-      goto cleanup;
-    };
-
-    // Load tile data.
-    const Ts_Tile* tile = &tileset->tiles[0];
-    for (uint16_t j = 0; j < tileset->num_tiles; ++j) {
-      // Tile dimensions should be a multiple of the base tile size.
-      assert((tile->width % map->base_tile_width) == 0);
-      assert((tile->height % map->base_tile_height) == 0);
-
-      // Allocate N base tile size blocks for the tile.
-      const uint16_t tile_size  = tile->width * tile->height;
-      const int      num_blocks = tile_size / base_tile_size;
-      Pixel*         pixels     = mem_alloc(&iso->pixels, num_blocks);
-      assert(pixels);
-      memcpy(pixels, tile->pixels, tile_size * sizeof(Pixel));
-
-      // Allocate the tile data.
-      TileData* tile_data = mempool_alloc(&iso->tiles);
-      assert(tile_data);
-      tile_data->width  = tile->width;
-      tile_data->height = tile->height;
-      tile_data->pixels_handle =
-          (uint16_t)mem_get_chunk_handle(&iso->pixels, pixels);
-
-      tile = ts_tileset_get_next_tile(tileset, tile);
-    }
-
-    printf("Loaded tile set (%u tiles): %s\n", tileset->num_tiles, ts_path_cwd);
-
-    free(tileset);
-    layer = tm_map_get_next_layer(map, layer);
-  }
-
-  // Load the map into the world.
-  layer = &map->layers[0];
-  // TODO: Handle num_layers layers.
-  for (int i = 0; i < 1; ++i) {
-    memcpy(iso->world, layer->tiles, world_size * sizeof(Tile));
-
-    // TODO: We need to handle 'firsgid' in TMX files.
-    for (int j = 0; j < world_size; ++j) {
-      iso->world[j] -= 1;
-    }
-
-    layer = tm_map_get_next_layer(map, layer);
-  }
-
-  iso->world_width  = map->world_width;
-  iso->world_height = map->world_height;
-  iso->tile_width   = map->base_tile_width;
-  iso->tile_height  = map->base_tile_height;
-
-  success = true;
-
-cleanup:
-  if (map) {
-    free(map);
-  }
-  if (!success) {
-    destroy_world(iso);
-  }
-  return success;
-}
-
-int isogfx_world_width(const IsoGfx* iso) {
-  assert(iso);
-  return iso->world_width;
-}
-
-int isogfx_world_height(const IsoGfx* iso) {
-  assert(iso);
-  return iso->world_height;
-}
-
-/// Create a tile mask procedurally.
-static void make_tile_from_colour(
-    const IsoGfx* iso, Pixel colour, TileData* tile) {
-  assert(iso);
-  assert(tile);
-
-  const int width  = tile->width;
-  const int height = tile->height;
-  const int r      = width / height;
-
-  for (int y = 0; y < height / 2; ++y) {
-    const int mask_start = width / 2 - r * y - 1;
-    const int mask_end   = width / 2 + r * y + 1;
-    for (int x = 0; x < width; ++x) {
-      const bool  mask = (mask_start <= x) && (x <= mask_end);
-      const Pixel val = mask ? colour : (Pixel){.r = 0, .g = 0, .b = 0, .a = 0};
-
-      // Top half.
-      *tile_xy_mut(iso, tile, x, y) = val;
-
-      // Bottom half reflects the top half.
-      const int y_reflected                   = height - y - 1;
-      *tile_xy_mut(iso, tile, x, y_reflected) = val;
-    }
-  }
-}
-
-Tile isogfx_make_tile(IsoGfx* iso, const TileDesc* desc) {
-  assert(iso);
-  assert(desc);
-  // Client must create world before creating tiles.
-  assert(iso->tile_width > 0);
-  assert(iso->tile_height > 0);
-
-  TileData* tile = mempool_alloc(&iso->tiles);
-  assert(tile); // TODO: Make this a hard assert.
-
-  const int num_blocks = calc_num_tile_blocks(
-      iso->tile_width, iso->tile_height, desc->width, desc->height);
-
-  Pixel* pixels = mem_alloc(&iso->pixels, num_blocks);
-  assert(pixels); // TODO: Make this a hard assert.
-
-  tile->width         = desc->width;
-  tile->height        = desc->height;
-  tile->pixels_handle = mem_get_chunk_handle(&iso->pixels, pixels);
-
-  switch (desc->type) {
-  case TileFromColour:
-    make_tile_from_colour(iso, desc->colour, tile);
-    break;
-  case TileFromFile:
-    assert(false); // TODO
-    break;
-  case TileFromMemory:
-    assert(false); // TODO
-    break;
-  }
-
-  return (Tile)mempool_get_block_index(&iso->tiles, tile);
-}
-
-void isogfx_set_tile(IsoGfx* iso, int x, int y, Tile tile) {
-  assert(iso);
-  *world_xy_mut(iso, x, y) = tile;
-}
-
-void isogfx_set_tiles(IsoGfx* iso, int x0, int y0, int x1, int y1, Tile tile) {
-  assert(iso);
-  for (int y = y0; y < y1; ++y) {
-    for (int x = x0; x < x1; ++x) {
-      isogfx_set_tile(iso, x, y, tile);
-    }
-  }
-}
-
-bool isogfx_load_sprite_sheet(
-    IsoGfx* iso, const char* filepath, SpriteSheet* p_sheet) {
-  assert(iso);
-  assert(filepath);
-  assert(p_sheet);
-
-  bool success = false;
-
-  // Lazy initialization of sprite pools.
-  if (mempool_capacity(&iso->sprites) == 0) {
-    if (!mempool_make_dyn(
-            &iso->sprites, iso->max_num_sprites, sizeof(SpriteData))) {
-      return false;
-    }
-  }
-  if (mem_capacity(&iso->sheets) == 0) {
-    // Using a block size of 1 byte for sprite sheet data.
-    if (!mem_make_dyn(&iso->sheets, iso->sprite_sheet_pool_size_bytes, 1)) {
-      return false;
-    }
-  }
-
-  // Load sprite sheet file.
-  printf("Load sprite sheet: %s\n", filepath);
-  FILE* file = fopen(filepath, "rb");
-  if (file == NULL) {
-    goto cleanup;
-  }
-  const size_t     sheet_size = get_file_size(file);
-  SpriteSheetData* ss_sheet   = mem_alloc(&iso->sheets, sheet_size);
-  if (!ss_sheet) {
-    goto cleanup;
-  }
-  if (fread(ss_sheet, sheet_size, 1, file) != 1) {
-    goto cleanup;
-  }
-
-  *p_sheet = mem_get_chunk_handle(&iso->sheets, ss_sheet);
-  success  = true;
-
-cleanup:
-  // Pools remain initialized since client may attempt to load other sprites.
-  if (file != NULL) {
-    fclose(file);
-  }
-  if (!success) {
-    if (ss_sheet) {
-      mem_free(&iso->sheets, &ss_sheet);
-    }
-  }
-  return success;
-}
-
-Sprite isogfx_make_sprite(IsoGfx* iso, SpriteSheet sheet) {
-  assert(iso);
-
-  SpriteData* sprite = mempool_alloc(&iso->sprites);
-  assert(sprite);
-
-  sprite->sheet = sheet;
-
-  return mempool_get_block_index(&iso->sprites, sprite);
-}
-
-#define with_sprite(SPRITE, BODY)                                \
-  {                                                              \
-    SpriteData* data = mempool_get_block(&iso->sprites, sprite); \
-    assert(data);                                                \
-    BODY;                                                        \
-  }
-
-void isogfx_set_sprite_position(IsoGfx* iso, Sprite sprite, int x, int y) {
-  assert(iso);
-  with_sprite(sprite, {
-    data->position.x = x;
-    data->position.y = y;
-  });
-}
-
-void isogfx_set_sprite_animation(IsoGfx* iso, Sprite sprite, int animation) {
-  assert(iso);
-  with_sprite(sprite, { data->animation = animation; });
-}
-
-void isogfx_update(IsoGfx* iso, double t) {
-  assert(iso);
-
-  // If this is the first time update() is called after initialization, just
-  // record the starting animation time.
-  if (iso->last_animation_time == 0.0) {
-    iso->last_animation_time = t;
-    return;
-  }
-
-  if ((t - iso->last_animation_time) >= ANIMATION_UPDATE_DELTA) {
-    // TODO: Consider linking animated sprites in a list so that we only walk
-    // over those here and not also the static sprites.
-    mempool_foreach(&iso->sprites, sprite, {
-      const SpriteSheetData* sheet = mem_get_chunk(&iso->sheets, sprite->sheet);
-      assert(sheet); // TODO: Make this a hard assert inside the mem/pool.
-      const SpriteSheetRow* row =
-          get_sprite_sheet_row(sheet, sprite->animation);
-      sprite->frame = (sprite->frame + 1) % row->num_cols;
-    });
-
-    iso->last_animation_time = t;
-  }
-}
-
-// -----------------------------------------------------------------------------
-// Rendering and picking.
-// -----------------------------------------------------------------------------
-
-typedef struct CoordSystem {
-  ivec2 o; /// Origin.
-  ivec2 x;
-  ivec2 y;
-} CoordSystem;
-
-/// Create the basis for the isometric coordinate system with origin and vectors
-/// expressed in the Cartesian system.
-static CoordSystem make_iso_coord_system(const IsoGfx* iso) {
-  assert(iso);
-  const ivec2 o = {iso->screen_width / 2, 0};
-  const ivec2 x = {.x = iso->tile_width / 2, .y = iso->tile_height / 2};
-  const ivec2 y = {.x = -iso->tile_width / 2, .y = iso->tile_height / 2};
-  return (CoordSystem){o, x, y};
-}
-
-/// Get the screen position of the top diamond-corner of the tile at world
-/// (x,y).
-static ivec2 GetTileScreenOrigin(
-    const CoordSystem iso_space, int world_x, int world_y) {
-  const ivec2 vx_offset = ivec2_scale(iso_space.x, world_x);
-  const ivec2 vy_offset = ivec2_scale(iso_space.y, world_y);
-  const ivec2 screen_origin =
-      ivec2_add(iso_space.o, ivec2_add(vx_offset, vy_offset));
-
-  return screen_origin;
-}
-
-static Pixel alpha_blend(Pixel src, Pixel dst) {
-  if ((src.a == 255) || (dst.a == 0)) {
-    return src;
-  }
-  const uint16_t one_minus_alpha = 255 - src.a;
-#define blend(s, d)                             \
-  (Channel)(                                    \
-      (double)((uint16_t)s * (uint16_t)src.a +  \
-               (uint16_t)d * one_minus_alpha) / \
-      255.0)
-  return (Pixel){
-      .r = blend(src.r, dst.r),
-      .g = blend(src.g, dst.g),
-      .b = blend(src.b, dst.b),
-      .a = src.a};
-}
-
-/// Draw a rectangle (tile or sprite).
-///
-/// The rectangle's top-left corner is mapped to the screen space position given
-/// by 'top_left'.
-///
-/// The rectangle's pixels are assumed to be arranged in a linear, row-major
-/// fashion.
-///
-/// If indices are given, then the image is assumed to be colour-paletted, where
-/// 'pixels' is the palette and 'indices' the pixel indices. Otherwise, the
-/// image is assumed to be in plain RGBA format.
-static void draw_rect(
-    IsoGfx* iso, ivec2 top_left, int rect_width, int rect_height,
-    const Pixel* pixels, const uint8_t* indices) {
-  assert(iso);
-
-#define rect_pixel(X, Y) \
-  (indices ? pixels[indices[Y * rect_width + X]] : pixels[Y * rect_width + X])
-
-  // Rect origin can be outside screen bounds, so we must offset accordingly to
-  // draw only the visible portion.
-#define max(a, b) (a > b ? a : b)
-  const int px_offset = max(0, -top_left.x);
-  const int py_offset = max(0, -top_left.y);
-
-  // Rect can exceed screen bounds, so clip along Y and X as we draw.
-  for (int py = py_offset;
-       (py < rect_height) && (top_left.y + py < iso->screen_height); ++py) {
-    const int sy = top_left.y + py;
-    for (int px = px_offset;
-         (px < rect_width) && (top_left.x + px < iso->screen_width); ++px) {
-      const Pixel colour = rect_pixel(px, py);
-      if (colour.a > 0) {
-        const int   sx              = top_left.x + px;
-        const Pixel dst             = screen_xy(iso, sx, sy);
-        const Pixel final           = alpha_blend(colour, dst);
-        *screen_xy_mut(iso, sx, sy) = final;
-      }
-    }
-  }
-}
-
-/// Draw a tile.
-///
-/// 'screen_origin' is the screen coordinates of the top diamond-corner of the
-/// tile (the base tile for super tiles).
-///     World (0, 0) -> (screen_width / 2, 0).
-static void draw_tile(IsoGfx* iso, ivec2 screen_origin, Tile tile) {
-  assert(iso);
-
-  const TileData* tile_data = mempool_get_block(&iso->tiles, tile);
-  assert(tile_data);
-  const Pixel* pixels = tile_xy_const_ref(iso, tile_data, 0, 0);
-
-  // Move from the top diamond-corner to the top-left corner of the tile image.
-  // For regular tiles, tile height == base tile height, so the y offset is 0.
-  // For super tiles, move as high up as the height of the tile.
-  const ivec2 offset = {
-      -(iso->tile_width / 2), tile_data->height - iso->tile_height};
-  const ivec2 top_left = ivec2_add(screen_origin, offset);
-
-  draw_rect(iso, top_left, tile_data->width, tile_data->height, pixels, 0);
-}
-
-static void draw_world(IsoGfx* iso) {
-  assert(iso);
-
-  const int W = iso->screen_width;
-  const int H = iso->screen_height;
-
-  memset(iso->screen, 0, W * H * sizeof(Pixel));
-
-  const CoordSystem iso_space = make_iso_coord_system(iso);
-
-  // TODO: Culling.
-  // Ex: map the screen corners to tile space to cull.
-  // Ex: walk in screen space and fetch the tile.
-  // The tile-centric approach might be more cache-friendly since the
-  // screen-centric approach would juggle multiple tiles throughout the scan.
-  for (int wy = 0; wy < iso->world_height; ++wy) {
-    for (int wx = 0; wx < iso->world_width; ++wx) {
-      const Tile  tile          = world_xy(iso, wx, wy);
-      const ivec2 screen_origin = GetTileScreenOrigin(iso_space, wx, wy);
-      draw_tile(iso, screen_origin, tile);
-    }
-  }
-}
-
-static void draw_sprite(
-    IsoGfx* iso, ivec2 origin, const SpriteData* sprite,
-    const SpriteSheetData* sheet) {
-  assert(iso);
-  assert(sprite);
-  assert(sheet);
-  assert(sprite->animation >= 0);
-  assert(sprite->animation < sheet->num_rows);
-  assert(sprite->frame >= 0);
-
-  const SpriteSheetRow* row = get_sprite_sheet_row(sheet, sprite->animation);
-  const uint8_t* frame = get_sprite_sheet_sprite(sheet, row, sprite->frame);
-  draw_rect(
-      iso, origin, sheet->sprite_width, sheet->sprite_height,
-      sheet->palette.colours, frame);
-}
-
-static void draw_sprites(IsoGfx* iso) {
-  assert(iso);
-
-  const CoordSystem iso_space = make_iso_coord_system(iso);
-
-  mempool_foreach(&iso->sprites, sprite, {
-    const SpriteSheetData* sheet = mem_get_chunk(&iso->sheets, sprite->sheet);
-    assert(sheet);
-
-    const ivec2 screen_origin =
-        GetTileScreenOrigin(iso_space, sprite->position.x, sprite->position.y);
-    draw_sprite(iso, screen_origin, sprite, sheet);
-  });
-}
-
-void isogfx_render(IsoGfx* iso) {
-  assert(iso);
-  draw_world(iso);
-  draw_sprites(iso);
-}
-
-void isogfx_draw_tile(IsoGfx* iso, int x, int y, Tile tile) {
-  assert(iso);
-  assert(x >= 0);
-  assert(y >= 0);
-  assert(x < iso->world_width);
-  assert(y < iso->world_height);
-
-  const CoordSystem iso_space     = make_iso_coord_system(iso);
-  const ivec2       screen_origin = GetTileScreenOrigin(iso_space, x, y);
-  draw_tile(iso, screen_origin, tile);
-}
-
-bool isogfx_resize(IsoGfx* iso, int screen_width, int screen_height) {
-  assert(iso);
-  assert(iso->screen);
-
-  const int current_size = iso->screen_width * iso->screen_height;
-  const int new_size     = screen_width * screen_height;
-
-  if (new_size > current_size) {
-    Pixel* new_screen = calloc(new_size, sizeof(Pixel));
-    if (new_screen) {
-      free(iso->screen);
-      iso->screen = new_screen;
-    } else {
-      return false;
-    }
-  }
-  iso->screen_width  = screen_width;
-  iso->screen_height = screen_height;
-  return true;
-}
-
-void isogfx_get_screen_size(const IsoGfx* iso, int* width, int* height) {
-  assert(iso);
-  assert(width);
-  assert(height);
-  *width  = iso->screen_width;
-  *height = iso->screen_height;
-}
-
-const Pixel* isogfx_get_screen_buffer(const IsoGfx* iso) {
-  assert(iso);
-  return iso->screen;
-}
-
-void isogfx_pick_tile(
-    const IsoGfx* iso, double xcart, double ycart, int* xiso, int* yiso) {
-  assert(iso);
-  assert(xiso);
-  assert(yiso);
-
-  const vec2 xy_iso = cart2iso(
-      (vec2){.x = xcart, .y = ycart}, iso->tile_width, iso->tile_height,
-      iso->screen_width);
-
-  if ((0 <= xy_iso.x) && (xy_iso.x < iso->world_width) && (0 <= xy_iso.y) &&
-      (xy_iso.y < iso->world_height)) {
-    *xiso = (int)xy_iso.x;
-    *yiso = (int)xy_iso.y;
-  } else {
-    *xiso = -1;
-    *yiso = -1;
-  }
-}
diff --git a/gfx-iso/tools/mkasset.py b/gfx-iso/tools/mkasset.py
deleted file mode 100644
index 3ca8a1d..0000000
--- a/gfx-iso/tools/mkasset.py
+++ /dev/null
@@ -1,324 +0,0 @@
-# Converts assets to binary formats (.ts, .tm, .ss) for the engine.
-#
-# Input file formats:
-#  - Tiled tile set (.tsx)
-#  - Tiled tile map (.tmx)
-#  - Sprite sheets (.jpg, .png, etc), 1 row per animation.
-#
-# Output file formats:
-#  - Binary tile set file (.ts)
-#  - Binary tile map file (.tm)
-#  - Binary sprite sheet file (.ss)
-#
-import argparse
-import ctypes
-import os
-from PIL import Image
-import sys
-from xml.etree import ElementTree
-
-# Maximum length of path strings in .TS and .TM files.
-# Must match the engine's value.
-MAX_PATH_LENGTH = 128
-
-
-def drop_extension(filepath):
-    return filepath[:filepath.rfind('.')]
-
-
-def to_char_array(string, length):
-    """Convert a string to a fixed-length ASCII char array.
-
-    The length of str must be at most length-1 so that the resulting string can
-    be null-terminated.
-    """
-    assert (len(string) < length)
-    chars = string.encode("ascii")
-    nulls = ("\0" * (length - len(string))).encode("ascii")
-    return chars + nulls
-
-
-def convert_tsx(input_filepath, output_filepath):
-    """Converts a Tiled .tsx tileset file to a .TS tile set file."""
-    xml = ElementTree.parse(input_filepath)
-    root = xml.getroot()
-
-    tile_count = int(root.attrib["tilecount"])
-    max_tile_width = int(root.attrib["tilewidth"])
-    max_tile_height = int(root.attrib["tileheight"])
-
-    print(f"Tile count: {tile_count}")
-    print(f"Max width:  {max_tile_width}")
-    print(f"Max height: {max_tile_height}")
-
-    with open(output_filepath, 'bw') as output:
-        output.write(ctypes.c_uint16(tile_count))
-        output.write(ctypes.c_uint16(max_tile_width))
-        output.write(ctypes.c_uint16(max_tile_height))
-
-        num_tile = 0
-        for tile in root:
-            # Skip the "grid" and other non-tile elements.
-            if not tile.tag == "tile":
-                continue
-
-            # Assuming tiles are numbered 0..N.
-            tile_id = int(tile.attrib["id"])
-            assert (tile_id == num_tile)
-            num_tile += 1
-
-            image = tile[0]
-            tile_width = int(image.attrib["width"])
-            tile_height = int(image.attrib["height"])
-            tile_path = image.attrib["source"]
-
-            output.write(ctypes.c_uint16(tile_width))
-            output.write(ctypes.c_uint16(tile_height))
-
-            with Image.open(tile_path) as im:
-                bytes = im.convert('RGBA').tobytes()
-                output.write(bytes)
-
-
-def convert_tmx(input_filepath, output_filepath):
-    """Converts a Tiled .tmx file to a .TM tile map file."""
-    xml = ElementTree.parse(input_filepath)
-    root = xml.getroot()
-
-    map_width = int(root.attrib["width"])
-    map_height = int(root.attrib["height"])
-    base_tile_width = int(root.attrib["tilewidth"])
-    base_tile_height = int(root.attrib["tileheight"])
-    num_layers = 1
-
-    print(f"Map width:   {map_width}")
-    print(f"Map height:  {map_height}")
-    print(f"Tile width:  {base_tile_width}")
-    print(f"Tile height: {base_tile_height}")
-
-    with open(output_filepath, 'bw') as output:
-        output.write(ctypes.c_uint16(map_width))
-        output.write(ctypes.c_uint16(map_height))
-        output.write(ctypes.c_uint16(base_tile_width))
-        output.write(ctypes.c_uint16(base_tile_height))
-        output.write(ctypes.c_uint16(num_layers))
-
-        tileset_path = None
-
-        for child in root:
-            if child.tag == "tileset":
-                tileset = child
-                tileset_path = tileset.attrib["source"]
-
-                print(f"Tile set: {tileset_path}")
-
-                tileset_path = tileset_path.replace("tsx", "ts")
-            elif child.tag == "layer":
-                layer = child
-                layer_id = int(layer.attrib["id"])
-                layer_width = int(layer.attrib["width"])
-                layer_height = int(layer.attrib["height"])
-
-                print(f"Layer:  {layer_id}")
-                print(f"Width:  {layer_width}")
-                print(f"Height: {layer_height}")
-
-                assert (tileset_path)
-                output.write(to_char_array(tileset_path, MAX_PATH_LENGTH))
-
-                # Assume the layer's dimensions matches the map's.
-                assert (layer_width == map_width)
-                assert (layer_height == map_height)
-
-                data = layer[0]
-                # Handle other encodings later.
-                assert (data.attrib["encoding"] == "csv")
-
-                csv = data.text.strip()
-                rows = csv.split('\n')
-                for row in rows:
-                    tile_ids = [x.strip() for x in row.split(',') if x]
-                    for tile_id in tile_ids:
-                        output.write(ctypes.c_uint16(int(tile_id)))
-
-
-def get_num_cols(image, sprite_width):
-    """Return the number of non-empty columns in the image.
-
-    Assumes no gaps in the columns.
-    """
-    assert (image.width % sprite_width == 0)
-    num_cols = image.width // sprite_width
-
-    # Start the search from right to left.
-    for col in reversed(range(1, num_cols)):
-        left = (col - 1) * sprite_width
-        right = col * sprite_width
-        rect = image.crop((left, 0, right, image.height))
-        min_max = rect.getextrema()
-        for (channel_min, channel_max) in min_max:
-            if channel_min != 0 or channel_max != 0:
-                # 'col' is the rightmost non-empty column.
-                # Assuming no gaps, col+1 is the number of non-empty columns.
-                return col + 1
-
-    return 0
-
-
-def get_sprite_sheet_rows(im, sprite_width, sprite_height):
-    """Gets the individual rows of a sprite sheet.
-
-    The input sprite sheet can have any number of rows.
-
-    Returns a list of lists [[sprite]], one inner list for the columns in each
-    row.
-    """
-    # Sprite sheet's width and height must be integer multiples of the
-    # sprite's width and height.
-    assert (im.width % sprite_width == 0)
-    assert (im.height % sprite_height == 0)
-
-    num_rows = im.height // sprite_height
-
-    rows = []
-    for row in range(num_rows):
-        # Get the number of columns.
-        upper = row * sprite_height
-        lower = (row + 1) * sprite_height
-        whole_row = im.crop((0, upper, im.width, lower))
-        num_cols = get_num_cols(whole_row, sprite_width)
-        assert (num_cols > 0)
-
-        # Crop the row into N columns.
-        cols = []
-        for i in range(num_cols):
-            left = i * sprite_width
-            right = (i + 1) * sprite_width
-            sprite = im.crop((left, upper, right, lower))
-            cols.append(sprite)
-
-        assert (len(cols) == num_cols)
-        rows.append(cols)
-
-    return rows
-
-
-def make_image_from_rows(rows, sprite_width, sprite_height):
-    """Concatenate the rows into a single RGBA image."""
-    im_width = sprite_width * max(len(row) for row in rows)
-    im_height = len(rows) * sprite_height
-    im = Image.new('RGBA', (im_width, im_height))
-    y = 0
-    for row in rows:
-        x = 0
-        for sprite in row:
-            im.paste(sprite.convert('RGBA'), (x, y))
-            x += sprite_width
-        y += sprite_height
-    return im
-
-
-def convert_sprite_sheet(input_file_paths, sprite_width, sprite_height,
-                         output_filepath):
-    """Converts a set of sprite sheet images into a binary sprite sheet file
-    (.ss).
-
-    The input sprite sheets can have any number of rows, one row per animation.
-    All rows from all sprite sheets are concatenated in the output file.
-
-    The sprite's width and height is assumed constant throughout the input
-    sprite sheets.
-    """
-    rows = []
-    for input_filepath in input_file_paths:
-        with Image.open(input_filepath) as sprite_sheet:
-            rows.extend(
-                get_sprite_sheet_rows(sprite_sheet, sprite_width,
-                                      sprite_height))
-
-    im = make_image_from_rows(rows, sprite_width, sprite_height)
-    im = im.convert(mode="P", palette=Image.ADAPTIVE, colors=256)
-
-    # The sprite data in 'rows' is no longer needed.
-    # Keep just the number of columns per row.
-    rows = [len(row) for row in rows]
-
-    with open(output_filepath, 'bw') as output:
-        output.write(ctypes.c_uint16(sprite_width))
-        output.write(ctypes.c_uint16(sprite_height))
-        output.write(ctypes.c_uint16(len(rows)))
-
-        # Write palette.
-        # getpalette() returns 256 colors, but the palette might use less than
-        # that. getcolors() returns the number of unique colors.
-        # getpalette() also returns a flattened list, which is why we must *4.
-        num_colours = len(im.getcolors())
-        colours = im.getpalette(rawmode="RGBA")[:4 * num_colours]
-        palette = []
-        for i in range(0, 4 * num_colours, 4):
-            palette.append((colours[i], colours[i + 1], colours[i + 2],
-                            colours[i + 3]))
-
-        output.write(ctypes.c_uint16(len(palette)))
-        output.write(bytearray(colours))
-
-        print(f"Sprite width:  {sprite_width}")
-        print(f"Sprite height: {sprite_height}")
-        print(f"Rows:          {len(rows)}")
-        print(f"Colours:       {len(palette)}")
-
-        # print("Palette")
-        # for i, colour in enumerate(palette):
-        #     print(f"{i}: {colour}")
-
-        for row, num_columns in enumerate(rows):
-            output.write(ctypes.c_uint16(num_columns))
-            upper = row * sprite_height
-            lower = (row + 1) * sprite_height
-            for col in range(num_columns):
-                left = col * sprite_width
-                right = (col + 1) * sprite_width
-                sprite = im.crop((left, upper, right, lower))
-                sprite_bytes = sprite.tobytes()
-
-                assert (len(sprite_bytes) == sprite_width * sprite_height)
-                output.write(sprite_bytes)
-
-                # if (row == 0) and (col == 0):
-                #     print(f"Sprite: ({len(sprite_bytes)})")
-                #     print(list(sprite_bytes))
-                #     sprite.save("out.png")
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("input",
-                        nargs="+",
-                        help="Input file (.tsx, .tmx) or path regex (sprite sheets)")
-    parser.add_argument("--width", type=int, help="Sprite width in pixels")
-    parser.add_argument("--height", type=int, help="Sprite height in pixels")
-    parser.add_argument("--out", help="Output file (sprite sheets)")
-    args = parser.parse_args()
-
-    if ".tsx" in args.input:
-        output_filepath_no_ext = drop_extension(args.input)
-        output_filepath = output_filepath_no_ext + ".ts"
-        convert_tsx(args.input, output_filepath)
-    elif ".tmx" in args.input:
-        output_filepath_no_ext = drop_extension(args.input)
-        output_filepath = output_filepath_no_ext + ".tm"
-        convert_tmx(args.input, output_filepath)
-    else:
-        # Sprite sheets.
-        if not args.width or not args.height:
-            print("Sprite width and height must be given")
-            return 1
-        output_filepath = args.out if args.out else "out.ss"
-        convert_sprite_sheet(args.input, args.width, args.height,
-                             output_filepath)
-
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(main())
diff --git a/gfx/CMakeLists.txt b/gfx/CMakeLists.txt
deleted file mode 100644
index 7d629dc..0000000
--- a/gfx/CMakeLists.txt
+++ /dev/null
@@ -1,89 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-
-include(cmake/shader.txt)
-
-add_subdirectory(contrib/cgltf)
-add_subdirectory(contrib/cgltf-tangents)
-add_subdirectory(contrib/stb)
-
-project(gfx)
-
-add_shader_library(shaders
-  shaders/brdf_integration_map.frag
-  shaders/cook_torrance.frag
-  shaders/cook_torrance.vert
-  shaders/cubemap_filtering.vert
-  shaders/debug3d.frag
-  shaders/debug3d.vert
-  shaders/immediate_mode.frag
-  shaders/immediate_mode.vert
-  shaders/irradiance_map.frag
-  shaders/prefiltered_environment_map.frag
-  shaders/quad.vert
-  shaders/skyquad.frag
-  shaders/skyquad.vert
-  shaders/view_normal_mapped_normals.frag
-  shaders/view_normal_mapped_normals.vert
-  shaders/view_normals.frag
-  shaders/view_normals.vert
-  shaders/view_tangents.frag
-  shaders/view_tangents.vert
-  shaders/view_texture.frag
-  shaders/view_texture.vert)
-
-add_library(gfx SHARED
-  src/asset/asset_cache.c
-  src/asset/model.c
-  src/asset/texture.c
-  src/core/buffer.c
-  src/core/core.c
-  src/core/framebuffer.c
-  src/core/geometry.c
-  src/core/renderbuffer.c
-  src/core/shader_program.c
-  src/core/shader.c
-  src/core/texture.c
-  src/renderer/imm_renderer.c
-  src/renderer/renderer.c
-  src/scene/animation.c
-  src/scene/camera.c
-  src/scene/light.c
-  src/scene/material.c
-  src/scene/mesh.c
-  src/scene/model.c
-  src/scene/node.c
-  src/scene/object.c
-  src/scene/scene.c
-  src/scene/scene_memory.c
-  src/gfx.c
-  src/util/geometry.c
-  src/util/ibl.c
-  src/util/shader.c
-  src/util/skyquad.c)
-
-target_include_directories(gfx PUBLIC
-  include)
-
-target_include_directories(gfx PRIVATE
-  src)
-
-target_compile_options(gfx PRIVATE -std=gnu11 -Wall -Wextra -Wpedantic)
-
-target_link_libraries(gfx PUBLIC
-  cstring
-  math)
-
-target_link_libraries(gfx PRIVATE
-  cassert
-  cgltf
-  cgltf-tangents
-  error
-  gfx-app
-  log
-  mempool
-  shaders
-  stb
-  # System libraries.
-  GL
-  # Required to initialize GLAD.
-  -ldl)
diff --git a/gfx/include/gfx/renderer.h b/gfx/include/gfx/renderer.h
deleted file mode 100644
index 2a4ada1..0000000
--- a/gfx/include/gfx/renderer.h
+++ /dev/null
@@ -1,104 +0,0 @@
-#pragma once
-
-#include <math/aabb2.h>
-#include <math/aabb3.h>
-#include <math/camera.h>
-#include <math/defs.h>
-#include <math/mat4.h>
-#include <math/vec3.h>
-#include <math/vec4.h>
-
-typedef struct GfxCore     GfxCore;
-typedef struct Scene       Scene;
-typedef struct SceneCamera SceneCamera;
-
-typedef struct ImmRenderer ImmRenderer;
-typedef struct Renderer    Renderer;
-
-// -----------------------------------------------------------------------------
-// Main Renderer.
-// -----------------------------------------------------------------------------
-
-typedef enum RenderSceneMode {
-  RenderDefault,
-  RenderDebug,
-  RenderNormals,
-  RenderNormalMappedNormals,
-  RenderTangents
-} RenderSceneMode;
-
-typedef struct RenderSceneParams {
-  RenderSceneMode    mode;
-  const Scene*       scene;
-  const SceneCamera* camera;
-} RenderSceneParams;
-
-/// Render the scene.
-void gfx_render_scene(Renderer*, const RenderSceneParams*);
-
-/// Update the scene.
-void gfx_update(Scene*, const SceneCamera*, R t);
-
-// -----------------------------------------------------------------------------
-// Immediate Mode Renderer.
-// -----------------------------------------------------------------------------
-
-/// Prepare the graphics systems for immediate-mode rendering.
-///
-/// Call this before issuing any immediate-mode rendering draws.
-void gfx_imm_start(ImmRenderer*);
-
-/// End immediate mode rendering.
-///
-/// Call this after issuing immediate-mode rendering draws and before swapping
-/// buffers.
-void gfx_imm_end(ImmRenderer*);
-
-/// Draw a set of triangles.
-void gfx_imm_draw_triangles(ImmRenderer*, const vec3[], size_t num_triangles);
-
-/// Draw a triangle.
-void gfx_imm_draw_triangle(ImmRenderer*, const vec3[3]);
-
-/// Draw a bounding box.
-void gfx_imm_draw_aabb2(ImmRenderer*, aabb2);
-
-/// Draw a bounding box.
-void gfx_imm_draw_aabb3(ImmRenderer*, aabb3);
-
-/// Draw a box.
-///
-/// The vertices must be given in the following order:
-///
-///     7 ----- 6
-///    /       /|
-///   3 ----- 2 |
-///   |       | |
-///   | 4 ----- 5
-///   |/      |/
-///   0 ----- 1
-void gfx_imm_draw_box3(ImmRenderer* renderer, const vec3 vertices[8]);
-
-/// Set the camera.
-void gfx_imm_set_camera(ImmRenderer*, const Camera*);
-
-/// Load an identity model matrix. Clears the matrix stack.
-void gfx_imm_load_identity(ImmRenderer* renderer);
-
-/// Push the given matrix to the matrix stack.
-void gfx_imm_push_matrix(ImmRenderer* renderer, const mat4* matrix);
-
-/// Pop the top of the matrix stack.
-void gfx_imm_pop_matrix(ImmRenderer* renderer);
-
-/// Push a translation matrix to the matrix stack.
-void gfx_imm_translate(ImmRenderer* renderer, vec3 offset);
-
-/// Set the model matrix. Clears the matrix stack.
-void gfx_imm_set_model_matrix(ImmRenderer*, const mat4*);
-
-/// Set the view-projection matrix.
-void gfx_imm_set_view_projection_matrix(ImmRenderer*, const mat4*);
-
-/// Set the render colour.
-void gfx_imm_set_colour(ImmRenderer*, vec4 colour);
diff --git a/gfx/src/renderer/imm_renderer.c b/gfx/src/renderer/imm_renderer.c
deleted file mode 100644
index 8cf3a10..0000000
--- a/gfx/src/renderer/imm_renderer.c
+++ /dev/null
@@ -1,260 +0,0 @@
-#include "imm_renderer_impl.h"
-
-#include <gfx/core.h>
-#include <gfx/util/shader.h>
-
-#include <math/aabb3.h>
-
-#include <assert.h>
-#include <string.h> // memcpy
-
-bool imm_renderer_make(ImmRenderer* 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->shader = gfx_make_immediate_mode_shader(gfxcore);
-  if (!renderer->shader) {
-    goto cleanup;
-  }
-
-  renderer->matrix_stack[0] = mat4_id();
-  renderer->stack_pointer   = 0;
-
-  gfx_imm_set_colour(renderer, vec4_make(0.0, 0.0, 0.0, 1.0));
-
-  return true;
-
-cleanup:
-  imm_renderer_destroy(renderer);
-  return false;
-}
-
-void imm_renderer_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 imm_renderer_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_apply_uniforms(renderer->shader);
-    gfx_render_geometry(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.
-  ShaderProgram* shader = renderer->shader;
-  gfx_activate_shader_program(shader);
-}
-
-void gfx_imm_end(ImmRenderer* renderer) {
-  assert(renderer);
-  imm_renderer_flush(renderer);
-  gfx_deactivate_shader_program(renderer->shader);
-}
-
-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);
-}
-
-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);
-}
-
-// Load the top of the matrix stack into the shader.
-static void update_shader_model_matrix(ImmRenderer* renderer) {
-  assert(renderer);
-  imm_renderer_flush(renderer);
-  gfx_set_mat4_uniform(
-      renderer->shader, "Model",
-      &renderer->matrix_stack[renderer->stack_pointer]);
-}
-
-void gfx_imm_load_identity(ImmRenderer* renderer) {
-  assert(renderer);
-  renderer->matrix_stack[0] = mat4_id();
-  renderer->stack_pointer   = 0;
-  update_shader_model_matrix(renderer);
-}
-
-void gfx_imm_push_matrix(ImmRenderer* renderer, const mat4* matrix) {
-  assert(renderer);
-  assert(matrix);
-  assert(renderer->stack_pointer >= 0);
-  assert(renderer->stack_pointer < IMM_MAX_NUM_MATRICES); // TODO: hard assert.
-
-  renderer->matrix_stack[renderer->stack_pointer + 1] =
-      mat4_mul(*matrix, renderer->matrix_stack[renderer->stack_pointer]);
-  renderer->stack_pointer += 1;
-
-  update_shader_model_matrix(renderer);
-}
-
-void gfx_imm_pop_matrix(ImmRenderer* renderer) {
-  assert(renderer);
-  assert(renderer->stack_pointer > 0); // TODO: hard assert.
-
-  // For debugging, zero out the matrix stack as matrices are popped out.
-  memset(
-      &renderer->matrix_stack[renderer->stack_pointer], 0,
-      sizeof(renderer->matrix_stack[0]));
-
-  renderer->stack_pointer -= 1;
-
-  update_shader_model_matrix(renderer);
-}
-
-void gfx_imm_translate(ImmRenderer* renderer, vec3 offset) {
-  assert(renderer);
-  const mat4 mat = mat4_translate(offset);
-  gfx_imm_push_matrix(renderer, &mat);
-}
-
-void gfx_imm_set_camera(ImmRenderer* renderer, const Camera* camera) {
-  assert(renderer);
-  assert(renderer->shader);
-  imm_renderer_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);
-}
-
-void gfx_imm_set_model_matrix(ImmRenderer* renderer, const mat4* model) {
-  assert(renderer);
-  assert(model);
-  imm_renderer_flush(renderer);
-  renderer->matrix_stack[0] = *model;
-  renderer->stack_pointer   = 0;
-  update_shader_model_matrix(renderer);
-}
-
-void gfx_imm_set_view_projection_matrix(
-    ImmRenderer* renderer, const mat4* view_proj) {
-  assert(renderer);
-  assert(renderer->shader);
-  imm_renderer_flush(renderer);
-  gfx_set_mat4_uniform(renderer->shader, "ViewProjection", view_proj);
-}
-
-void gfx_imm_set_colour(ImmRenderer* renderer, vec4 colour) {
-  assert(renderer);
-  assert(renderer->shader);
-  imm_renderer_flush(renderer);
-  gfx_set_vec4_uniform(renderer->shader, "Colour", colour);
-}
diff --git a/gfx/src/renderer/renderer.c b/gfx/src/renderer/renderer.c
deleted file mode 100644
index c2a7dda..0000000
--- a/gfx/src/renderer/renderer.c
+++ /dev/null
@@ -1,396 +0,0 @@
-#include "renderer_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"
-#include "scene/scene_impl.h"
-#include "scene/scene_memory.h"
-
-#include <gfx/core.h>
-#include <gfx/util/ibl.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) {
-  assert(renderer);
-  assert(gfxcore);
-
-  renderer->gfxcore = gfxcore;
-
-  return true;
-}
-
-void 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);
-  }
-  if (renderer->shaders.normals) {
-    gfx_destroy_shader_program(gfxcore, &renderer->shaders.normals);
-  }
-  if (renderer->shaders.normal_mapped_normals) {
-    gfx_destroy_shader_program(
-        gfxcore, &renderer->shaders.normal_mapped_normals);
-  }
-  if (renderer->shaders.tangents) {
-    gfx_destroy_shader_program(gfxcore, &renderer->shaders.tangents);
-  }
-}
-
-/// 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);
-
-#define LOAD_AND_RETURN(pShader, constructor)   \
-  {                                             \
-    if (!pShader) {                             \
-      pShader = constructor(renderer->gfxcore); \
-    }                                           \
-    assert(pShader);                            \
-    return pShader;                             \
-  }
-
-  switch (mode) {
-  case RenderDefault:
-    return 0;
-  case RenderDebug:
-    LOAD_AND_RETURN(renderer->shaders.debug, gfx_make_debug3d_shader);
-  case RenderNormals:
-    LOAD_AND_RETURN(renderer->shaders.normals, gfx_make_view_normals_shader);
-  case RenderNormalMappedNormals:
-    LOAD_AND_RETURN(
-        renderer->shaders.normal_mapped_normals,
-        gfx_make_view_normal_mapped_normals_shader);
-  case RenderTangents:
-    LOAD_AND_RETURN(renderer->shaders.tangents, gfx_make_view_tangents_shader);
-  }
-  assert(false);
-  return 0;
-}
-
-// static void log_matrix(const mat4* m) {
-//   for (int row = 0; row < 4; ++row) {
-//     LOGI("[ %5.2f, %5.2f, %5.2f, %5.2f ]", m->val[0][row], m->val[1][row],
-//          m->val[2][row], m->val[3][row]);
-//   }
-// }
-
-/// 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;
-  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;
-  }
-}
-
-/// Draw the scene recursively.
-static void draw_recursively(
-    RenderState* state, mat4 parent_transform, const SceneNode* node) {
-  assert(state);
-  const mat4 node_transform = mat4_mul(parent_transform, node->transform);
-
-  // Anima.
-  if (node->type == AnimaNode) {
-    state->anima = gfx_get_node_anima(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;
-    }
-  }
-  // 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);
-  }
-  // Render object.
-  else if (node->type == ObjectNode) {
-    const SceneObject* object = mem_get_object(node->object);
-    assert(object);
-
-    // 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);
-
-    if (object->skeleton.val) {
-      load_skeleton(state, object->skeleton);
-    }
-
-    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;
-
-      const Mesh* mesh = mem_get_mesh(mesh_link->mesh);
-      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.
-
-      // 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);
-    }
-
-    // Reset state for next object.
-    state->num_joints = 0;
-  }
-
-  // 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);
-    child_index = child->next;
-  }
-}
-
-void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) {
-  assert(renderer);
-  assert(params);
-  assert(params->scene);
-
-  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();
-  }
-
-  int x, y, width, height;
-  gfx_get_viewport(gfxcore, &x, &y, &width, &height);
-  const float aspect = (float)width / (float)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};
-
-  draw_recursively(&state, mat4_id(), scene->root);
-}
-
-static void update_rec(SceneNode* node, const SceneCamera* camera, R t) {
-  assert(node);
-  assert(camera);
-
-  const NodeType node_type = gfx_get_node_type(node);
-
-  // TODO: Models do not need to be animated if they are not visible to the
-  //  camera.
-  if (node_type == AnimaNode) {
-    Anima* anima = gfx_get_node_anima_mut(node);
-    gfx_update_animation(anima, (R)t);
-  } else if (node_type == ModelNode) {
-    Model*     model = gfx_get_node_model_mut(node);
-    SceneNode* root  = gfx_get_model_root_mut(model);
-    update_rec(root, camera, t);
-  }
-
-  // Children.
-  SceneNode* child = gfx_get_node_child_mut(node);
-  while (child) {
-    update_rec(child, camera, t);
-    child = gfx_get_node_sibling_mut(child);
-  }
-}
-
-void gfx_update(Scene* scene, const SceneCamera* camera, R t) {
-  assert(scene);
-  assert(camera);
-
-  SceneNode* node = gfx_get_scene_root(scene);
-  update_rec(node, camera, t);
-}
diff --git a/gfx/src/scene/material_impl.h b/gfx/src/scene/material_impl.h
deleted file mode 100644
index a6aa95b..0000000
--- a/gfx/src/scene/material_impl.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#pragma once
-
-#include <gfx/scene/material.h>
-
-typedef struct ShaderProgram ShaderProgram;
-
-typedef struct Material {
-  ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
-  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(ShaderProgram* shader, const Material* material);
diff --git a/gfx/src/scene/mesh_impl.h b/gfx/src/scene/mesh_impl.h
deleted file mode 100644
index 560b77e..0000000
--- a/gfx/src/scene/mesh_impl.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#include <gfx/scene/mesh.h>
-
-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
-// transform, and then renders the geometry.
diff --git a/gfx/include/gfx/asset.h b/include/gfx/asset.h
index caf40c1..caf40c1 100644
--- a/gfx/include/gfx/asset.h
+++ b/include/gfx/asset.h
diff --git a/gfx/include/gfx/core.h b/include/gfx/core.h
index 44509c9..0cf4465 100644
--- a/gfx/include/gfx/core.h
+++ b/include/gfx/core.h
@@ -219,6 +219,7 @@ typedef enum { Texture2D, TextureCubeMap } TextureDimension;
 /// Texture data format.
 typedef enum {
   TextureDepth,
+  TextureR8,
   TextureRG16,
   TextureRG16F,
   TextureRGB8,
@@ -473,6 +474,9 @@ void gfx_deactivate_shader_program(const ShaderProgram*);
 ///
 /// This function should be called after setting all of the uniform variables
 /// and prior to issuing a draw call.
+///
+/// The given program must have been activated prior to this call with
+/// gfx_activate_shader_program().
 void gfx_apply_uniforms(const ShaderProgram*);
 
 /// Set the texture uniform.
diff --git a/gfx/include/gfx/gfx.h b/include/gfx/gfx.h
index 7c670a5..d5c25b6 100644
--- a/gfx/include/gfx/gfx.h
+++ b/include/gfx/gfx.h
@@ -3,6 +3,7 @@
 typedef struct AssetCache  AssetCache;
 typedef struct GfxCore     GfxCore;
 typedef struct ImmRenderer ImmRenderer;
+typedef struct LLR         LLR;
 typedef struct Renderer    Renderer;
 
 typedef struct Gfx Gfx;
@@ -16,12 +17,15 @@ void gfx_destroy(Gfx**);
 /// Get the render backend.
 GfxCore* gfx_get_core(Gfx*);
 
-/// Get the renderer.
+/// Get the scene renderer.
 Renderer* gfx_get_renderer(Gfx*);
 
 /// Get the immediate mode renderer.
 ImmRenderer* gfx_get_imm_renderer(Gfx*);
 
+/// Get the low-level renderer.
+LLR* gfx_get_llr(Gfx*);
+
 /// Get the asset cache.
 AssetCache* gfx_get_asset_cache(Gfx*);
 
diff --git a/gfx/include/gfx/scene/light.h b/include/gfx/llr/light.h
index 132e344..132e344 100644
--- a/gfx/include/gfx/scene/light.h
+++ b/include/gfx/llr/light.h
diff --git a/include/gfx/llr/llr.h b/include/gfx/llr/llr.h
new file mode 100644
index 0000000..098374d
--- /dev/null
+++ b/include/gfx/llr/llr.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include <math/camera.h>
+#include <math/mat4.h>
+#include <math/vec3.h>
+
+typedef struct Anima         Anima;
+typedef struct Geometry      Geometry;
+typedef struct Light         Light;
+typedef struct Material      Material;
+typedef struct Mesh          Mesh;
+typedef struct ShaderProgram ShaderProgram;
+typedef struct Skeleton      Skeleton;
+
+typedef struct LLR LLR;
+
+/// Set the shader to be used for subsequent draw calls.
+/// The shader is not yet activated at this point.
+void gfx_llr_set_shader(LLR*, ShaderProgram*);
+
+/// Push a light into the lights stack.
+void gfx_llr_push_light(LLR*, Light*);
+
+/// Pop the last light from the lights stack.
+void gfx_llr_pop_light(LLR*);
+
+/// Load a skeleton.
+///
+/// If a skeleton is loaded, subsequent meshes are rendered with joint data
+/// passed to the shader. This has a cost, so if subsequent meshes are not
+/// animated, unload the skeleton prior to rendering them.
+void gfx_llr_set_skeleton(LLR*, const Anima*, const Skeleton*);
+
+/// Clear the loaded skeleton.
+void gfx_llr_clear_skeleton(LLR*);
+
+/// Set the material.
+///
+/// The material need not be set explicitly when rendering a mesh
+/// (gfx_llr_render_mesh). This is mostly useful when using the lower-level
+/// function to render geometry (gfx_llr_render_geometry).
+void gfx_llr_set_material(LLR*, const Material*);
+
+/// Set the camera.
+void gfx_llr_set_camera(LLR*, const Camera*);
+
+/// Set the aspect ratio.
+void gfx_llr_set_aspect(LLR*, float aspect);
+
+/// Render the geometry.
+void gfx_llr_render_geometry(LLR*, const Geometry*);
+
+/// Render the mesh.
+void gfx_llr_render_mesh(LLR*, const Mesh*);
+
+// -----------------------------------------------------------------------------
+// Matrix stack manipulation.
+
+/// Load an identity model matrix. Clears the matrix stack.
+void gfx_llr_load_identity(LLR* renderer);
+
+/// Push the given matrix to the matrix stack.
+void gfx_llr_push_matrix(LLR* renderer, const mat4* matrix);
+
+/// Pop the top of the matrix stack.
+void gfx_llr_pop_matrix(LLR* renderer);
+
+/// Push a translation matrix to the matrix stack.
+void gfx_llr_translate(LLR* renderer, vec3 offset);
+
+/// Set the model matrix. Clears the matrix stack.
+void gfx_llr_set_model_matrix(LLR*, const mat4*);
diff --git a/gfx/include/gfx/scene/material.h b/include/gfx/llr/material.h
index bca664e..bca664e 100644
--- a/gfx/include/gfx/scene/material.h
+++ b/include/gfx/llr/material.h
diff --git a/gfx/include/gfx/scene/mesh.h b/include/gfx/llr/mesh.h
index 0d3b4d4..0d3b4d4 100644
--- a/gfx/include/gfx/scene/mesh.h
+++ b/include/gfx/llr/mesh.h
diff --git a/include/gfx/renderer.h b/include/gfx/renderer.h
new file mode 100644
index 0000000..1da74eb
--- /dev/null
+++ b/include/gfx/renderer.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <math/defs.h>
+
+typedef struct GfxCore     GfxCore;
+typedef struct Scene       Scene;
+typedef struct SceneCamera SceneCamera;
+
+typedef struct Renderer Renderer;
+
+typedef enum RenderSceneMode {
+  RenderDefault,
+  RenderDebug,
+  RenderNormals,
+  RenderNormalMappedNormals,
+  RenderTangents
+} RenderSceneMode;
+
+typedef struct RenderSceneParams {
+  RenderSceneMode    mode;
+  const Scene*       scene;
+  const SceneCamera* camera;
+} RenderSceneParams;
+
+/// Render the scene.
+void gfx_render_scene(Renderer*, const RenderSceneParams*);
+
+/// Update the scene.
+void gfx_update(Scene*, const SceneCamera*, R t);
diff --git a/include/gfx/renderer/imm_renderer.h b/include/gfx/renderer/imm_renderer.h
new file mode 100644
index 0000000..db4d290
--- /dev/null
+++ b/include/gfx/renderer/imm_renderer.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <math/aabb2.h>
+#include <math/aabb3.h>
+#include <math/camera.h>
+#include <math/mat4.h>
+#include <math/vec3.h>
+#include <math/vec4.h>
+
+typedef struct ImmRenderer ImmRenderer;
+
+/// Prepare the graphics systems for immediate-mode rendering.
+///
+/// Call this before issuing any immediate-mode rendering draws.
+void gfx_imm_start(ImmRenderer*);
+
+/// End immediate mode rendering.
+///
+/// Call this after issuing immediate-mode rendering draws and before swapping
+/// buffers.
+void gfx_imm_end(ImmRenderer*);
+
+/// Flush draw commands.
+///
+/// This should be done when changing any state that may affect the rendering of
+/// primitives; for example, LLR matrix stack changes.
+void gfx_imm_flush(ImmRenderer*);
+
+/// Draw a set of triangles.
+void gfx_imm_draw_triangles(ImmRenderer*, const vec3[], size_t num_triangles);
+
+/// Draw a triangle.
+void gfx_imm_draw_triangle(ImmRenderer*, const vec3[3]);
+
+/// Draw a bounding box.
+void gfx_imm_draw_aabb2(ImmRenderer*, aabb2);
+
+/// Draw a bounding box.
+void gfx_imm_draw_aabb3(ImmRenderer*, aabb3);
+
+/// Draw a box.
+///
+/// The vertices must be given in the following order:
+///
+///     7 ----- 6
+///    /       /|
+///   3 ----- 2 |
+///   |       | |
+///   | 4 ----- 5
+///   |/      |/
+///   0 ----- 1
+void gfx_imm_draw_box3(ImmRenderer* renderer, const vec3 vertices[8]);
+
+/// Set the render colour.
+void gfx_imm_set_colour(ImmRenderer*, vec4 colour);
diff --git a/gfx/include/gfx/scene.h b/include/gfx/scene.h
index abcaa70..e9a6a89 100644
--- a/gfx/include/gfx/scene.h
+++ b/include/gfx/scene.h
@@ -2,9 +2,6 @@
 
 #include <gfx/scene/animation.h>
 #include <gfx/scene/camera.h>
-#include <gfx/scene/light.h>
-#include <gfx/scene/material.h>
-#include <gfx/scene/mesh.h>
 #include <gfx/scene/model.h>
 #include <gfx/scene/node.h>
 #include <gfx/scene/object.h>
diff --git a/gfx/include/gfx/scene/animation.h b/include/gfx/scene/animation.h
index d95b895..3ef0471 100644
--- a/gfx/include/gfx/scene/animation.h
+++ b/include/gfx/scene/animation.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "node.h"
 #include "object.h"
 #include <gfx/sizes.h>
 
@@ -15,8 +14,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
-typedef struct Buffer    Buffer;
-typedef struct SceneNode SceneNode;
+typedef struct Buffer Buffer;
 
 typedef struct Anima    Anima;
 typedef struct Joint    Joint;
diff --git a/gfx/include/gfx/scene/camera.h b/include/gfx/scene/camera.h
index 99d83fe..99d83fe 100644
--- a/gfx/include/gfx/scene/camera.h
+++ b/include/gfx/scene/camera.h
diff --git a/gfx/include/gfx/scene/model.h b/include/gfx/scene/model.h
index 42f85d4..42f85d4 100644
--- a/gfx/include/gfx/scene/model.h
+++ b/include/gfx/scene/model.h
diff --git a/gfx/include/gfx/scene/node.h b/include/gfx/scene/node.h
index a2c2836..193eb25 100644
--- a/gfx/include/gfx/scene/node.h
+++ b/include/gfx/scene/node.h
@@ -1,12 +1,8 @@
 #pragma once
 
-#include "animation.h"
-
 #include <math/fwd.h>
 #include <math/mat4.h>
 
-#include <stdint.h>
-
 typedef struct Anima       Anima;
 typedef struct Light       Light;
 typedef struct Model       Model;
diff --git a/gfx/include/gfx/scene/object.h b/include/gfx/scene/object.h
index 7579d29..7579d29 100644
--- a/gfx/include/gfx/scene/object.h
+++ b/include/gfx/scene/object.h
diff --git a/gfx/include/gfx/scene/scene.h b/include/gfx/scene/scene.h
index 0d96210..ac1b315 100644
--- a/gfx/include/gfx/scene/scene.h
+++ b/include/gfx/scene/scene.h
@@ -1,8 +1,5 @@
 #pragma once
 
-#include <math/defs.h>
-#include <math/fwd.h>
-
 typedef struct SceneNode SceneNode;
 
 typedef struct Scene Scene;
diff --git a/gfx/include/gfx/sizes.h b/include/gfx/sizes.h
index 076113c..3eb7481 100644
--- a/gfx/include/gfx/sizes.h
+++ b/include/gfx/sizes.h
@@ -3,7 +3,7 @@
 
 // Scene.
 
-/// Maximum number of cameras per scene.
+/// Maximum number of cameras.
 #define GFX_MAX_NUM_CAMERAS 16
 
 /// Maximum number of lights.
@@ -31,10 +31,10 @@
 #define GFX_MAX_NUM_CHANNELS 128
 
 /// Maximum number of skeletons.
-#define GFX_MAX_NUM_SKELETONS 128
+#define GFX_MAX_NUM_SKELETONS 8
 
 /// Maximum number of animations.
-#define GFX_MAX_NUM_ANIMATIONS 128
+#define GFX_MAX_NUM_ANIMATIONS 32
 
 /// Maximum number of animas.
 #define GFX_MAX_NUM_ANIMAS 128
@@ -77,16 +77,22 @@
 /// Maximum number of compiler defines in a Shader.
 #define GFX_MAX_SHADER_COMPILER_DEFINES 16
 
-// Renderer.
+// Low-level renderer.
+
+/// Maximum number of lights that the low-level renderer can enable per rendered
+/// mesh.
+#define GFX_LLR_MAX_NUM_LIGHTS 8
+
+/// Maximum number of matrices in the low-level renderer's matrix stack.
+#define GFX_LLR_MAX_NUM_MATRICES 32
+
+// Immediate-mode Renderer.
 
 /// Maximum number of triangles that the immediate-mode renderer can draw in a
 /// frame.
-#define IMM_MAX_NUM_TRIANGLES 1024
-
-/// Maximum number of matrices in the immediate-mode renderer's matrix stack.
-#define IMM_MAX_NUM_MATRICES 32
+#define GFX_IMM_MAX_NUM_TRIANGLES 1024
 
-// Asset Manager.
+// Asset Cache.
 
 #define GFX_MAX_NUM_ASSETS 1024
 
diff --git a/gfx/include/gfx/util/geometry.h b/include/gfx/util/geometry.h
index a962291..a962291 100644
--- a/gfx/include/gfx/util/geometry.h
+++ b/include/gfx/util/geometry.h
diff --git a/gfx/include/gfx/util/ibl.h b/include/gfx/util/ibl.h
index 6e39180..6e39180 100644
--- a/gfx/include/gfx/util/ibl.h
+++ b/include/gfx/util/ibl.h
diff --git a/gfx/include/gfx/util/shader.h b/include/gfx/util/shader.h
index bd058f4..bd058f4 100644
--- a/gfx/include/gfx/util/shader.h
+++ b/include/gfx/util/shader.h
diff --git a/gfx/include/gfx/util/skyquad.h b/include/gfx/util/skyquad.h
index 2b3fe17..2b3fe17 100644
--- a/gfx/include/gfx/util/skyquad.h
+++ b/include/gfx/util/skyquad.h
diff --git a/gfx/shaders/brdf_integration_map.frag b/shaders/brdf_integration_map.frag
index bb2cebd..bb2cebd 100644
--- a/gfx/shaders/brdf_integration_map.frag
+++ b/shaders/brdf_integration_map.frag
diff --git a/gfx/shaders/cook_torrance.frag b/shaders/cook_torrance.frag
index 1975491..1975491 100644
--- a/gfx/shaders/cook_torrance.frag
+++ b/shaders/cook_torrance.frag
diff --git a/gfx/shaders/cook_torrance.vert b/shaders/cook_torrance.vert
index 5f126c0..5f126c0 100644
--- a/gfx/shaders/cook_torrance.vert
+++ b/shaders/cook_torrance.vert
diff --git a/gfx/shaders/cubemap_filtering.vert b/shaders/cubemap_filtering.vert
index d0cf73f..d0cf73f 100644
--- a/gfx/shaders/cubemap_filtering.vert
+++ b/shaders/cubemap_filtering.vert
diff --git a/gfx/shaders/debug3d.frag b/shaders/debug3d.frag
index 54568d4..54568d4 100644
--- a/gfx/shaders/debug3d.frag
+++ b/shaders/debug3d.frag
diff --git a/gfx/shaders/debug3d.vert b/shaders/debug3d.vert
index d51684f..d51684f 100644
--- a/gfx/shaders/debug3d.vert
+++ b/shaders/debug3d.vert
diff --git a/gfx/shaders/immediate_mode.frag b/shaders/immediate_mode.frag
index ac23b5c..ac23b5c 100644
--- a/gfx/shaders/immediate_mode.frag
+++ b/shaders/immediate_mode.frag
diff --git a/gfx/shaders/immediate_mode.vert b/shaders/immediate_mode.vert
index 65070bb..65070bb 100644
--- a/gfx/shaders/immediate_mode.vert
+++ b/shaders/immediate_mode.vert
diff --git a/gfx/shaders/irradiance_map.frag b/shaders/irradiance_map.frag
index 8200e73..8200e73 100644
--- a/gfx/shaders/irradiance_map.frag
+++ b/shaders/irradiance_map.frag
diff --git a/gfx/shaders/prefiltered_environment_map.frag b/shaders/prefiltered_environment_map.frag
index 8327950..8327950 100644
--- a/gfx/shaders/prefiltered_environment_map.frag
+++ b/shaders/prefiltered_environment_map.frag
diff --git a/gfx/shaders/quad.vert b/shaders/quad.vert
index ef1834c..ef1834c 100644
--- a/gfx/shaders/quad.vert
+++ b/shaders/quad.vert
diff --git a/gfx/shaders/skyquad.frag b/shaders/skyquad.frag
index 9b44bfd..9b44bfd 100644
--- a/gfx/shaders/skyquad.frag
+++ b/shaders/skyquad.frag
diff --git a/gfx/shaders/skyquad.vert b/shaders/skyquad.vert
index c0c46e6..c0c46e6 100644
--- a/gfx/shaders/skyquad.vert
+++ b/shaders/skyquad.vert
diff --git a/gfx/shaders/view_normal_mapped_normals.frag b/shaders/view_normal_mapped_normals.frag
index a372c02..a372c02 100644
--- a/gfx/shaders/view_normal_mapped_normals.frag
+++ b/shaders/view_normal_mapped_normals.frag
diff --git a/gfx/shaders/view_normal_mapped_normals.vert b/shaders/view_normal_mapped_normals.vert
index 004ed9a..004ed9a 100644
--- a/gfx/shaders/view_normal_mapped_normals.vert
+++ b/shaders/view_normal_mapped_normals.vert
diff --git a/gfx/shaders/view_normals.frag b/shaders/view_normals.frag
index e90189c..e90189c 100644
--- a/gfx/shaders/view_normals.frag
+++ b/shaders/view_normals.frag
diff --git a/gfx/shaders/view_normals.vert b/shaders/view_normals.vert
index d51684f..d51684f 100644
--- a/gfx/shaders/view_normals.vert
+++ b/shaders/view_normals.vert
diff --git a/gfx/shaders/view_tangents.frag b/shaders/view_tangents.frag
index 11d1455..11d1455 100644
--- a/gfx/shaders/view_tangents.frag
+++ b/shaders/view_tangents.frag
diff --git a/gfx/shaders/view_tangents.vert b/shaders/view_tangents.vert
index 561ad22..561ad22 100644
--- a/gfx/shaders/view_tangents.vert
+++ b/shaders/view_tangents.vert
diff --git a/gfx/shaders/view_texture.frag b/shaders/view_texture.frag
index 12fa367..12fa367 100644
--- a/gfx/shaders/view_texture.frag
+++ b/shaders/view_texture.frag
diff --git a/gfx/shaders/view_texture.vert b/shaders/view_texture.vert
index 4e3c7d7..4e3c7d7 100644
--- a/gfx/shaders/view_texture.vert
+++ b/shaders/view_texture.vert
diff --git a/gfx/src/asset/asset_cache.c b/src/asset/asset_cache.c
index 16c4d5c..a364330 100644
--- a/gfx/src/asset/asset_cache.c
+++ b/src/asset/asset_cache.c
@@ -1,10 +1,10 @@
 #include "asset_cache.h"
 
+#include "memory.h"
 #include "model.h"
 #include "scene/animation_impl.h"
 #include "scene/model_impl.h"
 #include "scene/node_impl.h"
-#include "scene/scene_memory.h"
 #include "texture.h"
 
 #include <gfx/asset.h>
@@ -179,6 +179,7 @@ static Model* clone_model(const Model* model) {
 
 void gfx_init_asset_cache(AssetCache* cache) {
   assert(cache);
+
   mempool_make(&cache->assets);
 
   // Allocate a dummy asset at index 0 to guarantee that no assets allocated by
@@ -189,6 +190,7 @@ void gfx_init_asset_cache(AssetCache* cache) {
 
 void gfx_destroy_asset_cache(AssetCache* cache) {
   assert(cache);
+  // TODO: Destroy assets here.
   mempool_del(&cache->assets);
 }
 
diff --git a/gfx/src/asset/asset_cache.h b/src/asset/asset_cache.h
index b2a35ed..b2a35ed 100644
--- a/gfx/src/asset/asset_cache.h
+++ b/src/asset/asset_cache.h
diff --git a/gfx/src/asset/model.c b/src/asset/model.c
index 25f2780..0c57470 100644
--- a/gfx/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"
 
@@ -578,11 +577,10 @@ static bool load_buffers(
     const cgltf_buffer* buffer = &data->buffers[i];
     assert(buffer->data);
     buffers[i] = gfx_make_buffer(
-        gfxcore, &(BufferDesc){
-                     .usage      = BufferStatic,
-                     .type       = BufferUntyped,
-                     .data.data  = buffer->data,
-                     .data.count = buffer->size});
+        gfxcore, &(BufferDesc){.usage      = BufferStatic,
+                               .type       = BufferUntyped,
+                               .data.data  = buffer->data,
+                               .data.count = buffer->size});
     if (!buffers[i]) {
       return false;
     }
@@ -604,11 +602,10 @@ static bool load_tangent_buffers(
     const cgltfTangentBuffer* buffer = &cgltf_tangent_buffers[i];
     assert(buffer->data);
     tangent_buffers[i] = gfx_make_buffer(
-        gfxcore, &(BufferDesc){
-                     .usage      = BufferStatic,
-                     .type       = BufferUntyped,
-                     .data.data  = buffer->data,
-                     .data.count = buffer->size_bytes});
+        gfxcore, &(BufferDesc){.usage      = BufferStatic,
+                               .type       = BufferUntyped,
+                               .data.data  = buffer->data,
+                               .data.count = buffer->size_bytes});
     if (!tangent_buffers[i]) {
       return false;
     }
@@ -682,14 +679,13 @@ static void load_textures_lazy(
     mstring fullpath =
         mstring_concat_path(mstring_make(directory), mstring_make(image->uri));
 
-    load_texture_cmds[i] = (LoadTextureCmd){
-        .origin                = AssetFromFile,
-        .type                  = LoadTexture,
-        .colour_space          = sRGB,
-        .filtering             = filtering,
-        .wrap                  = wrap,
-        .mipmaps               = mipmaps,
-        .data.texture.filepath = fullpath};
+    load_texture_cmds[i] = (LoadTextureCmd){.origin       = AssetFromFile,
+                                            .type         = LoadTexture,
+                                            .colour_space = LinearColourSpace,
+                                            .filtering    = filtering,
+                                            .wrap         = wrap,
+                                            .mipmaps      = mipmaps,
+                                            .data.texture.filepath = fullpath};
   }
 }
 
@@ -717,8 +713,12 @@ static bool load_texture_and_uniform(
   // not be used as albedo and vice versa.
   if (!textures[texture_index]) {
     LoadTextureCmd* cmd = &load_texture_cmds[texture_index];
-    // TODO: Check for colour textures and default to LinearColourSpace instead.
-    if (texture_type == NormalMap) {
+    // Albedo and emissive use sRGB. Other textures use a linear colour space.
+    // See the notes on the spec.
+    if ((texture_type == BaseColorTexture) ||
+        (texture_type == EmissiveTexture)) {
+      cmd->colour_space = sRGB;
+    } else {
       cmd->colour_space = LinearColourSpace;
     }
 
@@ -778,22 +778,22 @@ static bool load_materials(
           .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};
+      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};
+      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)};
+      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_and_uniform(
@@ -854,28 +854,28 @@ static Material* make_default_material() {
   MaterialDesc desc = (MaterialDesc){0};
 
   assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
-      .name       = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
-      .type       = UniformVec4,
-      .value.vec4 = vec4_make(1, 1, 1, 1)};
+  desc.uniforms[desc.num_uniforms++] =
+      (ShaderUniform){.name       = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
+                      .type       = UniformVec4,
+                      .value.vec4 = vec4_make(1, 1, 1, 1)};
 
   assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
-      .name         = sstring_make(UNIFORM_METALLIC_FACTOR),
-      .type         = UniformFloat,
-      .value.scalar = 0};
+  desc.uniforms[desc.num_uniforms++] =
+      (ShaderUniform){.name         = sstring_make(UNIFORM_METALLIC_FACTOR),
+                      .type         = UniformFloat,
+                      .value.scalar = 0};
 
   assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
-      .name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
-      .type         = UniformFloat,
-      .value.scalar = 1};
+  desc.uniforms[desc.num_uniforms++] =
+      (ShaderUniform){.name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
+                      .type         = UniformFloat,
+                      .value.scalar = 1};
 
   assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
-      .name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
-      .type       = UniformVec3,
-      .value.vec3 = vec3_make(0, 0, 0)};
+  desc.uniforms[desc.num_uniforms++] =
+      (ShaderUniform){.name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
+                      .type       = UniformVec3,
+                      .value.vec3 = vec3_make(0, 0, 0)};
 
   return gfx_make_material(&desc);
 }
@@ -1192,10 +1192,10 @@ static bool load_meshes(
           shader ? shader : make_shader_permutation(gfxcore, perm);
       assert(mesh_shader);
 
-      meshes[next_mesh] = gfx_make_mesh(&(MeshDesc){
-          .geometry = geometries[next_mesh],
-          .material = material,
-          .shader   = mesh_shader});
+      meshes[next_mesh] =
+          gfx_make_mesh(&(MeshDesc){.geometry = geometries[next_mesh],
+                                    .material = material,
+                                    .shader   = mesh_shader});
 
       if (!meshes[next_mesh]) {
         return false;
@@ -1432,9 +1432,9 @@ static void load_animations(
     const cgltf_animation* animation      = &data->animations[a];
     AnimationDesc*         animation_desc = &anima_desc->animations[a];
 
-    *animation_desc = (AnimationDesc){
-        .name         = sstring_make(animation->name),
-        .num_channels = animation->channels_count};
+    *animation_desc =
+        (AnimationDesc){.name         = sstring_make(animation->name),
+                        .num_channels = animation->channels_count};
 
     assert(animation->channels_count <= GFX_MAX_NUM_CHANNELS);
     for (cgltf_size c = 0; c < animation->channels_count; ++c) {
diff --git a/gfx/src/asset/model.h b/src/asset/model.h
index d6399b1..d6399b1 100644
--- a/gfx/src/asset/model.h
+++ b/src/asset/model.h
diff --git a/gfx/src/asset/texture.c b/src/asset/texture.c
index c790394..fb423cc 100644
--- a/gfx/src/asset/texture.c
+++ b/src/asset/texture.c
@@ -49,7 +49,7 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
   assert(cmd->origin == AssetFromFile || cmd->origin == AssetFromMemory);
   assert(cmd->type == LoadTexture || cmd->type == LoadCubemap);
 
-  int            width, height, components, old_components;
+  int            width, height, components;
   unsigned char* pixels[6] = {0};
 
   switch (cmd->origin) {
@@ -64,7 +64,8 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
       }
       break;
     }
-    case LoadCubemap:
+    case LoadCubemap: {
+      int old_components = 0;
       for (int i = 0; i < 6; ++i) {
         // Flip +Y and -Y textures vertically.
         stbi_set_flip_vertically_on_load(((i == 2) || (i == 3)) ? 1 : 0);
@@ -76,9 +77,10 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
           log_error("Failed to load texture file: %s", filepath);
           break;
         }
-        if (i > 0 && components != old_components) {
-          log_error("All textures in a cubemap must have the same number of "
-                    "components");
+        if ((i > 0) && (components != old_components)) {
+          log_error(
+              "All textures in a cubemap must have the same number of "
+              "components");
           break;
         }
         if ((i != 2) && (i != 3)) {
@@ -89,6 +91,7 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
       }
       break;
     }
+    }
     break;
   case AssetFromMemory:
     // TODO: Load textures from memory.
@@ -122,6 +125,25 @@ Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
   }
 
   switch (components) {
+  case 1:
+    switch (cmd->colour_space) {
+    case LinearColourSpace:
+      desc.format = TextureR8;
+      break;
+    case sRGB:
+      // TODO: Gamma single-channel textures are not implemented yet.
+      //  The caller should convert the single-channel to RGB and pass it down
+      //  as sRGB. This is why the ChronographWatch currently appears red on the
+      //  back.
+      log_error("Gamma colour space is not supported for 1-channel textures");
+      // return 0;
+      desc.format = TextureR8;
+      break;
+    default:
+      log_error("Unsupported texture colour space: %d", cmd->colour_space);
+      return 0;
+    }
+    break;
   case 3:
     switch (cmd->colour_space) {
     case LinearColourSpace:
diff --git a/gfx/src/asset/texture.h b/src/asset/texture.h
index 0d38bd9..0d38bd9 100644
--- a/gfx/src/asset/texture.h
+++ b/src/asset/texture.h
diff --git a/gfx/src/core/buffer.c b/src/core/buffer.c
index 3b7e4bc..3b7e4bc 100644
--- a/gfx/src/core/buffer.c
+++ b/src/core/buffer.c
diff --git a/gfx/src/core/buffer.h b/src/core/buffer.h
index b9080f0..b9080f0 100644
--- a/gfx/src/core/buffer.h
+++ b/src/core/buffer.h
diff --git a/gfx/src/core/constants.h b/src/core/constants.h
index a6a3b94..a6a3b94 100644
--- a/gfx/src/core/constants.h
+++ b/src/core/constants.h
diff --git a/gfx/src/core/core.c b/src/core/core.c
index 90038c6..e1671ea 100644
--- a/gfx/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/gfx/src/core/core_impl.h b/src/core/core_impl.h
index eefdfbe..eefdfbe 100644
--- a/gfx/src/core/core_impl.h
+++ b/src/core/core_impl.h
diff --git a/gfx/src/core/framebuffer.c b/src/core/framebuffer.c
index 76d9002..76d9002 100644
--- a/gfx/src/core/framebuffer.c
+++ b/src/core/framebuffer.c
diff --git a/gfx/src/core/framebuffer.h b/src/core/framebuffer.h
index 1a3439c..1a3439c 100644
--- a/gfx/src/core/framebuffer.h
+++ b/src/core/framebuffer.h
diff --git a/gfx/src/core/geometry.c b/src/core/geometry.c
index cfc749f..cfc749f 100644
--- a/gfx/src/core/geometry.c
+++ b/src/core/geometry.c
diff --git a/gfx/src/core/geometry.h b/src/core/geometry.h
index c37a76f..c37a76f 100644
--- a/gfx/src/core/geometry.h
+++ b/src/core/geometry.h
diff --git a/gfx/src/core/gl_util.h b/src/core/gl_util.h
index d2d6e22..d2d6e22 100644
--- a/gfx/src/core/gl_util.h
+++ b/src/core/gl_util.h
diff --git a/gfx/src/core/renderbuffer.c b/src/core/renderbuffer.c
index 2753f3b..2753f3b 100644
--- a/gfx/src/core/renderbuffer.c
+++ b/src/core/renderbuffer.c
diff --git a/gfx/src/core/renderbuffer.h b/src/core/renderbuffer.h
index ea11610..ea11610 100644
--- a/gfx/src/core/renderbuffer.h
+++ b/src/core/renderbuffer.h
diff --git a/gfx/src/core/shader.c b/src/core/shader.c
index dded084..dded084 100644
--- a/gfx/src/core/shader.c
+++ b/src/core/shader.c
diff --git a/gfx/src/core/shader.h b/src/core/shader.h
index b9f5679..b9f5679 100644
--- a/gfx/src/core/shader.h
+++ b/src/core/shader.h
diff --git a/gfx/src/core/shader_program.c b/src/core/shader_program.c
index 3cbe48d..3cbe48d 100644
--- a/gfx/src/core/shader_program.c
+++ b/src/core/shader_program.c
diff --git a/gfx/src/core/shader_program.h b/src/core/shader_program.h
index 1443663..1443663 100644
--- a/gfx/src/core/shader_program.h
+++ b/src/core/shader_program.h
diff --git a/gfx/src/core/texture.c b/src/core/texture.c
index 89f7ec0..372f9e6 100644
--- a/gfx/src/core/texture.c
+++ b/src/core/texture.c
@@ -37,6 +37,7 @@ bool gfx_init_texture(Texture* texture, const TextureDesc* desc) {
     gfx_del_texture(texture);
     return false;
   }
+  ASSERT_GL;
 
   texture->format = to_GL_format(desc->format);
   texture->type   = to_GL_type(desc->format);
@@ -50,6 +51,7 @@ bool gfx_init_texture(Texture* texture, const TextureDesc* desc) {
   // Mipmaps.
   if (desc->mipmaps) {
     glGenerateMipmap(texture->target);
+    ASSERT_GL;
   }
 
   // Texture filtering.
@@ -60,6 +62,7 @@ bool gfx_init_texture(Texture* texture, const TextureDesc* desc) {
   GLenum     mag    = linear ? GL_LINEAR : GL_NEAREST;
   glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, min);
   glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, mag);
+  ASSERT_GL;
 
   // Texture wrapping.
   GLenum wrap = GL_INVALID_ENUM;
@@ -74,6 +77,7 @@ bool gfx_init_texture(Texture* texture, const TextureDesc* desc) {
   glTexParameteri(texture->target, GL_TEXTURE_WRAP_R, wrap);
   glTexParameteri(texture->target, GL_TEXTURE_WRAP_S, wrap);
   glTexParameteri(texture->target, GL_TEXTURE_WRAP_T, wrap);
+  ASSERT_GL;
 
   glBindTexture(texture->target, 0);
   return true;
@@ -119,6 +123,7 @@ void gfx_update_texture(Texture* texture, const TextureDataDesc* desc) {
     FAIL("Unhandled texture dimension");
     break;
   }
+  ASSERT_GL;
 
   glBindTexture(texture->target, 0);
 }
@@ -139,6 +144,8 @@ GLenum to_GL_internal_format(TextureFormat format) {
   switch (format) {
   case TextureDepth:
     return GL_DEPTH_COMPONENT;
+  case TextureR8:
+    return GL_R8;
   case TextureRG16:
     return GL_RG16;
   case TextureRG16F:
@@ -163,6 +170,8 @@ GLenum to_GL_format(TextureFormat format) {
   switch (format) {
   case TextureDepth:
     return GL_DEPTH_COMPONENT;
+  case TextureR8:
+    return GL_RED;
   case TextureRG16:
   case TextureRG16F:
     return GL_RG;
@@ -185,6 +194,7 @@ GLenum to_GL_type(TextureFormat format) {
   case TextureRG16F:
   case TextureR11G11B10F:
     return GL_FLOAT;
+  case TextureR8:
   case TextureRG16:
   case TextureRGB8:
   case TextureRGBA8:
diff --git a/gfx/src/core/texture.h b/src/core/texture.h
index 4af41e9..4af41e9 100644
--- a/gfx/src/core/texture.h
+++ b/src/core/texture.h
diff --git a/gfx/src/gfx.c b/src/gfx.c
index cd2ac90..39b04cd 100644
--- a/gfx/src/gfx.c
+++ b/src/gfx.c
@@ -2,11 +2,10 @@
 
 #include "asset/asset_cache.h"
 #include "core/core_impl.h"
+#include "llr/llr_impl.h"
+#include "memory.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>
@@ -14,8 +13,9 @@
 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/gfx/src/gfx_assert.h b/src/gfx_assert.h
index f4b3aa5..f4b3aa5 100644
--- a/gfx/src/gfx_assert.h
+++ b/src/gfx_assert.h
diff --git a/gfx/src/scene/light.c b/src/llr/light.c
index adbec8d..0fa1522 100644
--- a/gfx/src/scene/light.c
+++ b/src/llr/light.c
@@ -1,7 +1,7 @@
 #include "light_impl.h"
 
-#include "node_impl.h"
-#include "scene_memory.h"
+#include "memory.h"
+#include "scene/node_impl.h"
 
 #include <error.h>
 
diff --git a/gfx/src/scene/light_impl.h b/src/llr/light_impl.h
index 1aa0bb4..5ec8145 100644
--- a/gfx/src/scene/light_impl.h
+++ b/src/llr/light_impl.h
@@ -1,8 +1,8 @@
 #pragma once
 
-#include <gfx/scene/light.h>
+#include <gfx/llr/light.h>
 
-#include "types.h"
+#include "scene/types.h"
 
 typedef struct Texture Texture;
 
diff --git a/src/llr/llr.c b/src/llr/llr.c
new file mode 100644
index 0000000..fe02c0d
--- /dev/null
+++ b/src/llr/llr.c
@@ -0,0 +1,406 @@
+#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 <cassert.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;
+
+/// Initialize renderer state for IBL.
+static bool init_ibl(LLR* renderer) {
+  assert(renderer);
+  assert(!renderer->ibl);
+  assert(!renderer->brdf_integration_map);
+
+  if (!((renderer->ibl = gfx_make_ibl(renderer->gfxcore)))) {
+    return false;
+  }
+
+  if (!((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;
+}
+
+/// Compute irradiance and prefiltered environment maps for the light if they
+/// have not been already computed.
+///
+/// This is done lazily here, and not when the light is created, because we
+/// need an IBL instance to do this and it is more convenient for the public
+/// API to create lights without worrying about those details. It also makes the
+/// public API cheaper, since the maps are only computed when they are actually
+/// needed.
+static bool set_up_environment_light(LLR* renderer, EnvironmentLight* light) {
+  assert(renderer);
+  assert(light);
+  assert(renderer->ibl);
+  assert(renderer->brdf_integration_map);
+
+  if (light->irradiance_map) {
+    assert(light->prefiltered_environment_map);
+    return true;
+  }
+
+  // For convenience.
+  GfxCore* gfxcore = renderer->gfxcore;
+
+  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;
+}
+
+static void configure_light(LLR* renderer, Light* light) {
+  assert(renderer);
+  assert(light);
+
+  // For convenience.
+  ShaderProgram* const shader = renderer->shader;
+
+  switch (light->type) {
+  case EnvironmentLightType: {
+    EnvironmentLight* env = &light->environment;
+
+    const bool initialized = set_up_environment_light(renderer, env);
+    ASSERT(initialized);
+    assert(env->environment_map);
+    assert(env->irradiance_map);
+    assert(env->prefiltered_environment_map);
+    assert(renderer->brdf_integration_map);
+
+    gfx_set_texture_uniform(
+        shader, "BRDFIntegrationMap", renderer->brdf_integration_map);
+    gfx_set_texture_uniform(shader, "Sky", env->environment_map);
+    gfx_set_texture_uniform(shader, "IrradianceMap", env->irradiance_map);
+    gfx_set_texture_uniform(
+        shader, "PrefilteredEnvironmentMap", env->prefiltered_environment_map);
+    gfx_set_float_uniform(
+        shader, "MaxReflectionLOD", (float)env->max_reflection_lod);
+
+    break;
+  }
+  default:
+    assert(false); // TODO: Implement other light types.
+    break;
+  }
+}
+
+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 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
+  //  primitive calls like setting a new shader.
+  if (renderer->camera_changed || renderer->shader_changed) {
+    renderer->camera_changed = false;
+
+    // Set all supported camera-related uniforms. Shaders can choose which ones
+    // to use.
+    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, "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) {
+    renderer->lights_changed = false;
+
+    // TODO: Could do better by only setting the lights that have actually
+    //  changed.
+    // TODO: Will also need to pass the number of lights to the shader once the
+    //  other light types are implemented.
+    for (int i = 0; i < renderer->num_lights; ++i) {
+      configure_light(renderer, renderer->lights[i]);
+    }
+  }
+
+  if (renderer->skeleton_changed || renderer->shader_changed) {
+    renderer->skeleton_changed = false;
+
+    if (renderer->num_joints > 0) {
+      gfx_set_mat4_array_uniform(
+          shader, "JointMatrices", renderer->joint_matrices,
+          renderer->num_joints);
+    }
+  }
+
+  if (renderer->material_changed || renderer->shader_changed) {
+    renderer->material_changed = false;
+
+    gfx_material_activate(renderer->shader, renderer->material);
+  }
+
+  if (renderer->shader_changed) {
+    renderer->shader_changed = false;
+    gfx_activate_shader_program(renderer->shader);
+  }
+
+  // TODO: At present, this results in many redundant calls to
+  //  glGetUniformLocation() and glUniformXyz(). Look at the trace.
+  //
+  // TODO: Could add to qapitrace functionality to detect redundant calls and
+  //  other inefficiencies. Maybe ask in the Github first if there would be
+  //  interest in this.
+  //
+  // Must be called after activating the program.
+  gfx_apply_uniforms(renderer->shader);
+}
+
+bool gfx_llr_make(LLR* renderer, GfxCore* gfxcore) {
+  assert(renderer);
+  assert(gfxcore);
+
+  renderer->gfxcore = gfxcore;
+  if (!init_ibl(renderer)) {
+    goto cleanup;
+  }
+  gfx_llr_load_identity(renderer);
+  renderer->view            = mat4_id();
+  renderer->projection      = mat4_id();
+  renderer->camera_rotation = mat4_id();
+  return true;
+
+cleanup:
+  gfx_llr_destroy(renderer);
+  return false;
+}
+
+void gfx_llr_destroy(LLR* renderer) {
+  assert(renderer);
+  assert(renderer->gfxcore);
+
+  if (renderer->brdf_integration_map) {
+    gfx_destroy_texture(renderer->gfxcore, &renderer->brdf_integration_map);
+  }
+
+  // TODO: Do this once the IBL from the scene renderer is gone.
+  if (renderer->ibl) {
+    // gfx_destroy_ibl(renderer->gfxcore, &renderer->ibl);
+  }
+}
+
+void gfx_llr_set_shader(LLR* renderer, ShaderProgram* shader) {
+  assert(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.
+  if (renderer->shader != shader) {
+    renderer->shader         = shader;
+    renderer->shader_changed = true;
+  }
+}
+
+void gfx_llr_push_light(LLR* renderer, Light* light) {
+  assert(renderer);
+  assert(light);
+  assert(renderer->num_lights >= 0);
+  ASSERT(renderer->num_lights < GFX_LLR_MAX_NUM_LIGHTS);
+
+  renderer->lights[renderer->num_lights++] = light;
+  renderer->lights_changed                 = true;
+}
+
+void gfx_llr_pop_light(LLR* renderer) {
+  assert(renderer);
+  ASSERT(renderer->num_lights > 0);
+
+  renderer->lights[--renderer->num_lights] = 0;
+  renderer->lights_changed                 = true;
+}
+
+void gfx_llr_set_skeleton(
+    LLR* renderer, const Anima* anima, const Skeleton* skeleton) {
+  assert(renderer);
+  assert(anima);
+  assert(skeleton);
+  assert(skeleton->num_joints <= GFX_MAX_NUM_JOINTS);
+
+  for (size_t i = 0; i < skeleton->num_joints; ++i) {
+    const joint_idx joint_index = skeleton->joints[i];
+    const Joint*    joint       = &anima->joints[joint_index];
+    renderer->joint_matrices[i] = joint->joint_matrix;
+  }
+  renderer->num_joints       = skeleton->num_joints;
+  renderer->skeleton_changed = true;
+}
+
+void gfx_llr_clear_skeleton(LLR* renderer) {
+  assert(renderer);
+
+  renderer->num_joints       = 0;
+  renderer->skeleton_changed = true;
+}
+
+void gfx_llr_set_material(LLR* renderer, const Material* material) {
+  assert(renderer);
+  assert(material);
+
+  renderer->material         = material;
+  renderer->material_changed = true;
+}
+
+void gfx_llr_set_camera(LLR* renderer, const Camera* camera) {
+  assert(renderer);
+
+  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_llr_set_aspect(LLR* renderer, float aspect) {
+  assert(renderer);
+
+  renderer->aspect         = aspect;
+  renderer->camera_changed = true;
+}
+
+void gfx_llr_render_geometry(LLR* renderer, const Geometry* geometry) {
+  assert(renderer);
+  assert(geometry);
+
+  configure_state(renderer);
+  gfx_render_geometry(geometry);
+}
+
+void gfx_llr_render_mesh(LLR* renderer, const Mesh* mesh) {
+  assert(renderer);
+  assert(mesh);
+  assert(mesh->geometry);
+  assert(mesh->material);
+  assert(mesh->shader);
+
+  gfx_llr_set_material(renderer, mesh->material);
+  gfx_llr_set_shader(renderer, mesh->shader);
+  gfx_llr_render_geometry(renderer, mesh->geometry);
+}
+
+void gfx_llr_load_identity(LLR* renderer) {
+  assert(renderer);
+
+  renderer->matrix_stack[0] = mat4_id();
+  renderer->stack_pointer   = 0;
+  renderer->matrix_changed  = true;
+}
+
+void gfx_llr_push_matrix(LLR* renderer, const mat4* matrix) {
+  assert(renderer);
+  assert(matrix);
+  assert(renderer->stack_pointer >= 0);
+  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]);
+  renderer->matrix_changed = true;
+}
+
+void gfx_llr_pop_matrix(LLR* renderer) {
+  assert(renderer);
+  ASSERT(renderer->stack_pointer > 0);
+
+  // For debugging, zero out the matrix stack as matrices are popped out.
+  memset(
+      &renderer->matrix_stack[renderer->stack_pointer], 0,
+      sizeof(renderer->matrix_stack[0]));
+  renderer->stack_pointer -= 1;
+  renderer->matrix_changed = true;
+}
+
+void gfx_llr_translate(LLR* renderer, vec3 offset) {
+  assert(renderer);
+
+  const mat4 mat = mat4_translate(offset);
+  gfx_llr_push_matrix(renderer, &mat);
+}
+
+void gfx_llr_set_model_matrix(LLR* renderer, const mat4* model) {
+  assert(renderer);
+  assert(model);
+
+  renderer->matrix_stack[0] = *model;
+  renderer->stack_pointer   = 0;
+  renderer->matrix_changed  = true;
+}
diff --git a/src/llr/llr_impl.h b/src/llr/llr_impl.h
new file mode 100644
index 0000000..3f6a68f
--- /dev/null
+++ b/src/llr/llr_impl.h
@@ -0,0 +1,86 @@
+#pragma once
+
+#include <gfx/llr/llr.h>
+#include <gfx/sizes.h>
+
+#include <math/mat4.h>
+#include <math/vec3.h>
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct Geometry      Geometry;
+typedef struct GfxCore       GfxCore;
+typedef struct IBL           IBL;
+typedef struct Material      Material;
+typedef struct ShaderProgram ShaderProgram;
+typedef struct Texture       Texture;
+
+/// Immediate mode renderer.
+///
+/// The renderer caches state changes in memory and only programs the underlying
+/// shader program when a draw call is issued and if anything has changed. This
+/// keeps the number of graphics API calls to a minimum, but requires tracking
+/// state changes. The 'changed' booleans below fulfill this purpose, and
+/// indicate whether a given state has changed since the last draw call.
+///
+/// The renderer must combine state changes accordingly. For example, if only
+/// the lights have changed, then it is sufficient to update light uniforms in
+/// the current shader program. On the other hand, if the shader program has
+/// changed, then the renderer must reconfigure it from scratch and set light
+/// uniforms, camera uniforms, etc.
+///
+/// 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.
+typedef struct LLR {
+  GfxCore* gfxcore;
+
+  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 material_changed : 1; // Whether the material 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.
+
+  const Material* material; // Active material. 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[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.
+
+  size_t num_joints;
+  mat4   joint_matrices[GFX_MAX_NUM_JOINTS];
+
+  // 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[GFX_LLR_MAX_NUM_MATRICES];
+  int  stack_pointer; // Points to the top of the stack.
+} LLR;
+
+/// Create a new immediate mode renderer.
+bool gfx_llr_make(LLR*, GfxCore*);
+
+/// Destroy the immediate mode renderer.
+void gfx_llr_destroy(LLR*);
diff --git a/gfx/src/scene/material.c b/src/llr/material.c
index 3248243..f09dd3f 100644
--- a/gfx/src/scene/material.c
+++ b/src/llr/material.c
@@ -1,6 +1,6 @@
 #include "material_impl.h"
 
-#include "scene_memory.h"
+#include "memory.h"
 
 #include <gfx/core.h>
 
@@ -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
new file mode 100644
index 0000000..2b7cd89
--- /dev/null
+++ b/src/llr/material_impl.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <gfx/llr/material.h>
+
+typedef struct ShaderProgram ShaderProgram;
+
+typedef struct Material {
+  ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
+  int           num_uniforms;
+} Material;
+
+/// Activate the material.
+///
+/// This configures the shader uniforms that are specific to the material.
+void gfx_material_activate(ShaderProgram* shader, const Material* material);
diff --git a/gfx/src/scene/mesh.c b/src/llr/mesh.c
index 1a93bed..5f9e5d0 100644
--- a/gfx/src/scene/mesh.c
+++ b/src/llr/mesh.c
@@ -1,6 +1,6 @@
 #include "mesh_impl.h"
 
-#include "scene_memory.h"
+#include "memory.h"
 
 #include <assert.h>
 
diff --git a/src/llr/mesh_impl.h b/src/llr/mesh_impl.h
new file mode 100644
index 0000000..96e60df
--- /dev/null
+++ b/src/llr/mesh_impl.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <gfx/llr/mesh.h>
+
+typedef struct Mesh {
+  const Geometry* geometry;
+  const Material* material;
+  ShaderProgram*  shader;
+} Mesh;
diff --git a/gfx/src/scene/scene_memory.c b/src/memory.c
index 85c27e7..59bf8ca 100644
--- a/gfx/src/scene/scene_memory.c
+++ b/src/memory.c
@@ -1,17 +1,18 @@
-#include "scene_memory.h"
+#include "memory.h"
 
 #include <gfx/sizes.h>
 
-#include "animation_impl.h"
-#include "camera_impl.h"
-#include "light_impl.h"
-#include "material_impl.h"
-#include "mesh_impl.h"
-#include "model_impl.h"
-#include "node_impl.h"
-#include "object_impl.h"
-#include "scene_impl.h"
+#include "llr/light_impl.h"
+#include "llr/material_impl.h"
+#include "llr/mesh_impl.h"
+#include "scene/animation_impl.h"
+#include "scene/camera_impl.h"
+#include "scene/model_impl.h"
+#include "scene/node_impl.h"
+#include "scene/object_impl.h"
+#include "scene/scene_impl.h"
 
+#include <log/log.h>
 #include <mempool.h>
 
 DEF_MEMPOOL(anima_pool, Anima, GFX_MAX_NUM_ANIMAS)
@@ -47,10 +48,11 @@ typedef struct SceneMemory {
 
 static SceneMemory mem;
 
-#define ALLOC_DUMMY(POOL)                               \
-  {                                                     \
-    const void* object = mempool_alloc(POOL);           \
-    assert(mempool_get_block_index(POOL, object) == 0); \
+#define ALLOC_DUMMY(POOL)                                  \
+  {                                                        \
+    const void* object = mempool_alloc(POOL);              \
+    (void)object; /* Silence warning in release builds. */ \
+    assert(mempool_get_block_index(POOL, object) == 0);    \
   }
 
 #define PLURAL(name)    name##s
@@ -71,7 +73,7 @@ void scene_mem_init() {
   mempool_make(&mem.skeletons);
 
   // Allocate dummy objects at index 0 to guarantee that no objects allocated by
-  // the caller map to index 0.
+  // the caller map to index 0. This allows 0 to be used as a sentinel.
   ALLOC_DUMMY(&mem.animas);
   ALLOC_DUMMY(&mem.animations);
   ALLOC_DUMMY(&mem.cameras);
@@ -90,13 +92,40 @@ void scene_mem_destroy() {
   // NOTE: the dummy objects are not constructed, so the destruction code below
   // always skips index 0. (I don't really like the conditional inside the loop,
   // but this gets the job done without having to specialize the loop macro.)
-#define DESTROY(name)                      \
-  mempool_foreach(&MEM_FIELD(name), obj, { \
+#define DESTROY(NAME)                      \
+  mempool_foreach(&MEM_FIELD(NAME), obj, { \
     if (i > 0) {                           \
-      gfx_destroy_##name(&obj);            \
+      gfx_destroy_##NAME(&obj);            \
     }                                      \
   })
 
+  // Print memory diagnostics.
+#define PRINT_POOL(POOL_NAME, POOL)                                    \
+  {                                                                    \
+    const size_t capacity         = mempool_capacity(POOL);            \
+    const size_t size             = mempool_size(POOL);                \
+    const size_t block_size_bytes = mempool_block_size_bytes(POOL);    \
+    const size_t size_bytes       = size * block_size_bytes;           \
+    const size_t capacity_bytes   = capacity * block_size_bytes;       \
+    LOGI(                                                              \
+        "%s pool: %lu/%lu (%lu/%lu bytes)", POOL_NAME, size, capacity, \
+        size_bytes, capacity_bytes);                                   \
+  }
+
+  LOGI("Pool diagnostics:");
+  PRINT_POOL("Animas", &mem.animas);
+  PRINT_POOL("Animations", &mem.animations);
+  PRINT_POOL("Cameras", &mem.cameras);
+  PRINT_POOL("Lights", &mem.lights);
+  PRINT_POOL("Materials", &mem.materials);
+  PRINT_POOL("Meshes", &mem.meshs);
+  PRINT_POOL("Mesh links", &mem.mesh_links);
+  PRINT_POOL("Models", &mem.models);
+  PRINT_POOL("Nodes", &mem.nodes);
+  PRINT_POOL("Objects", &mem.objects);
+  PRINT_POOL("Scenes", &mem.scenes);
+  PRINT_POOL("Skeletons", &mem.skeletons);
+
   // Models contain scene elements. Destruction is handled by the remainder of
   // scene destructionb elow.
   //
@@ -119,20 +148,20 @@ void scene_mem_destroy() {
   // Skeletons are owned by animas and do not have a destructor.
 }
 
-#define DEF_MEMORY(name, type)                                              \
+#define DEF_MEMORY(NAME, TYPE)                                              \
   /* xyz* mem_alloc_xyz(); */                                               \
-  type* mem_alloc_##name() { return mempool_alloc(&MEM_FIELD(name)); }      \
+  TYPE* mem_alloc_##NAME() { return mempool_alloc(&MEM_FIELD(NAME)); }      \
   /* void mem_free_xyz(xyz**); */                                           \
-  void mem_free_##name(type** obj) { mempool_free(&MEM_FIELD(name), obj); } \
+  void mem_free_##NAME(TYPE** obj) { mempool_free(&MEM_FIELD(NAME), obj); } \
   /* xyz* mem_get_xyz(xyz_idx); */                                          \
-  type* mem_get_##name(NAMED_INDEX(name) index) {                           \
+  TYPE* mem_get_##NAME(NAMED_INDEX(NAME) index) {                           \
     assert(index.val != 0); /* 0 is the dummy allocation. */                \
-    return mempool_get_block(&MEM_FIELD(name), index.val);                  \
+    return mempool_get_block(&MEM_FIELD(NAME), index.val);                  \
   }                                                                         \
   /* xyz_idx mem_get_xyz_index(const xyz*); */                              \
-  NAMED_INDEX(name) mem_get_##name##_index(const type* obj) {               \
-    return (NAMED_INDEX(name)){                                             \
-        .val = mempool_get_block_index(&MEM_FIELD(name), obj)};             \
+  NAMED_INDEX(NAME) mem_get_##NAME##_index(const TYPE* obj) {               \
+    return (NAMED_INDEX(NAME)){                                             \
+        .val = mempool_get_block_index(&MEM_FIELD(NAME), obj)};             \
   }
 
 DEF_MEMORY(anima, Anima)
diff --git a/gfx/src/scene/scene_memory.h b/src/memory.h
index d175cba..366c6e4 100644
--- a/gfx/src/scene/scene_memory.h
+++ b/src/memory.h
@@ -1,7 +1,7 @@
 /// Memory management of scene objects.
 #pragma once
 
-#include "types.h"
+#include "scene/types.h"
 
 /// Initialize scene memory.
 ///
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/gfx/src/renderer/imm_renderer_impl.h b/src/renderer/imm_renderer_impl.h
index 5ece354..61b49a7 100644
--- a/gfx/src/renderer/imm_renderer_impl.h
+++ b/src/renderer/imm_renderer_impl.h
@@ -1,44 +1,43 @@
 #pragma once
 
-#include <gfx/renderer.h>
 #include <gfx/sizes.h>
 
-#include <math/mat4.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;
-  ShaderProgram* shader;
+  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[IMM_MAX_NUM_TRIANGLES * 3];
-  // 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];
-  int  stack_pointer;
+  vec3 triangle_verts[GFX_IMM_MAX_NUM_TRIANGLES * 3];
 } ImmRenderer;
 
 /// Create a new immediate mode renderer.
-bool imm_renderer_make(ImmRenderer*, GfxCore*);
+bool gfx_imm_make(ImmRenderer*, GfxCore*, LLR*);
 
 /// Destroy the immediate mode renderer.
-void imm_renderer_destroy(ImmRenderer*);
-
-/// Flush draw commands.
-void imm_renderer_flush(ImmRenderer*);
+void gfx_imm_destroy(ImmRenderer*);
diff --git a/src/renderer/renderer.c b/src/renderer/renderer.c
new file mode 100644
index 0000000..6bcf5cc
--- /dev/null
+++ b/src/renderer/renderer.c
@@ -0,0 +1,247 @@
+#include "renderer_impl.h"
+
+#include "llr/light_impl.h"
+#include "llr/mesh_impl.h"
+#include "memory.h"
+#include "scene/animation_impl.h"
+#include "scene/camera_impl.h"
+#include "scene/model_impl.h"
+#include "scene/node_impl.h"
+#include "scene/object_impl.h"
+#include "scene/scene_impl.h"
+
+#include <gfx/core.h>
+#include <gfx/llr/llr.h>
+#include <gfx/util/shader.h>
+
+#include <math/mat4.h>
+
+#include <assert.h>
+
+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 gfx_renderer_destroy(Renderer* renderer) {
+  if (!renderer) {
+    return;
+  }
+  assert(renderer->gfxcore);
+  GfxCore* gfxcore = renderer->gfxcore;
+  if (renderer->shaders.debug) {
+    gfx_destroy_shader_program(gfxcore, &renderer->shaders.debug);
+  }
+  if (renderer->shaders.normals) {
+    gfx_destroy_shader_program(gfxcore, &renderer->shaders.normals);
+  }
+  if (renderer->shaders.normal_mapped_normals) {
+    gfx_destroy_shader_program(
+        gfxcore, &renderer->shaders.normal_mapped_normals);
+  }
+  if (renderer->shaders.tangents) {
+    gfx_destroy_shader_program(gfxcore, &renderer->shaders.tangents);
+  }
+}
+
+static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) {
+  assert(renderer);
+
+#define LOAD_AND_RETURN(pShader, constructor)   \
+  {                                             \
+    if (!pShader) {                             \
+      pShader = constructor(renderer->gfxcore); \
+    }                                           \
+    assert(pShader);                            \
+    return pShader;                             \
+  }
+
+  switch (mode) {
+  case RenderDefault:
+    return 0;
+  case RenderDebug:
+    LOAD_AND_RETURN(renderer->shaders.debug, gfx_make_debug3d_shader);
+  case RenderNormals:
+    LOAD_AND_RETURN(renderer->shaders.normals, gfx_make_view_normals_shader);
+  case RenderNormalMappedNormals:
+    LOAD_AND_RETURN(
+        renderer->shaders.normal_mapped_normals,
+        gfx_make_view_normal_mapped_normals_shader);
+  case RenderTangents:
+    LOAD_AND_RETURN(renderer->shaders.tangents, gfx_make_view_tangents_shader);
+  }
+  assert(false);
+  return 0;
+}
+
+// static void log_matrix(const mat4* m) {
+//   for (int row = 0; row < 4; ++row) {
+//     LOGI("[ %5.2f, %5.2f, %5.2f, %5.2f ]", m->val[0][row], m->val[1][row],
+//          m->val[2][row], m->val[3][row]);
+//   }
+// }
+
+typedef struct RenderState {
+  GfxCore*       gfxcore;
+  LLR*           llr;
+  Renderer*      renderer;
+  ShaderProgram* shader; // Null to use scene shaders.
+  const Scene*   scene;
+  const Anima*   anima;
+} RenderState;
+
+static void draw_children(
+    RenderState* state, const mat4* node_transform, const SceneNode* node);
+
+/// Draw the scene recursively.
+static void draw_recursively(
+    RenderState* state, mat4 parent_transform, const SceneNode* node) {
+  assert(state);
+  const mat4 node_transform = mat4_mul(parent_transform, node->transform);
+
+  // 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);
+    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) {
+    const SceneObject* object = mem_get_object(node->object);
+    assert(object);
+
+    // TODO: Here we would frustum-cull the object.
+
+    // 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) {
+      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);
+      mesh_link_index           = mesh_link->next;
+
+      const Mesh* mesh = mem_get_mesh(mesh_link->mesh);
+      if (!mesh) {
+        continue;
+      }
+
+      // 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.
+
+      ShaderProgram* shader = state->shader ? state->shader : mesh->shader;
+      gfx_llr_set_shader(state->llr, shader);
+      gfx_llr_set_model_matrix(state->llr, &model_matrix);
+      gfx_llr_render_mesh(state->llr, mesh);
+    }
+
+    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);
+    child_index = child->next;
+  }
+}
+
+void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) {
+  assert(renderer);
+  assert(params);
+  assert(params->scene);
+
+  ShaderProgram* const shader = load_shader(renderer, params->mode);
+
+  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 R aspect = (R)width / (R)height;
+
+  RenderState state = {
+      .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);
+}
+
+static void update_rec(SceneNode* node, const SceneCamera* camera, R t) {
+  assert(node);
+  assert(camera);
+
+  const NodeType node_type = gfx_get_node_type(node);
+
+  // TODO: Models do not need to be animated if they are not visible to the
+  //  camera.
+  if (node_type == AnimaNode) {
+    Anima* anima = gfx_get_node_anima_mut(node);
+    gfx_update_animation(anima, (R)t);
+  } else if (node_type == ModelNode) {
+    Model*     model = gfx_get_node_model_mut(node);
+    SceneNode* root  = gfx_get_model_root_mut(model);
+    update_rec(root, camera, t);
+  }
+
+  // Children.
+  SceneNode* child = gfx_get_node_child_mut(node);
+  while (child) {
+    update_rec(child, camera, t);
+    child = gfx_get_node_sibling_mut(child);
+  }
+}
+
+void gfx_update(Scene* scene, const SceneCamera* camera, R t) {
+  assert(scene);
+  assert(camera);
+
+  SceneNode* node = gfx_get_scene_root(scene);
+  update_rec(node, camera, t);
+}
diff --git a/gfx/src/renderer/renderer_impl.h b/src/renderer/renderer_impl.h
index fc14dcb..7395915 100644
--- a/gfx/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/gfx/src/scene/animation.c b/src/scene/animation.c
index 08d02ce..601c400 100644
--- a/gfx/src/scene/animation.c
+++ b/src/scene/animation.c
@@ -1,7 +1,7 @@
 #include "animation_impl.h"
 
+#include "memory.h"
 #include "node_impl.h"
-#include "scene_memory.h"
 
 #include <string.h>
 
@@ -504,21 +504,21 @@ Box gfx_get_joint_box(
   return (Box){
       .vertices = {
                    mat4_mul_vec3(
-                   joint->joint_matrix, vec3_make(pmin.x, pmin.y, pmax.z), 1),
+              joint->joint_matrix, vec3_make(pmin.x, pmin.y, pmax.z), 1),
                    mat4_mul_vec3(
-                   joint->joint_matrix, vec3_make(pmax.x, pmin.y, pmax.z), 1),
+              joint->joint_matrix, vec3_make(pmax.x, pmin.y, pmax.z), 1),
                    mat4_mul_vec3(
-                   joint->joint_matrix, vec3_make(pmax.x, pmax.y, pmax.z), 1),
+              joint->joint_matrix, vec3_make(pmax.x, pmax.y, pmax.z), 1),
                    mat4_mul_vec3(
-                   joint->joint_matrix, vec3_make(pmin.x, pmax.y, pmax.z), 1),
+              joint->joint_matrix, vec3_make(pmin.x, pmax.y, pmax.z), 1),
                    mat4_mul_vec3(
-                   joint->joint_matrix, vec3_make(pmin.x, pmin.y, pmin.z), 1),
+              joint->joint_matrix, vec3_make(pmin.x, pmin.y, pmin.z), 1),
                    mat4_mul_vec3(
-                   joint->joint_matrix, vec3_make(pmax.x, pmin.y, pmin.z), 1),
+              joint->joint_matrix, vec3_make(pmax.x, pmin.y, pmin.z), 1),
                    mat4_mul_vec3(
-                   joint->joint_matrix, vec3_make(pmax.x, pmax.y, pmin.z), 1),
+              joint->joint_matrix, vec3_make(pmax.x, pmax.y, pmin.z), 1),
                    mat4_mul_vec3(
-                   joint->joint_matrix, vec3_make(pmin.x, pmax.y, pmin.z), 1),
+              joint->joint_matrix, vec3_make(pmin.x, pmax.y, pmin.z), 1),
                    }
   };
 }
diff --git a/gfx/src/scene/animation_impl.h b/src/scene/animation_impl.h
index 4408158..4408158 100644
--- a/gfx/src/scene/animation_impl.h
+++ b/src/scene/animation_impl.h
diff --git a/gfx/src/scene/camera.c b/src/scene/camera.c
index be7d806..bb073ba 100644
--- a/gfx/src/scene/camera.c
+++ b/src/scene/camera.c
@@ -1,7 +1,7 @@
 #include "camera_impl.h"
 
+#include "memory.h"
 #include "node_impl.h"
-#include "scene_memory.h"
 
 #include <assert.h>
 
diff --git a/gfx/src/scene/camera_impl.h b/src/scene/camera_impl.h
index 20c3890..20c3890 100644
--- a/gfx/src/scene/camera_impl.h
+++ b/src/scene/camera_impl.h
diff --git a/gfx/src/scene/model.c b/src/scene/model.c
index cc41a9a..e280a41 100644
--- a/gfx/src/scene/model.c
+++ b/src/scene/model.c
@@ -2,7 +2,7 @@
 
 #include <gfx/scene/node.h>
 
-#include "scene_memory.h"
+#include "memory.h"
 
 #include <assert.h>
 
diff --git a/gfx/src/scene/model_impl.h b/src/scene/model_impl.h
index a99d32c..39ac27f 100644
--- a/gfx/src/scene/model_impl.h
+++ b/src/scene/model_impl.h
@@ -2,7 +2,7 @@
 
 #include <gfx/scene/model.h>
 
-#include "scene_memory.h"
+#include "memory.h"
 
 /// Model.
 typedef struct Model {
diff --git a/gfx/src/scene/node.c b/src/scene/node.c
index 67ce93c..9d45aa7 100644
--- a/gfx/src/scene/node.c
+++ b/src/scene/node.c
@@ -2,11 +2,11 @@
 
 #include "animation_impl.h"
 #include "camera_impl.h"
-#include "light_impl.h"
+#include "llr/light_impl.h"
+#include "memory.h"
 #include "model_impl.h"
 #include "object_impl.h"
 #include "scene_graph.h"
-#include "scene_memory.h"
 
 #include "gfx_assert.h"
 
diff --git a/gfx/src/scene/node_impl.h b/src/scene/node_impl.h
index c79f252..c79f252 100644
--- a/gfx/src/scene/node_impl.h
+++ b/src/scene/node_impl.h
diff --git a/gfx/src/scene/object.c b/src/scene/object.c
index e8e3ee6..e985fd5 100644
--- a/gfx/src/scene/object.c
+++ b/src/scene/object.c
@@ -2,9 +2,9 @@
 
 #include <gfx/core.h>
 
-#include "mesh_impl.h"
+#include "llr/mesh_impl.h"
+#include "memory.h"
 #include "node_impl.h"
-#include "scene_memory.h"
 
 #include <assert.h>
 
diff --git a/gfx/src/scene/object_impl.h b/src/scene/object_impl.h
index 88f8e31..e864e53 100644
--- a/gfx/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.
@@ -21,6 +19,7 @@ typedef struct MeshLink {
 typedef struct SceneObject {
   mesh_link_idx mesh_link; /// First MeshLink in the list.
   skeleton_idx  skeleton;  /// 0 for static objects.
-  node_idx      parent;    /// Parent SceneNode.
-  aabb3         box;
+  // TODO: Can we just store node indices in nodes, not the contained object?
+  node_idx parent; /// Parent SceneNode.
+  aabb3    box;
 } SceneObject;
diff --git a/gfx/src/scene/scene.c b/src/scene/scene.c
index 54452dd..8c53810 100644
--- a/gfx/src/scene/scene.c
+++ b/src/scene/scene.c
@@ -1,7 +1,7 @@
 #include "scene_impl.h"
 
+#include "memory.h"
 #include "node_impl.h"
-#include "scene_memory.h"
 
 #include <assert.h>
 
diff --git a/gfx/src/scene/scene_graph.h b/src/scene/scene_graph.h
index a26f828..e7135a4 100644
--- a/gfx/src/scene/scene_graph.h
+++ b/src/scene/scene_graph.h
@@ -1,40 +1,46 @@
 /// Functions for list manipulation.
 #pragma once
 
-#include "scene_memory.h"
+#include "memory.h"
 
 // NOTE: SceneMemory guarantees that index 0 can be regarded as an invalid
 // index.
 
-#define MEM_GET(INDEX)                    \
-  _Generic((INDEX), camera_idx            \
-           : mem_get_camera, material_idx \
-           : mem_get_material, mesh_idx   \
-           : mem_get_mesh, mesh_link_idx  \
-           : mem_get_mesh_link, node_idx  \
-           : mem_get_node, object_idx     \
-           : mem_get_object, scene_idx    \
-           : mem_get_scene)(INDEX)
+#define MEM_GET(INDEX)                  \
+  _Generic(                             \
+      (INDEX),                          \
+      camera_idx: mem_get_camera,       \
+      material_idx: mem_get_material,   \
+      mesh_idx: mem_get_mesh,           \
+      mesh_link_idx: mem_get_mesh_link, \
+      node_idx: mem_get_node,           \
+      object_idx: mem_get_object,       \
+      scene_idx: mem_get_scene)(INDEX)
 
-#define MEM_GET_INDEX(ITEM)                       \
-  _Generic((ITEM), SceneCamera *                  \
-           : mem_get_camera_index, Material *     \
-           : mem_get_material_index, Mesh *       \
-           : mem_get_mesh_index, MeshLink *       \
-           : mem_get_mesh_link_index, SceneNode * \
-           : mem_get_node_index, SceneObject *    \
-           : mem_get_object_index, Scene *        \
-           : mem_get_scene_index)(ITEM)
+#define MEM_GET_INDEX(ITEM)                \
+  _Generic(                                \
+      (ITEM),                              \
+      SceneCamera *: mem_get_camera_index, \
+      Material *: mem_get_material_index,  \
+      Mesh *: mem_get_mesh_index,          \
+      MeshLink *: mem_get_mesh_link_index, \
+      SceneNode *: mem_get_node_index,     \
+      SceneObject *: mem_get_object_index, \
+      Scene *: mem_get_scene_index)(ITEM)
 
 /// Assert the list node invariant.
 ///
 /// - A node does not point to itself.
+#if NDEBUG
+#define ASSERT_LIST_NODE_INVARIANT(ITEM)
+#else
 #define ASSERT_LIST_NODE_INVARIANT(ITEM)              \
   {                                                   \
     const gfx_idx item_idx = MEM_GET_INDEX(ITEM).val; \
     assert((ITEM)->prev.val != item_idx);             \
     assert((ITEM)->next.val != item_idx);             \
   }
+#endif
 
 /// Assert the tree node invariant.
 ///
diff --git a/gfx/src/scene/scene_impl.h b/src/scene/scene_impl.h
index 992f620..992f620 100644
--- a/gfx/src/scene/scene_impl.h
+++ b/src/scene/scene_impl.h
diff --git a/gfx/src/scene/types.h b/src/scene/types.h
index d0ffc41..d0ffc41 100644
--- a/gfx/src/scene/types.h
+++ b/src/scene/types.h
diff --git a/gfx/src/util/geometry.c b/src/util/geometry.c
index afe0109..afe0109 100644
--- a/gfx/src/util/geometry.c
+++ b/src/util/geometry.c
diff --git a/gfx/src/util/ibl.c b/src/util/ibl.c
index 5a79990..5a79990 100644
--- a/gfx/src/util/ibl.c
+++ b/src/util/ibl.c
diff --git a/gfx/src/util/shader.c b/src/util/shader.c
index f5c22cc..f5c22cc 100644
--- a/gfx/src/util/shader.c
+++ b/src/util/shader.c
diff --git a/gfx/src/util/skyquad.c b/src/util/skyquad.c
index 08fa044..094de67 100644
--- a/gfx/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) {