167 files changed, 2552 insertions, 5256 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 25c7560..7d3767d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,8 +1,97 @@
-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)
+project(gfx)
-add_subdirectory(game)
+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/animation.c
+  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/memory.c
+  src/render/imm.c
+  src/render/llr.c
+  src/render/renderer.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/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
+  hash
+  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..3a30ee4 100644
--- a/gfx/README.md
+++ b/README.md
@@ -20,32 +20,45 @@ 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
+library's high-level API. The `Gfx` object exposes a render backend (`GfxCore`)
-`Renderer` and allows the caller to create `Scene`s.
+and a `Renderer`, and allows the caller to create `Scene`s.
-### Render Backend
+### Render Backend ("Core")
-The `Render` backend is a thin abstraction layer over low-level graphics APIs
+The render backend (`GfxCore`) is a thin abstraction layer over low-level
-like OpenGL or Vulkan. It holds GPU resources such as geometry, textures,
+graphics APIs like OpenGL or Vulkan. It holds GPU resources such as geometry,
-shaders, etc, and exposes functions to manipulate them.
+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,
+The render backend owns all rendering resources: buffers, geometries, textures,
-textures, shaders, etc. Even resources that point to other resources do not own
+shaders, etc. Even resources that point to other resources do not own those
-those other resources (geometries pointing to buffers).
+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
+The low-level renderer (`LLR`) provides a low-level, immediate-mode interface
+on top of the render backend. It understands higher-level concepts to make
+rendering more convenient (object, mesh, material, light, camera, etc), but is
+still relatively low-level and does not understand any particular scene data
+structure.
+### Immediate-mode Renderer
+The immediate-mode renderer (`Imm`) provides an API to define and render
+geometry procedurally and on the spot. It should be reserved for debug or
+not-performance-intensive rendering.
 ### Scene
-A `Scene` encapsulates a scene graph. A scene graph contains the elements that
+A `Scene` graph contains the elements that make up a scene. The current scene
-make up a scene: nodes, cameras, lights, objects, etc. The current scene graph
+graph implementation includes:
-implementation includes:
 - Camera
 - Light
@@ -64,7 +77,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 +90,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 +101,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 +145,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/CMakeLists.txt b/app/CMakeLists.txt
index 7703ccb..588ee87 100644
--- a/app/CMakeLists.txt
+++ b/app/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 add_subdirectory(contrib/glad)
diff --git a/app/demo/CMakeLists.txt b/app/demo/CMakeLists.txt
index bbb3aae..58d77cc 100644
--- a/app/demo/CMakeLists.txt
+++ b/app/demo/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 project(gfxappdemo)
diff --git a/app/include/gfx/app.h b/app/include/gfx/app.h
index 77b6ad2..3017707 100644
--- a/app/include/gfx/app.h
+++ b/app/include/gfx/app.h
@@ -1,7 +1,6 @@
 #pragma once
-#include <stdbool.h>
+typedef struct GfxApp      GfxApp;
 typedef struct GfxAppState GfxAppState;
 /// Application settings.
@@ -16,11 +15,11 @@ typedef struct GfxAppDesc {
  GfxAppState* app_state;
 } GfxAppDesc;
-typedef bool (*GfxAppInit)(GfxAppState*, int argc, const char** argv);
+typedef bool (*GfxAppInit)(GfxApp*, GfxAppState*, int argc, const char** argv);
-typedef void (*GfxAppShutdown)(GfxAppState*);
+typedef void (*GfxAppShutdown)(GfxApp*, GfxAppState*);
-typedef void (*GfxAppUpdate)(GfxAppState*, double t, double dt);
+typedef void (*GfxAppUpdate)(GfxApp*, GfxAppState*, double t, double dt);
-typedef void (*GfxAppRender)(GfxAppState*);
+typedef void (*GfxAppRender)(const GfxApp*, GfxAppState*);
-typedef void (*GfxAppResize)(GfxAppState*, int width, int height);
+typedef void (*GfxAppResize)(GfxApp*, GfxAppState*, int width, int height);
 /// Application callback functions.
 typedef struct GfxAppCallbacks {
@@ -64,6 +63,7 @@ typedef enum Key {
  KeyX,
  KeyY,
  KeyZ,
+  KeyLShift,
 } Key;
 #ifdef __cplusplus
@@ -74,13 +74,13 @@ extern "C" {
 bool gfx_app_run(const GfxAppDesc*, const GfxAppCallbacks*);
 /// Get the mouse coordinates relative to the app's window.
-void gfx_app_get_mouse_position(double* x, double* y);
+void gfx_app_get_mouse_position(GfxApp*, double* x, double* y);
 /// Return if the given mouse button is pressed.
-bool gfx_app_is_mouse_button_pressed(MouseButton);
+bool gfx_app_is_mouse_button_pressed(GfxApp*, MouseButton);
 /// Return true if the given key is pressed.
-bool gfx_app_is_key_pressed(Key);
+bool gfx_app_is_key_pressed(GfxApp*, Key);
 #ifdef __cplusplus
 } // extern "C"
@@ -102,11 +102,10 @@ bool gfx_app_is_key_pressed(Key);
            .title             = TITLE,                                     \
            .app_state         = &app_state,                                \
        },                                                                  \
-        &(GfxAppCallbacks){                                                 \
+        &(GfxAppCallbacks){.init     = Init,                                \
-            .init     = (GfxAppInit)Init,                                   \
+                           .shutdown = Shutdown,                            \
-            .shutdown = (GfxAppShutdown)Shutdown,                           \
+                           .update   = Update,                              \
-            .update   = (GfxAppUpdate)Update,                               \
+                           .render   = Render,                              \
-            .render   = (GfxAppRender)Render,                               \
+                           .resize   = Resize});                              \
-            .resize   = (GfxAppResize)Resize});                               \
    return 0;                                                               \
  }
diff --git a/app/src/app.c b/app/src/app.c
index 9b816ee..6eaa3d6 100644
--- a/app/src/app.c
+++ b/app/src/app.c
@@ -24,7 +24,7 @@ static GfxApp g_gfx_app;
 /// Called by GLFW when the window is resized.
 static void on_resize(GLFWwindow* window, int width, int height) {
-  (*g_gfx_app.callbacks.resize)(g_gfx_app.app_state, width, height);
+  (*g_gfx_app.callbacks.resize)(&g_gfx_app, g_gfx_app.app_state, width, height);
 }
 /// Run the application's main loop.
@@ -41,12 +41,13 @@ static void loop(GfxApp* app) {
  // Warm up the update to initialize the application's state.
  (*app->callbacks.update)(
-      app->app_state, time_delta_to_sec(time), time_delta_to_sec(update_dt));
+      app, app->app_state, time_delta_to_sec(time),
+      time_delta_to_sec(update_dt));
  // Warm up the rendering before entering the main loop. A renderer can
  // compile shaders and do other initialization the first time it renders a
  // scene.
-  (*app->callbacks.render)(app->app_state);
+  (*app->callbacks.render)(app, app->app_state);
  glfwSwapBuffers(app->window);
  timer_start(&timer);
@@ -56,14 +57,14 @@ static void loop(GfxApp* app) {
    while (time_budget >= update_dt) {
      (*app->callbacks.update)(
-          app->app_state, time_delta_to_sec(time),
+          app, app->app_state, time_delta_to_sec(time),
          time_delta_to_sec(update_dt));
      time += update_dt;
      time_budget -= update_dt;
    }
-    (*app->callbacks.render)(app->app_state);
+    (*app->callbacks.render)(app, app->app_state);
    glfwSwapBuffers(app->window);
    glfwPollEvents();
@@ -85,7 +86,7 @@ bool gfx_app_run(const GfxAppDesc* desc, const GfxAppCallbacks* callbacks) {
  g_gfx_app.callbacks         = *callbacks;
  g_gfx_app.max_fps           = desc->max_fps;
  g_gfx_app.update_delta_time = desc->update_delta_time;
-  g_gfx_app.window            = 0;
+  g_gfx_app.window            = nullptr;
  if (!glfwInit()) {
    LOGE("glfwInit() failed");
@@ -112,28 +113,33 @@ bool gfx_app_run(const GfxAppDesc* desc, const GfxAppCallbacks* callbacks) {
  }
  glfwMakeContextCurrent(g_gfx_app.window);
-  // Load GL before calling the application init clalback.
+  // Request adaptive sync if supported.
-  if (!gladLoadGL()) {
+  glfwSwapInterval(-1);
-    LOGE("Failed loading glad!");
-    return 0;
+  // 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.
  if (!(*g_gfx_app.callbacks.init)(
-          g_gfx_app.app_state, desc->argc, desc->argv)) {
+          &g_gfx_app, g_gfx_app.app_state, desc->argc, desc->argv)) {
    LOGE("Failed to initialize application");
    goto cleanup;
  }
  // Trigger an initial resize for convenience.
-  (*g_gfx_app.callbacks.resize)(g_gfx_app.app_state, desc->width, desc->height);
+  (*g_gfx_app.callbacks.resize)(
+      &g_gfx_app, g_gfx_app.app_state, desc->width, desc->height);
  // Set GLFW callbacks now that the application has been initialized.
  glfwSetWindowSizeCallback(g_gfx_app.window, on_resize);
  loop(&g_gfx_app);
-  (*g_gfx_app.callbacks.shutdown)(g_gfx_app.app_state);
+  (*g_gfx_app.callbacks.shutdown)(&g_gfx_app, g_gfx_app.app_state);
  success = true;
@@ -145,21 +151,21 @@ cleanup:
  return success;
 }
-void gfx_app_get_mouse_position(double* x, double* y) {
+void gfx_app_get_mouse_position(GfxApp* app, double* x, double* y) {
-  glfwGetCursorPos(g_gfx_app.window, x, y);
+  glfwGetCursorPos(app->window, x, y);
 }
 static int to_glfw_mouse_button(MouseButton button);
-bool gfx_app_is_mouse_button_pressed(MouseButton button) {
+bool gfx_app_is_mouse_button_pressed(GfxApp* app, MouseButton button) {
-  return glfwGetMouseButton(g_gfx_app.window, to_glfw_mouse_button(button)) ==
+  return glfwGetMouseButton(app->window, to_glfw_mouse_button(button)) ==
         GLFW_PRESS;
 }
 static int to_glfw_key(Key key);
-bool gfx_app_is_key_pressed(Key key) {
+bool gfx_app_is_key_pressed(GfxApp* app, Key key) {
-  return glfwGetKey(g_gfx_app.window, to_glfw_key(key)) == GLFW_PRESS;
+  return glfwGetKey(app->window, to_glfw_key(key)) == GLFW_PRESS;
 }
 static int to_glfw_mouse_button(MouseButton button) {
@@ -227,5 +233,7 @@ static int to_glfw_key(Key key) {
    return GLFW_KEY_Y;
  case KeyZ:
    return GLFW_KEY_Z;
+  case KeyLShift:
+    return GLFW_KEY_LEFT_SHIFT;
  }
 }
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..3f86fc2 100644
--- a/gfx/contrib/cgltf-tangents/CMakeLists.txt
+++ b/contrib/cgltf-tangents/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.5)
 project(cgltf-tangents)
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
Binary files differ
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
Binary files differ
diff --git a/gfx/doc/gfx.png b/doc/gfx.png
index e64f6e1..e64f6e1 100644
--- a/gfx/doc/gfx.png
+++ b/doc/gfx.png
Binary files differ
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
Binary files differ
diff --git a/gfx/doc/pipeline.png b/doc/pipeline.png
index 426f39e..426f39e 100644
--- a/gfx/doc/pipeline.png
+++ b/doc/pipeline.png
Binary files differ
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
Binary files differ
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
Binary files differ
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/include/gfx/scene.h b/gfx/include/gfx/scene.h
deleted file mode 100644
index abcaa70..0000000
--- a/gfx/include/gfx/scene.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#pragma once
-#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>
-#include <gfx/scene/scene.h>
diff --git a/gfx/include/gfx/scene/camera.h b/gfx/include/gfx/scene/camera.h
deleted file mode 100644
index 99d83fe..0000000
--- a/gfx/include/gfx/scene/camera.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-#include <math/fwd.h>
-typedef struct SceneNode SceneNode;
-typedef struct SceneCamera SceneCamera;
-/// Create a new camera.
-SceneCamera* gfx_make_camera();
-/// Destroy the camera.
-///
-/// The camera is conveniently removed from the scene graph and its parent scene
-/// node is destroyed.
-void gfx_destroy_camera(SceneCamera**);
-/// Set the scene camera's math camera.
-void gfx_set_camera_camera(SceneCamera* scene_camera, Camera* camera);
-/// Get the scene camera's math camera.
-Camera* gfx_get_camera_camera(SceneCamera*);
diff --git a/gfx/include/gfx/scene/light.h b/gfx/include/gfx/scene/light.h
deleted file mode 100644
index 132e344..0000000
--- a/gfx/include/gfx/scene/light.h
+++ /dev/null
@@ -1,30 +0,0 @@
-#pragma once
-typedef struct Texture Texture;
-typedef struct Light Light;
-/// Light type.
-typedef enum LightType { EnvironmentLightType } LightType;
-/// Describes an environment light.
-typedef struct EnvironmentLightDesc {
-  const Texture* environment_map;
-} EnvironmentLightDesc;
-/// Describes a light.
-typedef struct LightDesc {
-  LightType type;
-  union {
-    EnvironmentLightDesc environment;
-  } light;
-} LightDesc;
-/// Create a light.
-Light* gfx_make_light(const LightDesc*);
-/// Destroy the light.
-///
-/// The light is conveniently removed from the scene graph and its parent scene
-/// node is destroyed.
-void gfx_destroy_light(Light**);
diff --git a/gfx/include/gfx/scene/material.h b/gfx/include/gfx/scene/material.h
deleted file mode 100644
index bca664e..0000000
--- a/gfx/include/gfx/scene/material.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-#include <gfx/core.h>
-#include <gfx/sizes.h>
-typedef struct Material Material;
-/// Describes a material.
-///
-/// A material holds a shader program and a set of shader-specific uniform
-/// variables. Two materials can share the same shader, but shader parameters
-/// generally give two materials a different appearance.
-typedef struct MaterialDesc {
-  ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
-  int           num_uniforms;
-} MaterialDesc;
-/// Create a material.
-Material* gfx_make_material(const MaterialDesc*);
-/// Destroy the material.
-///
-/// The caller must make sure that no Mesh points to the given Material.
-/// For a safe purge of unused resources, see scene_purge().
-void gfx_destroy_material(Material**);
diff --git a/gfx/include/gfx/scene/mesh.h b/gfx/include/gfx/scene/mesh.h
deleted file mode 100644
index 0d3b4d4..0000000
--- a/gfx/include/gfx/scene/mesh.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-typedef struct Geometry      Geometry;
-typedef struct Material      Material;
-typedef struct ShaderProgram ShaderProgram;
-typedef struct Mesh Mesh;
-/// Describes a mesh.
-typedef struct MeshDesc {
-  const Geometry* geometry;
-  const Material* material;
-  ShaderProgram*  shader;
-} MeshDesc;
-/// Create a mesh.
-Mesh* gfx_make_mesh(const MeshDesc*);
-/// Destroy the mesh.
-///
-/// The caller must make sure that no SceneObject points to the given Mesh.
-/// For a safe purge of unused resources, see scene_purge().
-void gfx_destroy_mesh(Mesh**);
diff --git a/gfx/include/gfx/scene/model.h b/gfx/include/gfx/scene/model.h
deleted file mode 100644
index 42f85d4..0000000
--- a/gfx/include/gfx/scene/model.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-typedef struct Anima     Anima;
-typedef struct Model     Model;
-typedef struct SceneNode SceneNode;
-/// Return the model's anima, or null if the model is not animated.
-Anima* gfx_get_model_anima(Model*);
-/// Return the model's root node.
-const SceneNode* gfx_get_model_root(const Model*);
-SceneNode*       gfx_get_model_root_mut(Model*);
diff --git a/gfx/include/gfx/scene/node.h b/gfx/include/gfx/scene/node.h
deleted file mode 100644
index a2c2836..0000000
--- a/gfx/include/gfx/scene/node.h
+++ /dev/null
@@ -1,156 +0,0 @@
-#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;
-typedef struct SceneCamera SceneCamera;
-typedef struct SceneObject SceneObject;
-/// Scene node type.
-typedef enum NodeType {
-  LogicalNode,
-  AnimaNode,
-  CameraNode,
-  LightNode,
-  ModelNode,
-  ObjectNode,
-} NodeType;
-/// A node in the scene graph.
-///
-/// Scene nodes take ownership of the object they are associated with (Camera,
-/// Light, SceneObject, etc), as well as of child nodes.
-typedef struct SceneNode SceneNode;
-// -----------------------------------------------------------------------------
-// Constructors and destructor.
-// -----------------------------------------------------------------------------
-/// Create a new scene node.
-///
-/// This node does not contain any camera, light, object, etc. and exists simply
-/// as a logical and spatial construct.
-SceneNode* gfx_make_node();
-/// Create an anima node.
-SceneNode* gfx_make_anima_node(Anima*);
-/// Create a new camera node.
-SceneNode* gfx_make_camera_node(SceneCamera*);
-/// Create a new light node.
-SceneNode* gfx_make_light_node(Light*);
-/// Create a new model node.
-SceneNode* gfx_make_model_node(Model*);
-/// Create a new object node.
-SceneNode* gfx_make_object_node(SceneObject*);
-/// Make the node an anima node.
-void gfx_construct_anima_node(SceneNode*, Anima*);
-/// Make the node a camera node.
-void gfx_construct_camera_node(SceneNode*, SceneCamera*);
-/// Make the node a light node.
-void gfx_construct_light_node(SceneNode*, Light*);
-/// Make the node a model node.
-void gfx_construct_model_node(SceneNode*, Model*);
-/// Make the node an object node.
-void gfx_construct_object_node(SceneNode*, SceneObject*);
-/// Recursively destroy the scene node and its children.
-///
-/// The scene node and its children are removed from the scene graph.
-///
-/// Node resources -- cameras, lights, objects, etc. -- are also destroyed.
-void gfx_destroy_node(SceneNode**);
-// -----------------------------------------------------------------------------
-// Getters.
-// -----------------------------------------------------------------------------
-/// Get the node's type.
-NodeType gfx_get_node_type(const SceneNode*);
-/// Get the node's anima.
-///
-/// The node must be of type AnimaNode.
-const Anima* gfx_get_node_anima(const SceneNode*);
-Anima*       gfx_get_node_anima_mut(SceneNode*);
-/// Get the node's camera.
-///
-/// The node must be of type CameraNode.
-const SceneCamera* gfx_get_node_camera(const SceneNode* node);
-SceneCamera*       gfx_get_node_camera_mut(SceneNode* node);
-/// Get the node's light.
-///
-/// The node must be of type LightNode.
-const Light* gfx_get_node_light(const SceneNode*);
-Light*       gfx_get_node_light_mut(SceneNode*);
-/// Get the node's model.
-///
-/// The node must be of type ModelNode.
-const Model* gfx_get_node_model(const SceneNode*);
-Model*       gfx_get_node_model_mut(SceneNode*);
-/// Get the node's scene object.
-///
-/// The node must be of type ObjectNode.
-const SceneObject* gfx_get_node_object(const SceneNode*);
-SceneObject*       gfx_get_node_object_mut(SceneNode*);
-/// Get the node's parent.
-const SceneNode* gfx_get_node_parent(const SceneNode*);
-SceneNode*       gfx_get_node_parent_mut(SceneNode*);
-/// Get the node's first child.
-const SceneNode* gfx_get_node_child(const SceneNode*);
-SceneNode*       gfx_get_node_child_mut(SceneNode*);
-/// Get the node's immediate sibling.
-const SceneNode* gfx_get_node_sibling(const SceneNode*);
-SceneNode*       gfx_get_node_sibling_mut(SceneNode*);
-/// Get the node's (local) transform.
-mat4 gfx_get_node_transform(const SceneNode*);
-/// Get the node's global transform.
-mat4 gfx_get_node_global_transform(const SceneNode*);
-// -----------------------------------------------------------------------------
-// Setters.
-// -----------------------------------------------------------------------------
-/// Set the node's parent.
-///
-/// Pass in null to unwire from the existing parent, if one exists.
-void gfx_set_node_parent(SceneNode*, SceneNode* parent_node);
-/// Set the node's (local) transform.
-void gfx_set_node_transform(SceneNode*, const mat4* transform);
-/// Set the node's position.
-void gfx_set_node_position(SceneNode*, const vec3* position);
-/// Set the node's rotation.
-void gfx_set_node_rotation(SceneNode*, const quat* rotation);
-/// Set the node's rotation.
-void gfx_set_node_rotation_mat(SceneNode*, const mat4* rotation);
-/// Log the node's hierarchy.
-void gfx_log_node_hierarchy(const SceneNode*);
diff --git a/gfx/include/gfx/scene/object.h b/gfx/include/gfx/scene/object.h
deleted file mode 100644
index 7579d29..0000000
--- a/gfx/include/gfx/scene/object.h
+++ /dev/null
@@ -1,39 +0,0 @@
-#pragma once
-#include <gfx/sizes.h>
-#include <math/fwd.h>
-#include <math/aabb3.h>
-typedef struct Mesh      Mesh;
-typedef struct SceneNode SceneNode;
-typedef struct Skeleton  Skeleton;
-typedef struct SceneObject SceneObject;
-typedef struct ObjectDesc {
-  size_t num_meshes;
-  Mesh*  meshes[GFX_MAX_NUM_MESHES];
-} ObjectDesc;
-/// Create a new object.
-SceneObject* gfx_make_object(const ObjectDesc*);
-/// Destroy the object.
-///
-/// The object is conveniently removed from the scene graph and its parent scene
-/// node is destroyed.
-void gfx_destroy_object(SceneObject**);
-/// Set the object's skeleton.
-void gfx_set_object_skeleton(SceneObject*, const Skeleton*);
-/// Get the object's skeleton.
-/// Return null if the object has no skeleton.
-const Skeleton* gfx_get_object_skeleton(const SceneObject*);
-/// Gets the object's bounding box.
-///
-/// The object's bounding box is the bounding box of its mesh geometries.
-aabb3 gfx_get_object_aabb(const SceneObject*);
diff --git a/gfx/include/gfx/scene/scene.h b/gfx/include/gfx/scene/scene.h
deleted file mode 100644
index 0d96210..0000000
--- a/gfx/include/gfx/scene/scene.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-#include <math/defs.h>
-#include <math/fwd.h>
-typedef struct SceneNode SceneNode;
-typedef struct Scene Scene;
-/// Create a new scene.
-Scene* gfx_make_scene(void);
-/// Destroy the scene.
-///
-/// This function destroys the scene and all objects that it owns (scene
-/// objects, cameras, lights, etc), but not objects that could be shared with
-/// other scenes (meshes, materials, etc).
-void gfx_destroy_scene(Scene**);
-/// Get the scene's root node.
-SceneNode* gfx_get_scene_root(Scene*);
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/camera.c b/gfx/src/scene/camera.c
deleted file mode 100644
index be7d806..0000000
--- a/gfx/src/scene/camera.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "camera_impl.h"
-#include "node_impl.h"
-#include "scene_memory.h"
-#include <assert.h>
-SceneCamera* gfx_make_camera() {
-  SceneCamera* camera = mem_alloc_camera();
-  camera->camera = camera_perspective(
-      /*fovy=*/90.0 * TO_RAD, /*aspect=*/16.0 / 9.0,
-      /*near=*/0.1, /*far=*/1000);
-  return camera;
-}
-void gfx_destroy_camera(SceneCamera** camera) {
-  assert(camera);
-  if (*camera) {
-    if ((*camera)->parent.val) {
-      gfx_del_node((*camera)->parent);
-    }
-    mem_free_camera(camera);
-  }
-}
-void gfx_set_camera_camera(SceneCamera* scene_camera, Camera* camera) {
-  assert(scene_camera);
-  assert(camera);
-  scene_camera->camera = *camera;
-}
-Camera* gfx_get_camera_camera(SceneCamera* camera) {
-  assert(camera);
-  return &camera->camera;
-}
diff --git a/gfx/src/scene/camera_impl.h b/gfx/src/scene/camera_impl.h
deleted file mode 100644
index 20c3890..0000000
--- a/gfx/src/scene/camera_impl.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-#include <gfx/scene/camera.h>
-#include "types.h"
-#include <math/camera.h>
-typedef struct SceneCamera {
-  Camera camera;
-  node_idx parent; // Parent SceneNode.
-} SceneCamera;
diff --git a/gfx/src/scene/material.c b/gfx/src/scene/material.c
deleted file mode 100644
index 3248243..0000000
--- a/gfx/src/scene/material.c
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "material_impl.h"
-#include "scene_memory.h"
-#include <gfx/core.h>
-static void material_make(Material* material, const MaterialDesc* desc) {
-  assert(material);
-  assert(desc);
-  assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  material->num_uniforms = desc->num_uniforms;
-  for (int i = 0; i < desc->num_uniforms; ++i) {
-    material->uniforms[i] = desc->uniforms[i];
-  }
-}
-Material* gfx_make_material(const MaterialDesc* desc) {
-  assert(desc);
-  Material* material = mem_alloc_material();
-  material_make(material, desc);
-  return material;
-}
-void gfx_destroy_material(Material** material) { mem_free_material(material); }
-static void set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) {
-  switch (uniform->type) {
-  case UniformTexture:
-    gfx_set_texture_uniform(prog, uniform->name.str, uniform->value.texture);
-    break;
-  case UniformMat4:
-    gfx_set_mat4_uniform(prog, uniform->name.str, &uniform->value.mat4);
-    break;
-  case UniformVec3:
-    gfx_set_vec3_uniform(prog, uniform->name.str, uniform->value.vec3);
-    break;
-  case UniformVec4:
-    gfx_set_vec4_uniform(prog, uniform->name.str, uniform->value.vec4);
-    break;
-  case UniformFloat:
-    gfx_set_float_uniform(prog, uniform->name.str, uniform->value.scalar);
-    break;
-  case UniformMat4Array:
-    gfx_set_mat4_array_uniform(
-        prog, uniform->name.str, uniform->value.array.values,
-        uniform->value.array.count);
-    break;
-  }
-}
-void material_activate(ShaderProgram* shader, const Material* material) {
-  assert(material);
-  for (int i = 0; i < material->num_uniforms; ++i) {
-    const ShaderUniform* uniform = &material->uniforms[i];
-    set_uniform(shader, uniform);
-  }
-}
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/src/scene/scene.c b/gfx/src/scene/scene.c
deleted file mode 100644
index 54452dd..0000000
--- a/gfx/src/scene/scene.c
+++ /dev/null
@@ -1,25 +0,0 @@
-#include "scene_impl.h"
-#include "node_impl.h"
-#include "scene_memory.h"
-#include <assert.h>
-Scene* gfx_make_scene(void) {
-  Scene* scene = mem_alloc_scene();
-  scene->root  = gfx_make_node();
-  return scene;
-}
-void gfx_destroy_scene(Scene** scene) {
-  assert(scene);
-  if (*scene) {
-    gfx_destroy_node(&(*scene)->root);
-    mem_free_scene(scene);
-  }
-}
-SceneNode* gfx_get_scene_root(Scene* scene) {
-  assert(scene);
-  return scene->root;
-}
diff --git a/gfx/src/scene/scene_impl.h b/gfx/src/scene/scene_impl.h
deleted file mode 100644
index 992f620..0000000
--- a/gfx/src/scene/scene_impl.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-#include <gfx/scene/scene.h>
-#include "types.h"
-typedef struct SceneNode SceneNode;
-typedef struct Scene {
-  SceneNode* root;
-  scene_idx  next;
-  scene_idx  prev;
-} Scene;
diff --git a/gfx/include/gfx/scene/animation.h b/include/gfx/animation.h
index d95b895..b55e575 100644
--- a/gfx/include/gfx/scene/animation.h
+++ b/include/gfx/animation.h
@@ -1,7 +1,5 @@
 #pragma once
-#include "node.h"
-#include "object.h"
 #include <gfx/sizes.h>
 #include <cstring.h>
@@ -15,8 +13,7 @@
 #include <stddef.h>
 #include <stdint.h>
-typedef struct Buffer    Buffer;
+typedef struct Buffer Buffer;
-typedef struct SceneNode SceneNode;
 typedef struct Anima    Anima;
 typedef struct Joint    Joint;
diff --git a/gfx/include/gfx/asset.h b/include/gfx/asset.h
index caf40c1..3018cfd 100644
--- a/gfx/include/gfx/asset.h
+++ b/include/gfx/asset.h
@@ -18,8 +18,8 @@ typedef enum AssetOrigin {
 /// Describes a texture's colour space.
 typedef enum TextureColourSpace {
-  sRGB, // The most likely default.
+  LinearColourSpace, // The most likely default.
-  LinearColourSpace,
+  sRGB,
 } TextureColourSpace;
 /// Describes a command to load a texture.
diff --git a/gfx/include/gfx/core.h b/include/gfx/core.h
index 44509c9..8f01081 100644
--- a/gfx/include/gfx/core.h
+++ b/include/gfx/core.h
@@ -4,7 +4,7 @@
 /// rendering operations.
 #pragma once
-#include "sizes.h"
+#include <gfx/sizes.h>
 #include <math/aabb3.h>
 #include <math/fwd.h>
@@ -93,6 +93,7 @@ typedef struct BufferDesc {
    size_t      offset_bytes;        \
    size_t      size_bytes;          \
    size_t      stride_bytes;        \
+    size_t      count;               \
  } NAME;
 /// A buffer view for untyped data.
@@ -183,11 +184,12 @@ typedef struct ShaderProgramDesc {
 /// Shader uniform type.
 typedef enum {
+  UniformInt,
  UniformFloat,
  UniformMat4,
-  UniformTexture,
  UniformVec3,
  UniformVec4,
+  UniformTexture,
  UniformMat4Array
 } UniformType;
@@ -200,10 +202,11 @@ typedef struct ShaderUniform {
  UniformType type;
  union {
    const Texture* texture;
-    mat4           mat4;
+    int            uniform_int;
-    vec3           vec3;
+    float          uniform_float;
-    vec4           vec4;
+    mat4           uniform_mat4;
-    float          scalar;
+    vec3           uniform_vec3;
+    vec4           uniform_vec4;
    struct {
      size_t count;
      union {
@@ -219,6 +222,7 @@ typedef enum { Texture2D, TextureCubeMap } TextureDimension;
 /// Texture data format.
 typedef enum {
  TextureDepth,
+  TextureR8,
  TextureRG16,
  TextureRG16F,
  TextureRGB8,
@@ -473,11 +477,21 @@ 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.
+/// Set the uniform.
+void gfx_set_uniform(ShaderProgram* prog, const ShaderUniform* uniform);
+/// Set the int uniform.
 /// Has no effect if the shader does not contain the given uniform.
-void gfx_set_texture_uniform(ShaderProgram*, const char* name, const Texture*);
+void gfx_set_int_uniform(ShaderProgram*, const char* name, int value);
+/// Set the float uniform.
+/// Has no effect if the shader does not contain the given uniform.
+void gfx_set_float_uniform(ShaderProgram*, const char* name, float value);
 /// Set the matrix uniform.
 /// Has no effect if the shader does not contain the given uniform.
@@ -491,9 +505,9 @@ void gfx_set_vec3_uniform(ShaderProgram*, const char* name, vec3);
 /// Has no effect if the shader does not contain the given uniform.
 void gfx_set_vec4_uniform(ShaderProgram*, const char* name, vec4);
-/// Set the float uniform.
+/// Set the texture uniform.
 /// Has no effect if the shader does not contain the given uniform.
-void gfx_set_float_uniform(ShaderProgram*, const char* name, float value);
+void gfx_set_texture_uniform(ShaderProgram*, const char* name, const Texture*);
 /// Set the matrix array uniform.
 /// Has no effect if the shader does not contain the given uniform.
diff --git a/gfx/include/gfx/gfx.h b/include/gfx/gfx.h
index 7c670a5..eb7a3cd 100644
--- a/gfx/include/gfx/gfx.h
+++ b/include/gfx/gfx.h
@@ -2,7 +2,8 @@
 typedef struct AssetCache  AssetCache;
 typedef struct GfxCore     GfxCore;
-typedef struct ImmRenderer ImmRenderer;
+typedef struct Imm Imm;
+typedef struct LLR         LLR;
 typedef struct Renderer    Renderer;
 typedef struct Gfx Gfx;
@@ -16,11 +17,14 @@ 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*);
+Imm* gfx_get_imm(Gfx*);
+/// Get the low-level renderer.
+LLR* gfx_get_llr(Gfx*);
 /// Get the asset cache.
 AssetCache* gfx_get_asset_cache(Gfx*);
diff --git a/include/gfx/render/imm.h b/include/gfx/render/imm.h
new file mode 100644
index 0000000..62c071e
--- /dev/null
+++ b/include/gfx/render/imm.h
@@ -0,0 +1,52 @@
+#pragma once
+#include <math/aabb2.h>
+#include <math/aabb3.h>
+#include <math/vec3.h>
+typedef struct Imm Imm;
+/// Prepare the graphics systems for immediate-mode rendering.
+///
+/// Call this before issuing any immediate-mode rendering draws.
+void gfx_imm_start(Imm*);
+/// End immediate mode rendering.
+///
+/// Call this after issuing immediate-mode rendering draws and before swapping
+/// buffers.
+void gfx_imm_end(Imm*);
+/// 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(Imm*);
+/// Draw a set of triangles.
+void gfx_imm_draw_triangles(Imm*, const vec3[], size_t num_triangles);
+/// Draw a triangle.
+void gfx_imm_draw_triangle(Imm*, const vec3[3]);
+/// Draw a bounding box.
+void gfx_imm_draw_aabb2(Imm*, aabb2);
+/// Draw a bounding box.
+void gfx_imm_draw_aabb3(Imm*, 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(Imm* renderer, const vec3 vertices[8]);
+/// Set the render colour.
+void gfx_imm_set_colour(Imm*, vec4 colour);
diff --git a/include/gfx/render/llr.h b/include/gfx/render/llr.h
new file mode 100644
index 0000000..6f635b6
--- /dev/null
+++ b/include/gfx/render/llr.h
@@ -0,0 +1,81 @@
+#pragma once
+#include <math/fwd.h>
+#include <math/vec3.h>
+typedef struct Anima         Anima;
+typedef struct Camera        Camera;
+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 Texture       Texture;
+typedef struct LLR LLR;
+// -----------------------------------------------------------------------------
+// Low-level rendering.
+// -----------------------------------------------------------------------------
+/// 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 projection matrix.
+void gfx_llr_set_projection_matrix(LLR* renderer, const mat4* projection);
+/// 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/include/gfx/render/renderer.h b/include/gfx/render/renderer.h
new file mode 100644
index 0000000..9f3231b
--- /dev/null
+++ b/include/gfx/render/renderer.h
@@ -0,0 +1,36 @@
+#pragma once
+#include <math/defs.h>
+#include <math/fwd.h>
+typedef struct GfxCore GfxCore;
+typedef struct Scene   Scene;
+typedef struct Renderer Renderer;
+// TODO: Add RenderDepth.
+typedef enum RenderSceneMode {
+  RenderDefault,
+  RenderDebug,
+  RenderNormals,
+  RenderNormalMappedNormals,
+  RenderTangents
+} RenderSceneMode;
+typedef enum RenderSceneFilter {
+  RenderOpaqueAndAlphaMasked,
+  RenderTransparent
+} RenderSceneFilter;
+typedef struct RenderSceneParams {
+  RenderSceneMode   mode;
+  RenderSceneFilter filter;
+  const Scene*      scene;
+  const Camera*     camera;
+} RenderSceneParams;
+/// Render the scene.
+void gfx_render_scene(Renderer*, const RenderSceneParams*);
+/// Update the scene.
+void gfx_update(Scene*, const Camera*, R t);
diff --git a/include/gfx/scene.h b/include/gfx/scene.h
new file mode 100644
index 0000000..3aa6e0e
--- /dev/null
+++ b/include/gfx/scene.h
@@ -0,0 +1,296 @@
+#pragma once
+#include <gfx/core.h>
+#include <gfx/sizes.h>
+#include <math/aabb3.h>
+#include <math/fwd.h>
+#include <math/mat4.h>
+typedef struct Anima    Anima;
+typedef struct Camera   Camera;
+typedef struct Light    Light;
+typedef struct Material Material;
+typedef struct Mesh     Mesh;
+typedef struct Model    Model;
+typedef struct Scene    Scene;
+/// A node in the scene graph.
+///
+/// Scene nodes take ownership of the object they are associated with (Camera,
+/// Light, SceneObject, etc), as well as of child nodes.
+typedef struct SceneNode   SceneNode;
+typedef struct SceneObject SceneObject;
+typedef struct Skeleton    Skeleton;
+typedef struct Texture     Texture;
+/// Light type.
+typedef enum LightType { EnvironmentLightType } LightType;
+/// Describes an environment light.
+typedef struct EnvironmentLightDesc {
+  const Texture* environment_map;
+} EnvironmentLightDesc;
+/// Describes a light.
+typedef struct LightDesc {
+  LightType type;
+  union {
+    EnvironmentLightDesc environment;
+  } light;
+} LightDesc;
+/// Alpha mode.
+typedef enum AlphaMode { Opaque = 0, Mask = 1, Blend = 2 } AlphaMode;
+/// Describes a material.
+///
+/// TODO: It doesn't hold the shader program anymore...It's in the Mesh.
+/// A material holds a shader program and a set of shader-specific uniform
+/// variables. Two materials can share the same shader, but shader parameters
+/// generally give two materials a different appearance.
+typedef struct MaterialDesc {
+  AlphaMode     alpha_mode;
+  float         alpha_cutoff;
+  int           num_uniforms;
+  ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
+} MaterialDesc;
+/// Describes a mesh.
+typedef struct MeshDesc {
+  const Geometry* geometry;
+  const Material* material;
+  ShaderProgram*  shader;
+} MeshDesc;
+typedef struct ObjectDesc {
+  size_t num_meshes;
+  Mesh*  meshes[GFX_MAX_NUM_MESHES];
+} ObjectDesc;
+/// Scene node type.
+typedef enum NodeType {
+  LogicalNode,
+  AnimaNode,
+  CameraNode,
+  LightNode,
+  ModelNode,
+  ObjectNode,
+} NodeType;
+// -----------------------------------------------------------------------------
+// Camera.
+// -----------------------------------------------------------------------------
+/// Create a new camera.
+Camera* gfx_make_camera(void);
+/// Destroy the camera.
+///
+/// The caller must make sure that no Node owns the given Camera.
+/// For a safe purge of unused resources, see scene_purge().
+void gfx_destroy_camera(Camera**);
+// -----------------------------------------------------------------------------
+// Light.
+// -----------------------------------------------------------------------------
+/// Create a light.
+Light* gfx_make_light(const LightDesc*);
+/// Destroy the light.
+///
+/// The caller must make sure that no Node owns the given Light.
+/// For a safe purge of unused resources, see scene_purge().
+void gfx_destroy_light(Light**);
+// -----------------------------------------------------------------------------
+// Material.
+// -----------------------------------------------------------------------------
+/// Create a material.
+Material* gfx_make_material(const MaterialDesc*);
+/// Destroy the material.
+///
+/// The caller must make sure that no Mesh points to the given Material.
+/// For a safe purge of unused resources, see scene_purge().
+void gfx_destroy_material(Material**);
+// -----------------------------------------------------------------------------
+// Mesh.
+// -----------------------------------------------------------------------------
+/// Create a mesh.
+Mesh* gfx_make_mesh(const MeshDesc*);
+/// Destroy the mesh.
+///
+/// The caller must make sure that no SceneObject points to the given Mesh.
+/// For a safe purge of unused resources, see scene_purge().
+void gfx_destroy_mesh(Mesh**);
+// -----------------------------------------------------------------------------
+// Model.
+// -----------------------------------------------------------------------------
+/// Return the model's anima, or null if the model is not animated.
+Anima* gfx_get_model_anima(Model*);
+/// Return the model's root node.
+const SceneNode* gfx_get_model_root(const Model*);
+SceneNode*       gfx_get_model_root_mut(Model*);
+// -----------------------------------------------------------------------------
+// Object.
+// -----------------------------------------------------------------------------
+/// Create a new object.
+SceneObject* gfx_make_object(const ObjectDesc*);
+/// Destroy the object.
+///
+/// The caller must make sure that no Node owns the given SceneObject.
+/// For a safe purge of unused resources, see scene_purge().
+void gfx_destroy_object(SceneObject**);
+/// Set the object's skeleton.
+void gfx_set_object_skeleton(SceneObject*, const Skeleton*);
+/// Get the object's skeleton.
+/// Return null if the object has no skeleton.
+const Skeleton* gfx_get_object_skeleton(const SceneObject*);
+/// Gets the object's bounding box.
+///
+/// The object's bounding box is the bounding box of its mesh geometries.
+aabb3 gfx_get_object_aabb(const SceneObject*);
+// TODO: Remove the scene object? It only contains the root node.
+// -----------------------------------------------------------------------------
+// Scene.
+// -----------------------------------------------------------------------------
+/// Create a new scene.
+Scene* gfx_make_scene(void);
+/// Destroy the scene.
+///
+/// This function destroys the scene and all objects that it owns (scene
+/// objects, cameras, lights, etc), but not objects that could be shared with
+/// other scenes (meshes, materials, etc).
+void gfx_destroy_scene(Scene**);
+/// Get the scene's root node.
+const SceneNode* gfx_get_scene_root(const Scene*);
+SceneNode*       gfx_get_scene_root_mut(Scene*);
+// -----------------------------------------------------------------------------
+// Node constructors and destructor.
+// -----------------------------------------------------------------------------
+/// Create a new scene node.
+///
+/// This node does not contain any camera, light, object, etc. and exists simply
+/// as a logical and spatial construct.
+SceneNode* gfx_make_node(void);
+/// Create an anima node.
+SceneNode* gfx_make_anima_node(Anima*);
+/// Create a new camera node.
+SceneNode* gfx_make_camera_node(Camera*);
+/// Create a new light node.
+SceneNode* gfx_make_light_node(Light*);
+/// Create a new model node.
+SceneNode* gfx_make_model_node(Model*);
+/// Create a new object node.
+SceneNode* gfx_make_object_node(SceneObject*);
+/// Recursively destroy the scene node and its children.
+///
+/// The scene node and its children are removed from the scene graph.
+///
+/// Node resources -- cameras, lights, objects, etc. -- are also destroyed.
+void gfx_destroy_node(SceneNode**);
+// -----------------------------------------------------------------------------
+// Node getters.
+// -----------------------------------------------------------------------------
+/// Get the node's type.
+NodeType gfx_get_node_type(const SceneNode*);
+/// Get the node's anima.
+///
+/// The node must be of type AnimaNode.
+const Anima* gfx_get_node_anima(const SceneNode*);
+Anima*       gfx_get_node_anima_mut(SceneNode*);
+/// Get the node's camera.
+///
+/// The node must be of type CameraNode.
+const Camera* gfx_get_node_camera(const SceneNode* node);
+Camera*       gfx_get_node_camera_mut(SceneNode* node);
+/// Get the node's light.
+///
+/// The node must be of type LightNode.
+const Light* gfx_get_node_light(const SceneNode*);
+Light*       gfx_get_node_light_mut(SceneNode*);
+/// Get the node's model.
+///
+/// The node must be of type ModelNode.
+const Model* gfx_get_node_model(const SceneNode*);
+Model*       gfx_get_node_model_mut(SceneNode*);
+/// Get the node's scene object.
+///
+/// The node must be of type ObjectNode.
+const SceneObject* gfx_get_node_object(const SceneNode*);
+SceneObject*       gfx_get_node_object_mut(SceneNode*);
+/// Get the node's parent.
+const SceneNode* gfx_get_node_parent(const SceneNode*);
+SceneNode*       gfx_get_node_parent_mut(SceneNode*);
+/// Get the node's first child.
+const SceneNode* gfx_get_node_child(const SceneNode*);
+SceneNode*       gfx_get_node_child_mut(SceneNode*);
+/// Get the node's immediate sibling.
+const SceneNode* gfx_get_node_sibling(const SceneNode*);
+SceneNode*       gfx_get_node_sibling_mut(SceneNode*);
+/// Get the node's (local) transform.
+mat4 gfx_get_node_transform(const SceneNode*);
+/// Get the node's global transform.
+mat4 gfx_get_node_global_transform(const SceneNode*);
+// -----------------------------------------------------------------------------
+// Node setters.
+// -----------------------------------------------------------------------------
+/// Set the node's parent.
+///
+/// Pass in null to unwire from the existing parent, if one exists.
+void gfx_set_node_parent(SceneNode*, SceneNode* parent_node);
+/// Set the node's (local) transform.
+void gfx_set_node_transform(SceneNode*, const mat4* transform);
+/// Set the node's position.
+void gfx_set_node_position(SceneNode*, const vec3* position);
+/// Set the node's rotation.
+void gfx_set_node_rotation(SceneNode*, const quat* rotation);
+/// Set the node's rotation.
+void gfx_set_node_rotation_mat(SceneNode*, const mat4* rotation);
+/// Log the node's hierarchy.
+void gfx_log_node_hierarchy(const SceneNode*);
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
+#define GFX_IMM_MAX_NUM_TRIANGLES 1024
-/// Maximum number of matrices in the immediate-mode renderer's matrix stack.
-#define IMM_MAX_NUM_MATRICES 32
-// 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..55319e1 100644
--- a/gfx/include/gfx/util/skyquad.h
+++ b/include/gfx/util/skyquad.h
@@ -2,7 +2,6 @@
 #pragma once
 typedef struct GfxCore     GfxCore;
-typedef struct Scene       Scene;
 typedef struct SceneNode   SceneNode;
 typedef struct SceneObject SceneObject;
 typedef struct Texture     Texture;
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..f6c6048 100644
--- a/gfx/shaders/cook_torrance.frag
+++ b/shaders/cook_torrance.frag
@@ -1,3 +1,8 @@
+/*
+[1] BRDF reference: https://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
+[2] glTF reference implementation: https://github.com/KhronosGroup/glTF-Sample-Renderer/blob/main/source/Renderer/shaders/brdf.glsl
+[3] Learn OpenGL reference: https://learnopengl.com/PBR/Theory (see other chapters also for IBL)
+*/
 precision highp float;
 uniform vec4  BaseColorFactor;
@@ -5,19 +10,26 @@ uniform float MetallicFactor;
 uniform float RoughnessFactor;
 uniform vec3  EmissiveFactor;
-#ifdef HAS_ALBEDO_MAP
+#if HAS_TRANSPARENCY
+#define ALPHA_MODE_MASK  1
+#define ALPHA_MODE_BLEND 2
+uniform int   AlphaMode;
+uniform float AlphaCutoff;
+#endif
+#if HAS_ALBEDO_MAP
 uniform sampler2D BaseColorTexture;
 #endif
-#ifdef HAS_METALLIC_ROUGHNESS_MAP
+#if HAS_METALLIC_ROUGHNESS_MAP
 uniform sampler2D MetallicRoughnessTexture;
 #endif
-#ifdef HAS_EMISSIVE_MAP
+#if HAS_EMISSIVE_MAP
 uniform sampler2D EmissiveTexture;
 #endif
-#ifdef HAS_OCCLUSION_MAP
+#if HAS_OCCLUSION_MAP
 uniform sampler2D AmbientOcclusionTexture;
 #endif
-#ifdef HAS_NORMAL_MAP
+#if HAS_NORMAL_MAP
 uniform sampler2D NormalMap;
 #endif
@@ -32,13 +44,13 @@ uniform vec3 CameraPosition; // World space.
 // World-space position, normal and tangent.
 in vec3 Position;
-#ifdef HAS_NORMALS
+#if HAS_NORMALS
 in vec3 Normal;
 #endif
-#ifdef HAS_TANGENTS
+#if HAS_TANGENTS
 in vec4 Tangent;
 #endif
-#ifdef HAS_TEXCOORDS
+#if HAS_TEXCOORDS
 in vec2 Texcoord;
 #endif
@@ -56,7 +68,7 @@ layout (location = 0) out vec4 Colour;
 #if defined(HAS_NORMAL_MAP) && (defined(HAS_TANGENTS) || defined(HAS_TEXCOORDS))
 vec3 get_ws_normal(vec3 normalWs, vec3 normalMapSample) {
  vec3 N = normalize(Normal);
-#ifdef HAS_TANGENTS
+#if HAS_TANGENTS
  //vec3 T = normalize(tangent.xyz - dot(tangent.xyz, N) * N);
  vec3 T = Tangent.xyz;
  vec3 B = Tangent.w * cross(N, T);
@@ -86,8 +98,10 @@ vec3 get_ws_normal(vec3 normalWs, vec3 normalMapSample) {
 }
 #endif // HAS_TANGENTS || HAS_TEXCOORDS
+// Normal distribution function (NDF).
+// Eq (4) in reference [1].
 float trowbridge_reitz_GGX(float roughness, float NdotH) {
-  float a = roughness * roughness;
+  float a = roughness * roughness; // "alpha roughness" in the reference.
  float a2 = a * a;
  float d = NdotH * NdotH * (a2 - 1.0) + 1.0;
  return a2 / (PI * d * d);
@@ -97,6 +111,8 @@ float geometry_schlick_GGX(float k, float NdotV) {
  return NdotV / (NdotV * (1.0 - k) + k);
 }
+// Geometry function.
+// See "Smith" under "Geometric Shadowing" in reference [1].
 float geometry_smith(float roughness, float NdotL, float NdotV) {
  float k = roughness * roughness / 2.0; // IBL
  return geometry_schlick_GGX(k, NdotV) * geometry_schlick_GGX(k, NdotL);
@@ -121,7 +137,11 @@ vec3 cook_torrance(
  vec3  F = fresnel_schlick(F0, HdotV);
  float G = geometry_smith(roughness, NdotL, NdotV);
  vec3 Kd = mix(vec3(1.0) - F, vec3(0.0), metallic);
-  vec3 diffuse = Kd*albedo*INV_PI;
+  // A non-HDR environment map essentially has the 1/pi baked in as it does not
+  // use physical units. See:
+  // https://seblagarde.wordpress.com/2012/01/08/pi-or-not-to-pi-in-game-lighting-equation/
+  // vec3 diffuse = Kd * albedo * INV_PI;
+  vec3 diffuse = Kd * albedo * INV_PI;
  // Take a max to prevent division by 0 when either dot product is 0.
  vec3 specular = (D*F*G) / max(4.0 * NdotV * NdotL, 0.0001);
  return diffuse + specular;
@@ -132,46 +152,33 @@ vec3 cook_torrance_IBL(
    vec3 albedo, float metallic, float roughness, float occlusion,
    float NdotV,
    vec3 irradiance, vec3 prefiltered_env, vec2 BRDF_env) {
-  vec3 F0 = mix(vec3(0.04), albedo, metallic);
+  vec3 F0 = mix(vec3(0.04), albedo, metallic); // albedo = F0 for metals
-  vec3  F = fresnel_schlick_roughness(F0, NdotV, roughness);
+  vec3 F  = fresnel_schlick_roughness(F0, NdotV, roughness);
-  vec3 Kd = mix(vec3(1.0) - F, vec3(0.0), metallic);
+  vec3 Kd = (vec3(1.0) - F) * (1.0 - metallic);
-  vec3 diffuse = Kd * albedo * INV_PI * irradiance;
+  // A non-HDR environment map essentially has the 1/pi baked in as it does not
+  // use physical units. See:
+  // https://seblagarde.wordpress.com/2012/01/08/pi-or-not-to-pi-in-game-lighting-equation/
+  // vec3 diffuse = Kd * albedo * INV_PI * irradiance;
+  vec3 diffuse = Kd * albedo * irradiance;
  vec3 specular = prefiltered_env * (F * BRDF_env.x + BRDF_env.y);
  return occlusion * (diffuse + specular);
 }
 void main()
 {
-  // TODO: Also use the specular F0 map from the model, and emissive. Make sure
-  // to use all maps.
-  // https://sketchfab.com/models/b81008d513954189a063ff901f7abfe4
-#ifdef HAS_NORMAL_MAP
-  vec3 normalMapSample = texture(NormalMap, Texcoord).xyz * 2.0 - 1.0;
-  vec3 N = get_ws_normal(Normal, normalMapSample);
-#elif HAS_NORMALS
-  vec3 N = normalize(Normal);
-#endif
-  vec3 V = normalize(CameraPosition - Position);
-  vec3 R = reflect(-V, N);
-  // Not needed for IBL.
-  //vec3 L = N;
-  //vec3 H = normalize(L + V);
-  float NdotV = max(0.0, dot(N, V));
-  // Not needed for IBL.
-  //float NdotL = max(0.0, dot(N,L));
-  //float NdotH = max(0.0, dot(N,H));
-  //float HdotV = clamp(dot(H,V), 0.0, 1.0);  // Clamp to prevent black spots.
-  // TODO: BaseColorFactor and BaseColorTexture are vec4/rgba quantities
-  // respectively. Handle the alpha channel.
  // TODO: Other factors.
-#ifdef HAS_ALBEDO_MAP
+#if HAS_ALBEDO_MAP
-  vec3 albedo = vec3(BaseColorFactor) * texture(BaseColorTexture, Texcoord).rgb;
+  vec4 base_colour = vec4(BaseColorFactor) * texture(BaseColorTexture, Texcoord);
 #else
-  vec3 albedo = vec3(BaseColorFactor);
+  vec4 base_colour = vec4(BaseColorFactor);
+#endif
+  vec3 albedo = base_colour.rgb;
+#if HAS_TRANSPARENCY
+  if ((AlphaMode == ALPHA_MODE_MASK) && (base_colour.a < AlphaCutoff)) {
+    discard;
+  }
 #endif
-#ifdef HAS_METALLIC_ROUGHNESS_MAP
+#if HAS_METALLIC_ROUGHNESS_MAP
  // Spec: "Its green channel contains roughness values and its blue channel
  // contains metalness values."
  vec2 metal_roughness
@@ -180,12 +187,12 @@ void main()
 #else
  vec2 metal_roughness = vec2(MetallicFactor, RoughnessFactor);
 #endif
-#ifdef HAS_EMISSIVE_MAP
+#if HAS_EMISSIVE_MAP
  vec3 emissive = EmissiveFactor * texture(EmissiveTexture, Texcoord).rgb;
 #else
  vec3 emissive = EmissiveFactor;
 #endif
-#ifdef HAS_OCCLUSION_MAP
+#if HAS_OCCLUSION_MAP
  float occlusion = texture(AmbientOcclusionTexture, Texcoord).r;
 #else
  float occlusion = 1.0;
@@ -193,6 +200,32 @@ void main()
  float metallic  = metal_roughness.x;
  float roughness = metal_roughness.y;
+  // TODO: Also use the specular F0 map from the model, and emissive. Make sure
+  // to use all maps.
+  // https://sketchfab.com/models/b81008d513954189a063ff901f7abfe4
+#if HAS_NORMAL_MAP
+  // Spec: "After dequantization, texel values MUST be mapped as follows:
+  //   red   [0.0 .. 1.0] to X [-1 .. 1],
+  //   green [0.0 .. 1.0] to Y [-1 .. 1],
+  //   blue  (0.5 .. 1.0] to Z ( 0 .. 1].
+  // Normal textures SHOULD NOT contain blue values less than or equal to 0.5."
+  vec3 normalMapSample = texture(NormalMap, Texcoord).xyz * 2.0 - 1.0;
+  vec3 N = get_ws_normal(Normal, normalMapSample);
+#elif HAS_NORMALS
+  vec3 N = normalize(Normal);
+#endif
+  vec3 V = normalize(CameraPosition - Position);
+  vec3 R = reflect(-V, N);
+  // Not needed for IBL.
+  //vec3 L = N;
+  //vec3 H = normalize(L + V);
+  float NdotV = max(0.0, dot(N, V));
+  // Not needed for IBL.
+  //float NdotL = max(0.0, dot(N,L));
+  //float NdotH = max(0.0, dot(N,H));
+  //float HdotV = clamp(dot(H,V), 0.0, 1.0);  // Clamp to prevent black spots.
  // For a single light direction:
  // vec3 brdf = cook_torrance(albedo, metallic, roughness, NdotL, NdotV, NdotH, HdotV);
  // vec3 Li = texture(Sky, N).rgb;
@@ -251,5 +284,5 @@ void main()
  //   //colour = B * 0.5 + 0.5;
  // }
-  Colour = vec4(colour, 1.0);
+  Colour = vec4(colour, base_colour.a);
 }
diff --git a/gfx/shaders/cook_torrance.vert b/shaders/cook_torrance.vert
index 5f126c0..17fe1f7 100644
--- a/gfx/shaders/cook_torrance.vert
+++ b/shaders/cook_torrance.vert
@@ -5,7 +5,7 @@ uniform mat4 ModelMatrix;
 uniform mat4 View;
 uniform mat4 Projection;
 //uniform mat4 MVP;
-#ifdef HAS_JOINTS
+#if HAS_JOINTS
 // The client should pass in an appropriate value for MAX_JOINTS.
 // #define MAX_JOINTS 96
 //
@@ -21,35 +21,35 @@ uniform mat4 JointMatrices[MAX_JOINTS]; // Use 4x4 for now to keep it simple.
 #endif
 layout (location = 0) in vec3 vPosition;
-#ifdef HAS_NORMALS
+#if HAS_NORMALS
 layout (location = 1) in vec3 vNormal;
 #endif
-#ifdef HAS_TANGENTS
+#if HAS_TANGENTS
 layout (location = 2) in vec4 vTangent;
 #endif
-#ifdef HAS_TEXCOORDS
+#if HAS_TEXCOORDS
 layout (location = 3) in vec2 vTexcoord;
 #endif
-#ifdef HAS_JOINTS
+#if HAS_JOINTS
 layout (location = 4) in uvec4 vJoint;
 layout (location = 5) in vec4  vWeight;
 #endif
 // World-space position, normal and tangent.
 out vec3 Position;
-#ifdef HAS_NORMALS
+#if HAS_NORMALS
 out vec3 Normal;
 #endif
-#ifdef HAS_TANGENTS
+#if HAS_TANGENTS
 out vec4 Tangent;
 #endif
-#ifdef HAS_TEXCOORDS
+#if HAS_TEXCOORDS
 out vec2 Texcoord;
 #endif
 void main()
 {
-#ifdef HAS_JOINTS
+#if HAS_JOINTS
  mat4 skinMatrix =
    vWeight.x * JointMatrices[vJoint.x] +
    vWeight.y * JointMatrices[vJoint.y] +
@@ -59,14 +59,14 @@ void main()
 #else
  Position = vec3(ModelMatrix * vec4(vPosition, 1.0));
 #endif
-#ifdef HAS_NORMALS
+#if HAS_NORMALS
  Normal = mat3(ModelMatrix) * vNormal;
  //Normal = normalize(ModelMatrix * vec4(vNormal, 0.0)).xyz;
 #endif
-#ifdef HAS_TANGENTS
+#if HAS_TANGENTS
  Tangent = vec4(mat3(ModelMatrix) * vTangent.xyz, vTangent.w);
 #endif
-#ifdef HAS_TEXCOORDS
+#if HAS_TEXCOORDS
  Texcoord = vTexcoord;
 #endif
  gl_Position = Projection * View * vec4(Position, 1.0);
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/scene/animation.c b/src/animation.c
index 08d02ce..c52df73 100644
--- a/gfx/src/scene/animation.c
+++ b/src/animation.c
@@ -1,7 +1,6 @@
 #include "animation_impl.h"
-#include "node_impl.h"
+#include "memory.h"
-#include "scene_memory.h"
 #include <string.h>
@@ -204,10 +203,6 @@ void gfx_destroy_anima(Anima** anima) {
      mem_free_animation(&animation);
    }
-    if ((*anima)->parent.val) {
-      gfx_del_node((*anima)->parent);
-    }
    mem_free_anima(anima);
  }
 }
@@ -450,10 +445,8 @@ void gfx_update_animation(Anima* anima, R t) {
  // which we have constructed to be the common root of all skeletons.
  //
  // This procedure touches every joint exactly once.
-  SceneNode* root_node = mem_get_node(anima->parent);
+  const mat4 root_global_transform     = mat4_id();
-  // LOGD("Root: %u, child: %u", anima->parent.val, root->child.val);
+  const mat4 root_inv_global_transform = mat4_id();
-  const mat4 root_global_transform = gfx_get_node_global_transform(root_node);
-  const mat4 root_inv_global_transform = mat4_inverse(root_global_transform);
  Joint* root_joint = get_anima_root_joint(anima);
  compute_joint_matrices_rec(
@@ -504,21 +497,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/animation_impl.h
index 4408158..4929b97 100644
--- a/gfx/src/scene/animation_impl.h
+++ b/src/animation_impl.h
@@ -1,6 +1,6 @@
 #pragma once
-#include <gfx/scene/animation.h>
+#include <gfx/animation.h>
 #include <gfx/sizes.h>
 #include "types.h"
@@ -12,7 +12,6 @@
 #include <math/vec3.h>
 #include <stddef.h>
-#include <stdint.h>
 typedef struct Buffer Buffer;
@@ -24,24 +23,24 @@ typedef struct Buffer Buffer;
 /// Joints are mutable and store the transform and joint matrices that result
 /// from animation, aside from the inverse bind matrix.
 typedef struct Joint {
-  joint_idx child;       /// First child Joint; index into Anima's joints.
+  joint_idx child;       // First child Joint; index into Anima's joints.
-  joint_idx next;        /// Next sibling Joint; index into Anima's joints.
+  joint_idx next;        // Next sibling Joint; index into Anima's joints.
-  mat4      transform;   /// Local transform relative to parent.
+  mat4      transform;   // Local transform relative to parent.
-  mat4  inv_bind_matrix; /// Transforms the mesh into the joint's local space.
+  mat4  inv_bind_matrix; // Transforms the mesh into the joint's local space.
-  mat4  joint_matrix;    /// inv(global) * global joint transform * inv(bind).
+  mat4  joint_matrix;    // inv(global) * global joint transform * inv(bind).
-  aabb3 box;             /// Bounding box of vertices affected by joint.
+  aabb3 box;             // Bounding box of vertices affected by joint.
 } Joint;
 /// Animation skeleton.
 typedef struct Skeleton {
  skeleton_idx next;
  size_t       num_joints;
-  joint_idx joints[GFX_MAX_NUM_JOINTS]; /// Indices into Anima's joints array.
+  joint_idx    joints[GFX_MAX_NUM_JOINTS]; // Indices into Anima's joints array.
 } Skeleton;
 /// A keyframe of animation.
 typedef struct Keyframe {
-  R time; /// Start time in [0, end animation time]
+  R time; // Start time in [0, end animation time]
  union {
    vec3 translation;
    quat rotation;
@@ -50,7 +49,7 @@ typedef struct Keyframe {
 /// Animation channel.
 typedef struct Channel {
-  joint_idx              target; /// Index into Anima's joints array.
+  joint_idx              target; // Index into Anima's joints array.
  ChannelType            type;
  AnimationInterpolation interpolation;
  size_t                 num_keyframes;
@@ -89,10 +88,9 @@ typedef struct AnimationState {
 /// have no parent (a skeleton need not have its own root and can be a set of
 /// disjoint node hierarchies).
 typedef struct Anima {
-  node_idx       parent;     /// Parent SceneNode.
+  skeleton_idx   skeleton;   // Index of first skeleton.
-  skeleton_idx   skeleton;   /// Index of first skeleton.
+  animation_idx  animation;  // Index of first animation.
-  animation_idx  animation;  /// Index of first animation.
+  AnimationState state;      // Current animation state.
-  AnimationState state;      /// Current animation state.
+  size_t         num_joints; // Number of actual joints in the array.
-  size_t         num_joints; /// Number of actual joints in the array.
+  Joint          joints[GFX_MAX_NUM_JOINTS]; // Shared by all skeletons.
-  Joint          joints[GFX_MAX_NUM_JOINTS]; /// Shared by all skeletons.
 } Anima;
diff --git a/gfx/src/asset/asset_cache.c b/src/asset/asset_cache.c
index 16c4d5c..dfaf7c6 100644
--- a/gfx/src/asset/asset_cache.c
+++ b/src/asset/asset_cache.c
@@ -1,15 +1,15 @@
 #include "asset_cache.h"
+#include "animation_impl.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>
 #include <gfx/gfx.h>
-#include <gfx/scene/node.h>
+#include <gfx/scene.h>
 #include <gfx_assert.h>
 #include <cstring.h>
@@ -167,7 +167,6 @@ static Model* clone_model(const Model* model) {
    SceneNode* root_copy = gfx_clone_scene_shallow(root);
    root_copy->anima     = mem_get_anima_index(anima_copy);
-    anima_copy->parent   = mem_get_node_index(root_copy);
    Model* copy = mem_alloc_model();
    copy->root  = mem_get_node_index(root_copy);
@@ -179,6 +178,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 +189,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..b5c6b0d 100644
--- a/gfx/src/asset/model.c
+++ b/src/asset/model.c
@@ -82,30 +82,26 @@
 #include "asset/model.h"
 #include "asset/texture.h"
-#include "gfx/core.h"
-#include "gfx/gfx.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"
 #include "gfx_assert.h"
 #include "scene/model_impl.h"
-#include "cstring.h"
+#include <gfx/animation.h>
-#include "error.h"
+#include <gfx/core.h>
-#include "log/log.h"
+#include <gfx/gfx.h>
-#include "math/camera.h"
+#include <gfx/render/llr.h>
-#include "math/defs.h"
+#include <gfx/scene.h>
-#include "math/mat4.h"
+#include <gfx/sizes.h>
-#include "math/quat.h"
+#include <gfx/util/shader.h>
-#include "math/vec2.h"
-#include "math/vec3.h"
+#include <cstring.h>
+#include <error.h>
+#include <log/log.h>
+#include <math/camera.h>
+#include <math/defs.h>
+#include <math/mat4.h>
+#include <math/quat.h>
+#include <math/vec2.h>
+#include <math/vec3.h>
 #include "cgltf_tangents.h"
 #define CGLTF_IMPLEMENTATION
@@ -142,6 +138,7 @@
 #define DEFINE_HAS_NORMAL_MAP             "HAS_NORMAL_MAP"
 #define DEFINE_HAS_OCCLUSION_MAP          "HAS_OCCLUSION_MAP"
 #define DEFINE_HAS_EMISSIVE_MAP           "HAS_EMISSIVE_MAP"
+#define DEFINE_HAS_TRANSPARENCY           "HAS_TRANSPARENCY"
 #define DEFINE_HAS_JOINTS                 "HAS_JOINTS"
 #define DEFINE_MAX_JOINTS                 "MAX_JOINTS"
@@ -170,6 +167,8 @@ typedef struct MeshPermutation {
      bool has_normal_map             : 1;
      bool has_occlusion_map          : 1;
      bool has_emissive_map           : 1;
+      // Material.
+      bool has_transparency : 1;
    };
    int32_t all;
  };
@@ -196,6 +195,7 @@ static size_t make_defines(
  check(has_normal_map, DEFINE_HAS_NORMAL_MAP);
  check(has_occlusion_map, DEFINE_HAS_OCCLUSION_MAP);
  check(has_emissive_map, DEFINE_HAS_EMISSIVE_MAP);
+  check(has_transparency, DEFINE_HAS_TRANSPARENCY);
  if (perm.has_joints) {
    defines[next].name  = sstring_make(DEFINE_MAX_JOINTS);
@@ -212,12 +212,12 @@ static ShaderProgram* make_shader_permutation(
  LOGD(
      "Compiling Cook-Torrance shader permutation: texcoords: %d, normals: "
      "%d, tangents: %d, joints: %d, weights: %d, albedo map: %d, "
-      "metallic-roughness map: "
+      "metallic-roughness map: %d, normal map: %d, AO map: %d, emissive map: "
-      "%d, normal "
+      "%d, has transparency: %d",
-      "map: %d, AO map: %d, emissive map: %d",
      perm.has_texcoords, perm.has_normals, perm.has_tangents, perm.has_joints,
      perm.has_weights, perm.has_albedo_map, perm.has_metallic_roughness_map,
-      perm.has_normal_map, perm.has_occlusion_map, perm.has_emissive_map);
+      perm.has_normal_map, perm.has_occlusion_map, perm.has_emissive_map,
+      perm.has_transparency);
  ShaderCompilerDefine defines[GFX_MAX_SHADER_COMPILER_DEFINES];
  const size_t         num_defines = make_defines(perm, defines);
@@ -578,11 +578,10 @@ static bool load_buffers(
    const cgltf_buffer* buffer = &data->buffers[i];
    assert(buffer->data);
    buffers[i] = gfx_make_buffer(
-        gfxcore, &(BufferDesc){
+        gfxcore, &(BufferDesc){.usage      = BufferStatic,
-                     .usage      = BufferStatic,
+                               .type       = BufferUntyped,
-                     .type       = BufferUntyped,
+                               .data.data  = buffer->data,
-                     .data.data  = buffer->data,
+                               .data.count = buffer->size});
-                     .data.count = buffer->size});
    if (!buffers[i]) {
      return false;
    }
@@ -604,11 +603,10 @@ static bool load_tangent_buffers(
    const cgltfTangentBuffer* buffer = &cgltf_tangent_buffers[i];
    assert(buffer->data);
    tangent_buffers[i] = gfx_make_buffer(
-        gfxcore, &(BufferDesc){
+        gfxcore, &(BufferDesc){.usage      = BufferStatic,
-                     .usage      = BufferStatic,
+                               .type       = BufferUntyped,
-                     .type       = BufferUntyped,
+                               .data.data  = buffer->data,
-                     .data.data  = buffer->data,
+                               .data.count = buffer->size_bytes});
-                     .data.count = buffer->size_bytes});
    if (!tangent_buffers[i]) {
      return false;
    }
@@ -682,14 +680,13 @@ static void load_textures_lazy(
    mstring fullpath =
        mstring_concat_path(mstring_make(directory), mstring_make(image->uri));
-    load_texture_cmds[i] = (LoadTextureCmd){
+    load_texture_cmds[i] = (LoadTextureCmd){.origin       = AssetFromFile,
-        .origin                = AssetFromFile,
+                                            .type         = LoadTexture,
-        .type                  = LoadTexture,
+                                            .colour_space = LinearColourSpace,
-        .colour_space          = sRGB,
+                                            .filtering    = filtering,
-        .filtering             = filtering,
+                                            .wrap         = wrap,
-        .wrap                  = wrap,
+                                            .mipmaps      = mipmaps,
-        .mipmaps               = mipmaps,
+                                            .data.texture.filepath = fullpath};
-        .data.texture.filepath = fullpath};
  }
 }
@@ -717,8 +714,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.
+    // Albedo and emissive use sRGB. Other textures use a linear colour space.
-    if (texture_type == NormalMap) {
+    // See the notes on the spec.
+    if ((texture_type == BaseColorTexture) ||
+        (texture_type == EmissiveTexture)) {
+      cmd->colour_space = sRGB;
+    } else {
      cmd->colour_space = LinearColourSpace;
    }
@@ -745,6 +746,19 @@ static bool load_texture_and_uniform(
  return true;
 }
+static AlphaMode to_gfx_alpha_mode(cgltf_alpha_mode mode) {
+  switch (mode) {
+  case cgltf_alpha_mode_opaque:
+    return Opaque;
+  case cgltf_alpha_mode_mask:
+    return Mask;
+  case cgltf_alpha_mode_blend:
+    return Blend;
+  }
+  FAIL("unhandled alpha mode");
+  return Opaque;
+}
 /// Load all materials from the glTF scene.
 ///
 /// Return an array of Materials such that the index of each descriptor matches
@@ -773,27 +787,27 @@ static bool load_materials(
      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
      desc.uniforms[next_uniform++] = (ShaderUniform){
-          .name       = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
+          .name               = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
-          .type       = UniformVec4,
+          .type               = UniformVec4,
-          .value.vec4 = vec4_from_array(pbr->base_color_factor)};
+          .value.uniform_vec4 = vec4_from_array(pbr->base_color_factor)};
      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
-      desc.uniforms[next_uniform++] = (ShaderUniform){
+      desc.uniforms[next_uniform++] =
-          .name         = sstring_make(UNIFORM_METALLIC_FACTOR),
+          (ShaderUniform){.name = sstring_make(UNIFORM_METALLIC_FACTOR),
-          .type         = UniformFloat,
+                          .type = UniformFloat,
-          .value.scalar = pbr->metallic_factor};
+                          .value.uniform_float = pbr->metallic_factor};
      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
-      desc.uniforms[next_uniform++] = (ShaderUniform){
+      desc.uniforms[next_uniform++] =
-          .name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
+          (ShaderUniform){.name = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
-          .type         = UniformFloat,
+                          .type = UniformFloat,
-          .value.scalar = pbr->roughness_factor};
+                          .value.uniform_float = pbr->roughness_factor};
      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
      desc.uniforms[next_uniform++] = (ShaderUniform){
-          .name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
+          .name               = sstring_make(UNIFORM_EMISSIVE_FACTOR),
-          .type       = UniformVec3,
+          .type               = UniformVec3,
-          .value.vec3 = vec3_from_array(mat->emissive_factor)};
+          .value.uniform_vec3 = vec3_from_array(mat->emissive_factor)};
      if (pbr->base_color_texture.texture) {
        if (!load_texture_and_uniform(
@@ -840,6 +854,9 @@ static bool load_materials(
    assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
    desc.num_uniforms = next_uniform;
+    desc.alpha_mode   = to_gfx_alpha_mode(mat->alpha_mode);
+    desc.alpha_cutoff = mat->alpha_cutoff;
    materials[i] = gfx_make_material(&desc);
    if (!materials[i]) {
      return false;
@@ -854,28 +871,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){
+  desc.uniforms[desc.num_uniforms++] =
-      .name       = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
+      (ShaderUniform){.name = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
-      .type       = UniformVec4,
+                      .type = UniformVec4,
-      .value.vec4 = vec4_make(1, 1, 1, 1)};
+                      .value.uniform_vec4 = vec4_make(1, 1, 1, 1)};
  assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
+  desc.uniforms[desc.num_uniforms++] =
-      .name         = sstring_make(UNIFORM_METALLIC_FACTOR),
+      (ShaderUniform){.name = sstring_make(UNIFORM_METALLIC_FACTOR),
-      .type         = UniformFloat,
+                      .type = UniformFloat,
-      .value.scalar = 0};
+                      .value.uniform_float = 0};
  assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
+  desc.uniforms[desc.num_uniforms++] =
-      .name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
+      (ShaderUniform){.name = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
-      .type         = UniformFloat,
+                      .type = UniformFloat,
-      .value.scalar = 1};
+                      .value.uniform_float = 1};
  assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
-  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
+  desc.uniforms[desc.num_uniforms++] =
-      .name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
+      (ShaderUniform){.name = sstring_make(UNIFORM_EMISSIVE_FACTOR),
-      .type       = UniformVec3,
+                      .type = UniformVec3,
-      .value.vec3 = vec3_make(0, 0, 0)};
+                      .value.uniform_vec3 = vec3_make(0, 0, 0)};
  return gfx_make_material(&desc);
 }
@@ -953,6 +970,7 @@ static bool load_meshes(
        perm.has_normal_map    = mat->normal_texture.texture != 0;
        perm.has_occlusion_map = mat->occlusion_texture.texture != 0;
        perm.has_emissive_map  = mat->emissive_texture.texture != 0;
+        perm.has_transparency  = mat->alpha_mode != cgltf_alpha_mode_opaque;
        if (mat->has_pbr_metallic_roughness) {
          const cgltf_pbr_metallic_roughness* pbr =
@@ -1012,7 +1030,6 @@ static bool load_meshes(
        const cgltf_attribute*   attrib       = &prim->attributes[a];
        const cgltf_accessor*    accessor     = attrib->data;
        const cgltf_buffer_view* view         = accessor->buffer_view;
-        const cgltf_size         offset       = accessor->offset + view->offset;
        const cgltf_size         buffer_index = view->buffer - data->buffers;
        assert(buffer_index < data->buffers_count);
@@ -1102,12 +1119,20 @@ static bool load_meshes(
          break;
        }
-#define CONFIGURE_BUFFER(buf)         \
+        // See comments here for accessor/view/buffer invariants:
-  if (buf) {                          \
+        //   https://github.com/KhronosGroup/glTF-Sample-Assets/issues/242
-    buf->buffer       = buffer;       \
+        // Gfx only has Buffer and BufferView, not accessors. We must combine
-    buf->offset_bytes = offset;       \
+        // the glTF's accessor and view offsets correctly.
-    buf->size_bytes   = view->size;   \
+        const cgltf_size offset     = accessor->offset + view->offset;
-    buf->stride_bytes = view->stride; \
+        const cgltf_size size_bytes = view->size - accessor->offset;
+#define CONFIGURE_BUFFER(buf)            \
+  if (buf) {                             \
+    buf->buffer       = buffer;          \
+    buf->offset_bytes = offset;          \
+    buf->size_bytes   = size_bytes;      \
+    buf->stride_bytes = view->stride;    \
+    buf->count        = accessor->count; \
  }
        CONFIGURE_BUFFER(buffer_view_2d);
        CONFIGURE_BUFFER(buffer_view_3d);
@@ -1142,14 +1167,11 @@ static bool load_meshes(
      // either 2d or 3d positions but not both, here we can perform addition
      // to compute the total number of vertices.
      geometry_desc.num_verts =
-          (geometry_desc.positions2d.size_bytes / sizeof(vec2)) +
+          geometry_desc.positions2d.count + geometry_desc.positions3d.count;
-          (geometry_desc.positions3d.size_bytes / sizeof(vec3));
+#define CHECK_COUNT(buffer_view, type, num_components)                  \
-#define CHECK_COUNT(buffer_view, type, num_components)                 \
+  if (geometry_desc.buffer_view.buffer) {                               \
-  if (geometry_desc.buffer_view.buffer) {                              \
+    assert(geometry_desc.buffer_view.count == geometry_desc.num_verts); \
-    assert(                                                            \
-        (geometry_desc.buffer_view.size_bytes /                        \
-         (num_components * sizeof(type))) == geometry_desc.num_verts); \
  }
      // Check that the number of vertices is consistent across all vertex
@@ -1192,10 +1214,10 @@ static bool load_meshes(
          shader ? shader : make_shader_permutation(gfxcore, perm);
      assert(mesh_shader);
-      meshes[next_mesh] = gfx_make_mesh(&(MeshDesc){
+      meshes[next_mesh] =
-          .geometry = geometries[next_mesh],
+          gfx_make_mesh(&(MeshDesc){.geometry = geometries[next_mesh],
-          .material = material,
+                                    .material = material,
-          .shader   = mesh_shader});
+                                    .shader   = mesh_shader});
      if (!meshes[next_mesh]) {
        return false;
@@ -1432,9 +1454,9 @@ static void load_animations(
    const cgltf_animation* animation      = &data->animations[a];
    AnimationDesc*         animation_desc = &anima_desc->animations[a];
-    *animation_desc = (AnimationDesc){
+    *animation_desc =
-        .name         = sstring_make(animation->name),
+        (AnimationDesc){.name         = sstring_make(animation->name),
-        .num_channels = animation->channels_count};
+                        .num_channels = animation->channels_count};
    assert(animation->channels_count <= GFX_MAX_NUM_CHANNELS);
    for (cgltf_size c = 0; c < animation->channels_count; ++c) {
@@ -1490,15 +1512,75 @@ static void load_animations(
  }
 }
+/// Remove joint nodes from the Gfx Scene.
+///
+/// Joint nodes are not needed because joints are packed into the Anima.
+static void remove_joint_nodes(
+    const cgltf_data* data, SceneNode** scene_nodes) {
+  assert(data);
+  assert(scene_nodes);
+  // This works assuming the joint nodes are contiguous. Contiguity is checked
+  // when loading skins. See load_skins().
+  size_t min_joint_index = (size_t)-1;
+  size_t max_joint_index = 0;
+  // First get the minimum and maximum indices of all joint nodes.
+  for (cgltf_size s = 0; s < data->skins_count; ++s) {
+    const cgltf_skin* skin = &data->skins[s];
+    for (cgltf_size j = 0; j < skin->joints_count; ++j) {
+      // Joint is an index/pointer into the nodes array.
+      const cgltf_size joint_index = skin->joints[j] - data->nodes;
+      assert(joint_index < data->nodes_count);
+      if (joint_index < min_joint_index) {
+        min_joint_index = joint_index;
+      }
+      if (joint_index > max_joint_index) {
+        max_joint_index = joint_index;
+      }
+    }
+  }
+  assert(min_joint_index < data->nodes_count);
+  assert(max_joint_index < data->nodes_count);
+  // Now walk over the joint nodes. If a joint's parent is itself not a joint
+  // node, then that joint is a root of a joint hierarchy (skins in glTF may
+  // have multiple roots). In such case, delete the root joint recursively.
+  for (cgltf_size s = 0; s < data->skins_count; ++s) {
+    const cgltf_skin* skin = &data->skins[s];
+    for (cgltf_size j = 0; j < skin->joints_count; ++j) {
+      // Joint is an index/pointer into the nodes array.
+      const cgltf_size joint_index = skin->joints[j] - data->nodes;
+      assert(joint_index < data->nodes_count);
+      const cgltf_node* joint = &data->nodes[joint_index];
+      // Parent node index.
+      const cgltf_size parent_index = joint->parent - data->nodes;
+      assert(parent_index < data->nodes_count);
+      // If the parent is not a joint node, recursively delete this joint node.
+      if ((parent_index < min_joint_index) ||
+          (parent_index > max_joint_index)) {
+        gfx_destroy_node(&scene_nodes[joint_index]);
+      }
+    }
+  }
+}
 /// Load all nodes from the glTF scene.
 ///
 /// This function ignores the many scenes and default scene of the glTF spec
 /// and instead just loads all nodes into a single gfx Scene.
 static void load_nodes(
    const cgltf_data* data, SceneNode* root_node, SceneObject** objects,
-    SceneCamera** cameras, const Anima* anima, SceneNode** nodes) {
+    const Anima* anima, SceneNode** nodes) {
  // Note that with glTF 2.0, nodes do not form a DAG / scene graph but a
-  // disjount union of strict trees:
+  // disjoint union of strict trees:
  //
  // "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.
@@ -1511,25 +1593,25 @@ static void load_nodes(
  assert(data);
  assert(root_node);
  assert(objects);
-  assert(cameras);
  assert(nodes);
  cgltf_size next_camera = 0;
+  // First pass: create the nodes.
  for (cgltf_size n = 0; n < data->nodes_count; ++n) {
    const cgltf_node* node = &data->nodes[n];
-    // Add SceneObject, SceneCamera or Lights.
+    // Add SceneObject, Camera or Lights.
    // TODO: Handle lights once they are implemented in the gfx library.
    if (node->mesh) {
      const cgltf_size mesh_index = node->mesh - data->meshes;
      assert(mesh_index < data->meshes_count);
      SceneObject* object = objects[mesh_index];
-      gfx_construct_object_node(nodes[n], object);
+      nodes[n] = gfx_make_object_node(object);
      if (node->skin) {
        assert(anima);
        const cgltf_size skin_index = node->skin - data->skins;
        assert(skin_index < data->skins_count);
        const Skeleton* skeleton = gfx_get_anima_skeleton(anima, skin_index);
@@ -1538,33 +1620,32 @@ static void load_nodes(
    } else if (node->camera) {
      assert(next_camera < data->cameras_count);
-      Camera              camera;
      const cgltf_camera* cam = node->camera;
      // TODO: We could define a function load_cameras() the same way we load
      // every mesh and then remove this ad-hoc loading of cameras here, as well
      // as remove 'next_camera'.
+      Camera* camera = gfx_make_camera();
      switch (cam->type) {
      case cgltf_camera_type_orthographic:
-        camera = camera_orthographic(
+        *camera = camera_orthographic(
            0, cam->data.orthographic.xmag, 0, cam->data.orthographic.ymag,
            cam->data.orthographic.znear, cam->data.orthographic.zfar);
        break;
      case cgltf_camera_type_perspective:
-        camera = camera_perspective(
+        *camera = camera_perspective(
            cam->data.perspective.yfov, cam->data.perspective.aspect_ratio,
            cam->data.perspective.znear, cam->data.perspective.zfar);
        break;
      case cgltf_camera_type_invalid:
        break;
      }
+      nodes[n] = gfx_make_camera_node(camera);
-      gfx_set_camera_camera(cameras[next_camera], &camera);
-      gfx_construct_camera_node(nodes[n], cameras[next_camera]);
      ++next_camera;
    } else {
      // TODO: implementation for missing node types.
      // These nodes currently default to logical nodes.
+      nodes[n] = gfx_make_node();
    }
    assert(nodes[n]);
@@ -1590,6 +1671,11 @@ static void load_nodes(
      }
    }
    gfx_set_node_transform(nodes[n], &transform);
+  }
+  // Second pass: wire up the node hierarchy.
+  for (cgltf_size n = 0; n < data->nodes_count; ++n) {
+    const cgltf_node* node = &data->nodes[n];
    // If this is a top-level node in the glTF scene, set its parent to the
    // given root node.
@@ -1602,66 +1688,12 @@ static void load_nodes(
      assert(parent);
      gfx_set_node_parent(nodes[n], parent);
    }
-  } // SceneNode.
-}
-/// Remove joint nodes from the Gfx Scene.
-///
-/// Joint nodes are not needed because joints are packed into the Anima.
-static void remove_joint_nodes(
-    const cgltf_data* data, SceneNode** scene_nodes) {
-  assert(data);
-  assert(scene_nodes);
-  // This works assuming the joint nodes are contiguous. Contiguity is checked
-  // when loading skins. See load_skins().
-  size_t min_joint_index = (size_t)-1;
-  size_t max_joint_index = 0;
-  // First get the minimum and maximum indices of all joint nodes.
-  for (cgltf_size s = 0; s < data->skins_count; ++s) {
-    const cgltf_skin* skin = &data->skins[s];
-    for (cgltf_size j = 0; j < skin->joints_count; ++j) {
-      // Joint is an index/pointer into the nodes array.
-      const cgltf_size joint_index = skin->joints[j] - data->nodes;
-      assert(joint_index < data->nodes_count);
-      if (joint_index < min_joint_index) {
-        min_joint_index = joint_index;
-      }
-      if (joint_index > max_joint_index) {
-        max_joint_index = joint_index;
-      }
-    }
  }
-  assert(min_joint_index < data->nodes_count);
+  // Clean up scene nodes that correspond to joints in the glTF. These are not
-  assert(max_joint_index < data->nodes_count);
+  // needed anymore.
+  if (data->skins_count > 0) {
-  // Now walk over the joint nodes. If a joint's parent is itself not a joint
+    remove_joint_nodes(data, nodes);
-  // node, then that joint is a root of a joint hierarchy (skins in glTF may
-  // have multiple roots). In such case, delete the root joint recursively.
-  for (cgltf_size s = 0; s < data->skins_count; ++s) {
-    const cgltf_skin* skin = &data->skins[s];
-    for (cgltf_size j = 0; j < skin->joints_count; ++j) {
-      // Joint is an index/pointer into the nodes array.
-      const cgltf_size joint_index = skin->joints[j] - data->nodes;
-      assert(joint_index < data->nodes_count);
-      const cgltf_node* joint = &data->nodes[joint_index];
-      // Parent node index.
-      const cgltf_size parent_index = joint->parent - data->nodes;
-      assert(parent_index < data->nodes_count);
-      // If the parent is not a joint node, recursively delete this joint node.
-      if ((parent_index < min_joint_index) ||
-          (parent_index > max_joint_index)) {
-        gfx_destroy_node(&scene_nodes[joint_index]);
-      }
-    }
  }
 }
@@ -1705,42 +1737,21 @@ static Model* load_scene(
  LOGD("Filepath: %s", mstring_cstr(filepath));
  LOGD("Directory: %s", mstring_cstr(&directory));
-  Buffer**        tangent_buffers   = 0;
-  Buffer**        buffers           = 0;
-  LoadTextureCmd* load_texture_cmds = 0;
-  const Texture** textures          = 0; // Textures are owned by asset cache.
-  Material**      materials         = 0;
-  Geometry**      geometries        = 0;
-  Mesh**          meshes            = 0;
-  AnimaDesc*      anima_desc        = 0;
-  SceneObject**   scene_objects     = 0;
-  SceneCamera**   scene_cameras     = 0;
-  SceneNode**     scene_nodes       = 0;
-  Anima*          anima             = 0;
-  SceneNode*      root_node         = 0;
-  Model*          model             = 0;
-  tangent_buffers = calloc(num_tangent_buffers, sizeof(Buffer*));
-  buffers         = calloc(data->buffers_count, sizeof(Buffer*));
-  textures        = calloc(data->textures_count, sizeof(Texture*));
-  materials       = calloc(data->materials_count, sizeof(Material*));
-  geometries      = calloc(primitive_count, sizeof(Geometry*));
-  meshes          = calloc(primitive_count, sizeof(Mesh*));
-  scene_objects   = calloc(data->meshes_count, sizeof(SceneObject*));
-  scene_cameras   = calloc(data->cameras_count, sizeof(SceneCamera**));
-  scene_nodes     = calloc(data->nodes_count, sizeof(SceneNode**));
  // A glTF scene does not necessarily have textures. Materials can be given
  // as constants, for example.
-  if (data->textures_count > 0) {
+  // gfx textures are owned by asset cache.
-    load_texture_cmds = calloc(data->textures_count, sizeof(LoadTextureCmd));
+  Buffer*        tangent_buffers[num_tangent_buffers];
-  }
+  Buffer*        buffers[data->buffers_count];
+  LoadTextureCmd load_texture_cmds[data->textures_count];
-  if (!buffers || !tangent_buffers ||
+  const Texture* textures[data->textures_count];
-      ((data->textures_count > 0) && !load_texture_cmds) || !textures ||
+  Material*      materials[data->materials_count];
-      !materials || !geometries || !meshes || !scene_objects ||
+  Geometry*      geometries[primitive_count];
-      !scene_cameras || !scene_nodes) {
+  Mesh*          meshes[primitive_count];
-    goto cleanup;
+  SceneObject*   scene_objects[data->meshes_count];
-  }
+  SceneNode*     scene_nodes[data->nodes_count];
+  Anima*         anima     = 0;
+  SceneNode*     root_node = 0;
+  Model*         model     = 0;
  if ((num_tangent_buffers > 0) &&
      !load_tangent_buffers(
@@ -1769,47 +1780,30 @@ static Model* load_scene(
    goto cleanup;
  }
-  // Skins refer to nodes, and nodes may refer to skins. To break this circular
-  // dependency, glTF defines skins in terms of node indices. We could do the
-  // same if Gfx allowed allocating nodes contiguously in memory. For now,
-  // create the nodes up front and use the indices of the array to map to the
-  // node_idx.
-  for (cgltf_size i = 0; i < data->nodes_count; ++i) {
-    scene_nodes[i] = gfx_make_node();
-  }
  // Create the scene's root node.
  // This is an anima node if the scene has skins; otherwise it is a logical
  // node.
-  root_node = gfx_make_node();
  if (data->skins_count > 0) {
-    anima_desc = calloc(1, sizeof(AnimaDesc));
-    if (!anima_desc) {
-      goto cleanup;
-    }
    const cgltf_size base = find_base_joint_index(data);
-    anima_desc->num_skeletons  = data->skins_count;
+    AnimaDesc anima_desc =
-    anima_desc->num_animations = data->animations_count;
+        (AnimaDesc){.num_skeletons  = data->skins_count,
-    anima_desc->num_joints     = load_skins(data, buffers, base, anima_desc);
+                    .num_animations = data->animations_count,
-    load_animations(data, base, anima_desc);
+                    .num_joints = load_skins(data, buffers, base, &anima_desc)};
+    load_animations(data, base, &anima_desc);
    compute_joint_bounding_boxes(
-        data, anima_desc->num_joints, anima_desc->joints);
+        data, anima_desc.num_joints, anima_desc.joints);
-    anima = gfx_make_anima(anima_desc);
+    anima     = gfx_make_anima(&anima_desc);
-    gfx_construct_anima_node(root_node, anima);
+    root_node = gfx_make_anima_node(anima);
+  } else {
+    root_node = gfx_make_node();
  }
+  assert(root_node);
  // The root node becomes the root of all scene nodes.
-  load_nodes(data, root_node, scene_objects, scene_cameras, anima, scene_nodes);
+  load_nodes(data, root_node, scene_objects, anima, scene_nodes);
-  // Clean up scene nodes that correspond to joints in the glTF. These are
-  // not needed anymore.
-  if (data->skins_count > 0) {
-    remove_joint_nodes(data, scene_nodes);
-  }
  model = gfx_make_model(root_node);
@@ -1818,96 +1812,42 @@ static Model* load_scene(
 cleanup:
  // The arrays of resources are no longer needed. The resources themselves are
  // destroyed only if this function fails.
-  if (tangent_buffers) {
+  if (!success) {
-    if (!success) {
+    for (cgltf_size i = 0; i < num_tangent_buffers; ++i) {
-      for (cgltf_size i = 0; i < num_tangent_buffers; ++i) {
+      if (tangent_buffers[i]) {
-        if (tangent_buffers[i]) {
+        gfx_destroy_buffer(gfxcore, &tangent_buffers[i]);
-          gfx_destroy_buffer(gfxcore, &tangent_buffers[i]);
-        }
-      }
-    }
-    free(tangent_buffers);
-  }
-  if (buffers) {
-    if (!success) {
-      for (cgltf_size i = 0; i < data->buffers_count; ++i) {
-        if (buffers[i]) {
-          gfx_destroy_buffer(gfxcore, &buffers[i]);
-        }
      }
    }
-    free(buffers);
+    for (cgltf_size i = 0; i < data->buffers_count; ++i) {
-  }
+      if (buffers[i]) {
-  if (load_texture_cmds) {
+        gfx_destroy_buffer(gfxcore, &buffers[i]);
-    free(load_texture_cmds);
-  }
-  if (textures) {
-    free(textures);
-  }
-  if (materials) {
-    if (!success) {
-      for (cgltf_size i = 0; i < data->materials_count; ++i) {
-        if (materials[i]) {
-          gfx_destroy_material(&materials[i]);
-        }
      }
    }
-    free(materials);
+    for (cgltf_size i = 0; i < data->materials_count; ++i) {
-  }
+      if (materials[i]) {
-  if (geometries) {
+        gfx_destroy_material(&materials[i]);
-    if (!success) {
-      for (size_t i = 0; i < primitive_count; ++i) {
-        if (geometries[i]) {
-          gfx_destroy_geometry(gfxcore, &geometries[i]);
-        }
      }
    }
-    free(geometries);
+    for (size_t i = 0; i < primitive_count; ++i) {
-  }
+      if (geometries[i]) {
-  if (meshes) {
+        gfx_destroy_geometry(gfxcore, &geometries[i]);
-    if (!success) {
-      for (size_t i = 0; i < primitive_count; ++i) {
-        if (meshes[i]) {
-          gfx_destroy_mesh(&meshes[i]);
-        }
      }
    }
-    free(meshes);
+    for (size_t i = 0; i < primitive_count; ++i) {
-  }
+      if (meshes[i]) {
-  if (anima_desc) {
+        gfx_destroy_mesh(&meshes[i]);
-    free(anima_desc);
-  }
-  if (scene_objects) {
-    if (!success) {
-      for (cgltf_size i = 0; i < data->meshes_count; ++i) {
-        if (scene_objects[i]) {
-          gfx_destroy_object(&scene_objects[i]);
-        }
      }
    }
-    free(scene_objects);
+    for (cgltf_size i = 0; i < data->meshes_count; ++i) {
-  }
+      if (scene_objects[i]) {
-  if (scene_cameras) {
+        gfx_destroy_object(&scene_objects[i]);
-    if (!success) {
-      for (cgltf_size i = 0; i < data->cameras_count; ++i) {
-        if (scene_cameras[i]) {
-          gfx_destroy_camera(&scene_cameras[i]);
-        }
      }
    }
-    free(scene_cameras);
+    for (cgltf_size i = 0; i < data->nodes_count; ++i) {
-  }
+      if (scene_nodes[i]) {
-  if (scene_nodes) {
+        gfx_destroy_node(&scene_nodes[i]);
-    if (!success) {
-      for (cgltf_size i = 0; i < data->nodes_count; ++i) {
-        if (scene_nodes[i]) {
-          gfx_destroy_node(&scene_nodes[i]);
-        }
      }
    }
-    free(scene_nodes);
-  }
-  if (!success) {
    if (root_node) {
      gfx_destroy_node(&root_node); // Node owns the anima.
    } else if (anima) {
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) {
+        if ((i > 0) && (components != old_components)) {
-          log_error("All textures in a cubemap must have the same number of "
+          log_error(
-                    "components");
+              "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..1df225a 100644
--- a/gfx/src/core/buffer.h
+++ b/src/core/buffer.h
@@ -4,8 +4,6 @@
 #include "gl_util.h"
-#include <math/fwd.h>
 #include <stdbool.h>
 #include <stddef.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..9c04cc7 100644
--- a/gfx/src/core/core.c
+++ b/src/core/core.c
@@ -3,6 +3,7 @@
 #include "gl_util.h"
 // #include <log/log.h>
+#include <fnv1a.h>
 #include <assert.h>
@@ -282,26 +283,29 @@ void gfx_destroy_framebuffer(GfxCore* gfxcore, FrameBuffer** framebuffer) {
 // Shaders.
 // -----------------------------------------------------------------------------
-static uint64_t hash_shader_desc(const ShaderDesc* desc) {
+static hash_t hash_shader_desc(const ShaderDesc* desc) {
  assert(desc);
-  // Note that defines may affect shader permutations, so we need to hash those
+  // Defines may affect shader permutations, so we need to hash those as well.
-  // as well.
+  hash_t hash = fnv1a32_begin();
-  uint64_t hash = 0;
+  hash        = fnv1a32_update(hash, desc->code, strlen(desc->code));
  for (size_t i = 0; i < desc->num_defines; ++i) {
    const ShaderCompilerDefine* define = &desc->defines[i];
-    hash = (((hash << 13) + sstring_hash(define->name)) << 7) +
-           sstring_hash(define->value);
+    hash = fnv1a32_update(
+        hash, sstring_cstr(&define->name), sstring_length(&define->name));
+    hash = fnv1a32_update(
+        hash, sstring_cstr(&define->value), sstring_length(&define->value));
  }
-  return (hash << 17) + cstring_hash(desc->code);
+  return hash;
 }
-static uint64_t hash_program_desc(const ShaderProgramDesc* desc) {
+static hash_t hash_program_desc(const ShaderProgramDesc* desc) {
  assert(desc);
-  return ((uint64_t)desc->vertex_shader->id << 32) |
+  return ((hash_t)desc->vertex_shader->id << 16) |
-         (uint64_t)desc->fragment_shader->id;
+         (hash_t)desc->fragment_shader->id;
 }
-static Shader* find_cached_shader(ShaderCache* cache, uint64_t hash) {
+static Shader* find_cached_shader(ShaderCache* cache, hash_t hash) {
  assert(cache);
  mempool_foreach(cache, entry, {
    if (entry->hash == hash) {
@@ -311,7 +315,7 @@ static Shader* find_cached_shader(ShaderCache* cache, uint64_t hash) {
  return 0;
 }
-static ShaderProgram* find_cached_program(ProgramCache* cache, uint64_t hash) {
+static ShaderProgram* find_cached_program(ProgramCache* cache, hash_t hash) {
  assert(cache);
  mempool_foreach(cache, entry, {
    if (entry->hash == hash) {
@@ -350,9 +354,9 @@ Shader* gfx_make_shader(GfxCore* gfxcore, const ShaderDesc* desc) {
  assert(desc);
  // Check the shader cache first.
-  ShaderCache*   cache  = &gfxcore->shader_cache;
+  ShaderCache* cache  = &gfxcore->shader_cache;
-  const uint64_t hash   = hash_shader_desc(desc);
+  const hash_t hash   = hash_shader_desc(desc);
-  Shader*        shader = find_cached_shader(cache, hash);
+  Shader*      shader = find_cached_shader(cache, hash);
  if (shader) {
    // LOGD("Found cached shader with hash [%lx]", hash);
    return shader;
@@ -395,7 +399,7 @@ ShaderProgram* gfx_make_shader_program(
  // Check the shader program cache first.
  ProgramCache*  cache = &gfxcore->program_cache;
-  const uint64_t hash  = hash_program_desc(desc);
+  const hash_t   hash  = hash_program_desc(desc);
  ShaderProgram* prog  = find_cached_program(cache, hash);
  if (prog) {
    // LOGD("Found cached shader program with hash [%lx]", hash);
@@ -420,6 +424,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..320532d 100644
--- a/gfx/src/core/core_impl.h
+++ b/src/core/core_impl.h
@@ -15,16 +15,18 @@
 #include <stdint.h>
+typedef uint32_t hash_t;
 // TODO: Make a generic (hash, void*) structure and define functions over it.
 // Then define a macro that defines type-safe macros given the type of the
 // entry.
 typedef struct ShaderCacheEntry {
-  uint64_t hash;
+  hash_t  hash;
-  Shader*  shader;
+  Shader* shader;
 } ShaderCacheEntry;
 typedef struct ShaderProgramCacheEntry {
-  uint64_t       hash;
+  hash_t         hash;
  ShaderProgram* program;
 } ShaderProgramCacheEntry;
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..488dc23 100644
--- a/gfx/src/core/geometry.c
+++ b/src/core/geometry.c
@@ -12,7 +12,7 @@
 ///
 /// Note that views are allowed to have no data, in which case a buffer of the
 /// specified size is created.
-#define view_is_populated(BUFFER_VIEW) (BUFFER_VIEW.size_bytes > 0)
+#define view_is_populated(BUFFER_VIEW) (BUFFER_VIEW.count > 0)
 static GLenum primitive_type_to_gl(PrimitiveType type) {
  switch (type) {
@@ -34,30 +34,25 @@ void init_view_buffer(
    BufferUsage buffer_usage) {
  if (!view->buffer) {
    view->buffer = gfx_make_buffer(
-        gfxcore,
+        gfxcore, &(BufferDesc){.usage      = buffer_usage,
-        &(BufferDesc){
+                               .type       = buffer_type,
-            .usage      = buffer_usage,
+                               .data.data  = view->data,
-            .type       = buffer_type,
+                               .data.count = view->count});
-            .data.data  = view->data,
+    assert(view->buffer);
-            .data.count = view->size_bytes /
-                          gfx_get_buffer_type_size_bytes(buffer_type)});
  }
-  assert(view->size_bytes <= view->buffer->size_bytes);
 }
-/// Configure the buffer in teh VAO.
+/// Configure the buffer in the VAO.
 static void configure_buffer(
    GfxCore* gfxcore, const GeometryDesc* desc, BufferView* view,
-    size_t num_components, size_t component_size_bytes, GLenum component_type,
+    size_t num_components, GLenum component_type, GLboolean normalized,
-    GLboolean normalized, GLuint channel) {
+    GLuint channel) {
  assert(gfxcore);
  assert(desc);
  assert(view);
  assert(view->buffer);
-  assert(
+  assert(view->count == desc->num_verts);
-      desc->num_verts <=
+  assert((view->offset_bytes + view->size_bytes) <= view->buffer->size_bytes);
-      view->size_bytes / (num_components * component_size_bytes));
-  assert(view->size_bytes <= view->buffer->size_bytes);
  glBindBuffer(GL_ARRAY_BUFFER, view->buffer->vbo);
  glEnableVertexAttribArray(channel);
@@ -89,8 +84,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->positions3d, 3, sizeof(float),
+        gfxcore, desc, (BufferView*)&desc->positions3d, 3, GL_FLOAT, GL_FALSE,
-        GL_FLOAT, GL_FALSE, GFX_POSITION_CHANNEL);
+        GFX_POSITION_CHANNEL);
  } else if (view_is_populated(desc->positions2d)) {
    init_view_buffer(
        gfxcore, (BufferView*)&desc->positions2d, Buffer2d, desc->buffer_usage);
@@ -98,8 +93,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->positions2d, 2, sizeof(float),
+        gfxcore, desc, (BufferView*)&desc->positions2d, 2, GL_FLOAT, GL_FALSE,
-        GL_FLOAT, GL_FALSE, GFX_POSITION_CHANNEL);
+        GFX_POSITION_CHANNEL);
  }
  if (view_is_populated(desc->normals)) {
    init_view_buffer(
@@ -108,8 +103,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->normals, 3, sizeof(float), GL_FLOAT,
+        gfxcore, desc, (BufferView*)&desc->normals, 3, GL_FLOAT, GL_FALSE,
-        GL_FALSE, GFX_NORMAL_CHANNEL);
+        GFX_NORMAL_CHANNEL);
  }
  if (view_is_populated(desc->tangents)) {
    init_view_buffer(
@@ -118,8 +113,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->tangents, 4, sizeof(float), GL_FLOAT,
+        gfxcore, desc, (BufferView*)&desc->tangents, 4, GL_FLOAT, GL_FALSE,
-        GL_FALSE, GFX_TANGENT_CHANNEL);
+        GFX_TANGENT_CHANNEL);
  }
  if (view_is_populated(desc->texcoords)) {
    init_view_buffer(
@@ -128,8 +123,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->texcoords, 2, sizeof(float),
+        gfxcore, desc, (BufferView*)&desc->texcoords, 2, GL_FLOAT, GL_FALSE,
-        GL_FLOAT, GL_FALSE, GFX_TEXCOORDS_CHANNEL);
+        GFX_TEXCOORDS_CHANNEL);
  }
  if (view_is_populated(desc->joints.u8)) {
    init_view_buffer(
@@ -138,8 +133,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->joints.u8, 4, sizeof(uint8_t),
+        gfxcore, desc, (BufferView*)&desc->joints.u8, 4, GL_UNSIGNED_BYTE,
-        GL_UNSIGNED_BYTE, GL_FALSE, GFX_JOINTS_CHANNEL);
+        GL_FALSE, GFX_JOINTS_CHANNEL);
  } else if (view_is_populated(desc->joints.u16)) {
    init_view_buffer(
        gfxcore, (BufferView*)&desc->joints.u16, BufferU16, desc->buffer_usage);
@@ -147,8 +142,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->joints.u16, 4, sizeof(uint16_t),
+        gfxcore, desc, (BufferView*)&desc->joints.u16, 4, GL_UNSIGNED_SHORT,
-        GL_UNSIGNED_SHORT, GL_FALSE, GFX_JOINTS_CHANNEL);
+        GL_FALSE, GFX_JOINTS_CHANNEL);
  }
  // If weights are given as unsigned integers, then they are normalized
@@ -160,8 +155,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->weights.u8, 4, sizeof(uint8_t),
+        gfxcore, desc, (BufferView*)&desc->weights.u8, 4, GL_UNSIGNED_BYTE,
-        GL_UNSIGNED_BYTE, GL_TRUE, GFX_WEIGHTS_CHANNEL);
+        GL_TRUE, GFX_WEIGHTS_CHANNEL);
  } else if (view_is_populated(desc->weights.u16)) {
    init_view_buffer(
        gfxcore, (BufferView*)&desc->weights.u16, BufferU16,
@@ -170,8 +165,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->weights.u16, 4, sizeof(uint16_t),
+        gfxcore, desc, (BufferView*)&desc->weights.u16, 4, GL_UNSIGNED_SHORT,
-        GL_UNSIGNED_SHORT, GL_TRUE, GFX_WEIGHTS_CHANNEL);
+        GL_TRUE, GFX_WEIGHTS_CHANNEL);
  } else if (view_is_populated(desc->weights.floats)) {
    init_view_buffer(
        gfxcore, (BufferView*)&desc->weights.floats, BufferFloat,
@@ -180,8 +175,8 @@ static bool configure_vertex_attributes(GfxCore* gfxcore, GeometryDesc* desc) {
      return false;
    }
    configure_buffer(
-        gfxcore, desc, (BufferView*)&desc->weights.floats, 4, sizeof(float),
+        gfxcore, desc, (BufferView*)&desc->weights.floats, 4, GL_FLOAT,
-        GL_FLOAT, GL_FALSE, GFX_WEIGHTS_CHANNEL);
+        GL_FALSE, GFX_WEIGHTS_CHANNEL);
  }
  return true;
@@ -282,9 +277,9 @@ void gfx_update_geometry(Geometry* geometry, const GeometryDesc* desc) {
    assert(geometry->desc.positions3d.buffer);
    gfx_update_buffer(
        geometry->desc.positions3d.buffer,
-        &(BufferDataDesc){
+        &(BufferDataDesc){.vec3s = desc->positions3d.data,
-            .vec3s = desc->positions3d.data,
+                          .count =
-            .count = desc->positions3d.size_bytes / sizeof(vec3)});
+                              desc->positions3d.size_bytes / sizeof(vec3)});
  }
  // TODO: more
  else {
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..3840019 100644
--- a/gfx/src/core/shader_program.c
+++ b/src/core/shader_program.c
@@ -72,17 +72,23 @@ void gfx_deactivate_shader_program(const ShaderProgram* prog) {
  ASSERT_GL;
 }
-static void set_texture_uniform(
+static void set_int_uniform(GLuint prog, const char* name, int value) {
-    GLuint prog, const char* name, int texture_unit, const Texture* texture) {
  assert(prog != 0);
  assert(name);
-  assert(texture);
  const GLint location = glGetUniformLocation(prog, name);
  if (location >= 0) {
-    glActiveTexture(GL_TEXTURE0 + texture_unit);
+    glUniform1i(location, value);
-    glBindTexture(texture->target, texture->id);
+  }
-    glUniform1i(location, texture_unit);
+}
+static void set_float_uniform(GLuint prog, const char* name, float value) {
+  assert(prog != 0);
+  assert(name);
+  const GLint location = glGetUniformLocation(prog, name);
+  if (location >= 0) {
+    glUniform1f(location, value);
  }
 }
@@ -118,13 +124,17 @@ static void set_vec4_uniform(GLuint prog, const char* name, vec4 value) {
  }
 }
-static void set_float_uniform(GLuint prog, const char* name, float value) {
+static void set_texture_uniform(
+    GLuint prog, const char* name, int texture_unit, const Texture* texture) {
  assert(prog != 0);
  assert(name);
+  assert(texture);
  const GLint location = glGetUniformLocation(prog, name);
  if (location >= 0) {
-    glUniform1f(location, value);
+    glActiveTexture(GL_TEXTURE0 + texture_unit);
+    glBindTexture(texture->target, texture->id);
+    glUniform1i(location, texture_unit);
  }
 }
@@ -135,23 +145,30 @@ void gfx_apply_uniforms(const ShaderProgram* prog) {
  for (int i = 0; i < prog->num_uniforms; ++i) {
    const ShaderUniform* uniform = &prog->uniforms[i];
    switch (uniform->type) {
-    case UniformTexture:
+    case UniformInt:
-      set_texture_uniform(
+      set_int_uniform(prog->id, uniform->name.str, uniform->value.uniform_int);
-          prog->id, uniform->name.str, next_texture_unit,
+      break;
-          uniform->value.texture);
+    case UniformFloat:
-      next_texture_unit++;
+      set_float_uniform(
+          prog->id, uniform->name.str, uniform->value.uniform_float);
      break;
    case UniformMat4:
-      set_mat4_uniform(prog->id, uniform->name.str, &uniform->value.mat4, 1);
+      set_mat4_uniform(
+          prog->id, uniform->name.str, &uniform->value.uniform_mat4, 1);
      break;
    case UniformVec3:
-      set_vec3_uniform(prog->id, uniform->name.str, uniform->value.vec3);
+      set_vec3_uniform(
+          prog->id, uniform->name.str, uniform->value.uniform_vec3);
      break;
    case UniformVec4:
-      set_vec4_uniform(prog->id, uniform->name.str, uniform->value.vec4);
+      set_vec4_uniform(
+          prog->id, uniform->name.str, uniform->value.uniform_vec4);
      break;
-    case UniformFloat:
+    case UniformTexture:
-      set_float_uniform(prog->id, uniform->name.str, uniform->value.scalar);
+      set_texture_uniform(
+          prog->id, uniform->name.str, next_texture_unit,
+          uniform->value.texture);
+      next_texture_unit++;
      break;
    case UniformMat4Array:
      set_mat4_uniform(
@@ -179,8 +196,9 @@ static ShaderUniform* get_or_allocate_uniform(
  // Create the uniform if it does not exist.
  if (prog->num_uniforms == GFX_MAX_UNIFORMS_PER_SHADER) {
-    FAIL("Exceeded the maximum number of uniforms per shader. Please increase "
+    FAIL(
-         "this value.");
+        "Exceeded the maximum number of uniforms per shader. Please increase "
+        "this value.");
    return 0;
  }
  ShaderUniform* uniform = &prog->uniforms[prog->num_uniforms];
@@ -191,21 +209,67 @@ static ShaderUniform* get_or_allocate_uniform(
 // The functions below save the value of a uniform in the shader program. If the
 // uniform does not even exist, then there is no need to store the value.
-void gfx_set_texture_uniform(
+void gfx_set_uniform(ShaderProgram* prog, const ShaderUniform* uniform) {
-    ShaderProgram* prog, const char* name, const Texture* texture) {
+  switch (uniform->type) {
+  case UniformInt:
+    gfx_set_int_uniform(prog, uniform->name.str, uniform->value.uniform_int);
+    break;
+  case UniformFloat:
+    gfx_set_float_uniform(
+        prog, uniform->name.str, uniform->value.uniform_float);
+    break;
+  case UniformMat4:
+    gfx_set_mat4_uniform(prog, uniform->name.str, &uniform->value.uniform_mat4);
+    break;
+  case UniformVec3:
+    gfx_set_vec3_uniform(prog, uniform->name.str, uniform->value.uniform_vec3);
+    break;
+  case UniformVec4:
+    gfx_set_vec4_uniform(prog, uniform->name.str, uniform->value.uniform_vec4);
+    break;
+  case UniformTexture:
+    gfx_set_texture_uniform(prog, uniform->name.str, uniform->value.texture);
+    break;
+  case UniformMat4Array:
+    gfx_set_mat4_array_uniform(
+        prog, uniform->name.str, uniform->value.array.values,
+        uniform->value.array.count);
+    break;
+  }
+}
+void gfx_set_int_uniform(ShaderProgram* prog, const char* name, int value) {
  assert(prog);
  assert(name);
-  assert(texture);
+  // No need to store the uniform on our side if it does not exist in the
+  // program.
  const GLint location = glGetUniformLocation(prog->id, name);
  if (location < 0) {
    return;
  }
  ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
  assert(uniform);
-  uniform->name          = sstring_make(name);
+  uniform->name              = sstring_make(name);
-  uniform->type          = UniformTexture;
+  uniform->type              = UniformInt;
-  uniform->value.texture = texture;
+  uniform->value.uniform_int = value;
+}
+void gfx_set_float_uniform(ShaderProgram* prog, const char* name, float value) {
+  assert(prog);
+  assert(name);
+  // No need to store the uniform on our side if it does not exist in the
+  // program.
+  const GLint location = glGetUniformLocation(prog->id, name);
+  if (location < 0) {
+    return;
+  }
+  ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
+  assert(uniform);
+  uniform->name                = sstring_make(name);
+  uniform->type                = UniformFloat;
+  uniform->value.uniform_float = value;
 }
 void gfx_set_mat4_uniform(
@@ -220,9 +284,9 @@ void gfx_set_mat4_uniform(
  }
  ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
  assert(uniform);
-  uniform->name       = sstring_make(name);
+  uniform->name               = sstring_make(name);
-  uniform->type       = UniformMat4;
+  uniform->type               = UniformMat4;
-  uniform->value.mat4 = *mat;
+  uniform->value.uniform_mat4 = *mat;
 }
 void gfx_set_vec3_uniform(ShaderProgram* prog, const char* name, vec3 value) {
@@ -235,9 +299,9 @@ void gfx_set_vec3_uniform(ShaderProgram* prog, const char* name, vec3 value) {
  }
  ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
  assert(uniform);
-  uniform->name       = sstring_make(name);
+  uniform->name               = sstring_make(name);
-  uniform->type       = UniformVec3;
+  uniform->type               = UniformVec3;
-  uniform->value.vec3 = value;
+  uniform->value.uniform_vec3 = value;
 }
 void gfx_set_vec4_uniform(ShaderProgram* prog, const char* name, vec4 value) {
@@ -250,26 +314,26 @@ void gfx_set_vec4_uniform(ShaderProgram* prog, const char* name, vec4 value) {
  }
  ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
  assert(uniform);
-  uniform->name       = sstring_make(name);
+  uniform->name               = sstring_make(name);
-  uniform->type       = UniformVec4;
+  uniform->type               = UniformVec4;
-  uniform->value.vec4 = value;
+  uniform->value.uniform_vec4 = value;
 }
-void gfx_set_float_uniform(ShaderProgram* prog, const char* name, float value) {
+void gfx_set_texture_uniform(
+    ShaderProgram* prog, const char* name, const Texture* texture) {
  assert(prog);
  assert(name);
+  assert(texture);
-  // No need to store the uniform on our side if it does not exist in the
-  // program.
  const GLint location = glGetUniformLocation(prog->id, name);
  if (location < 0) {
    return;
  }
  ShaderUniform* uniform = get_or_allocate_uniform(prog, name);
  assert(uniform);
-  uniform->name         = sstring_make(name);
+  uniform->name          = sstring_make(name);
-  uniform->type         = UniformFloat;
+  uniform->type          = UniformTexture;
-  uniform->value.scalar = value;
+  uniform->value.texture = texture;
 }
 void gfx_set_mat4_array_uniform(
@@ -277,7 +341,7 @@ void gfx_set_mat4_array_uniform(
  assert(prog);
  assert(name);
  assert(mats);
-  
  const GLint location = glGetUniformLocation(prog->id, name);
  if (location < 0) {
    return;
diff --git a/gfx/src/core/shader_program.h b/src/core/shader_program.h
index 1443663..521118d 100644
--- a/gfx/src/core/shader_program.h
+++ b/src/core/shader_program.h
@@ -5,8 +5,6 @@
 #include "gl_util.h"
-#include <math/fwd.h>
 #include <stdbool.h>
 typedef struct Texture Texture;
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..bf713ca 100644
--- a/gfx/src/gfx.c
+++ b/src/gfx.c
@@ -2,20 +2,20 @@
 #include "asset/asset_cache.h"
 #include "core/core_impl.h"
-#include "renderer/imm_renderer_impl.h"
+#include "memory.h"
-#include "renderer/renderer_impl.h"
+#include "render/imm_impl.h"
-#include "scene/scene_memory.h"
+#include "render/llr_impl.h"
+#include "render/renderer_impl.h"
-#include <log/log.h>
 #include <assert.h>
 #include <stdlib.h>
 typedef struct Gfx {
-  AssetCache  asset_cache;
+  AssetCache asset_cache;
-  GfxCore     gfxcore;
+  GfxCore    gfxcore;
-  Renderer    renderer;
+  LLR        llr;
-  ImmRenderer imm_renderer;
+  Imm        imm;
+  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, &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);
+  gfx_renderer_destroy(&(*gfx)->renderer);
-  imm_renderer_destroy(&(*gfx)->imm_renderer);
+  gfx_imm_destroy(&(*gfx)->imm);
+  gfx_llr_destroy(&(*gfx)->llr);
  gfx_del_gfxcore(&(*gfx)->gfxcore);
  free(*gfx);
  *gfx = 0;
@@ -62,9 +67,14 @@ Renderer* gfx_get_renderer(Gfx* gfx) {
  return &gfx->renderer;
 }
-ImmRenderer* gfx_get_imm_renderer(Gfx* gfx) {
+Imm* gfx_get_imm(Gfx* gfx) {
+  assert(gfx);
+  return &gfx->imm;
+}
+LLR* gfx_get_llr(Gfx* gfx) {
  assert(gfx);
-  return &gfx->imm_renderer;
+  return &gfx->llr;
 }
 AssetCache* gfx_get_asset_cache(Gfx* gfx) {
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/scene_memory.c b/src/memory.c
index 85c27e7..754f04d 100644
--- a/gfx/src/scene/scene_memory.c
+++ b/src/memory.c
@@ -1,22 +1,23 @@
-#include "scene_memory.h"
+#include "memory.h"
+#include <gfx/scene.h>
 #include <gfx/sizes.h>
 #include "animation_impl.h"
-#include "camera_impl.h"
+#include "scene/light_impl.h"
-#include "light_impl.h"
+#include "scene/material_impl.h"
-#include "material_impl.h"
+#include "scene/mesh_impl.h"
-#include "mesh_impl.h"
+#include "scene/model_impl.h"
-#include "model_impl.h"
+#include "scene/node_impl.h"
-#include "node_impl.h"
+#include "scene/object_impl.h"
-#include "object_impl.h"
+#include "scene/scene_impl.h"
-#include "scene_impl.h"
+#include <log/log.h>
 #include <mempool.h>
 DEF_MEMPOOL(anima_pool, Anima, GFX_MAX_NUM_ANIMAS)
 DEF_MEMPOOL(animation_pool, Animation, GFX_MAX_NUM_ANIMATIONS)
-DEF_MEMPOOL(camera_pool, SceneCamera, GFX_MAX_NUM_CAMERAS)
+DEF_MEMPOOL(camera_pool, Camera, GFX_MAX_NUM_CAMERAS)
 DEF_MEMPOOL(light_pool, Light, GFX_MAX_NUM_LIGHTS)
 DEF_MEMPOOL(material_pool, Material, GFX_MAX_NUM_MATERIALS)
 DEF_MEMPOOL(mesh_pool, Mesh, GFX_MAX_NUM_MESHES)
@@ -47,16 +48,17 @@ typedef struct SceneMemory {
 static SceneMemory mem;
-#define ALLOC_DUMMY(POOL)                               \
+#define ALLOC_DUMMY(POOL)                                  \
-  {                                                     \
+  {                                                        \
-    const void* object = mempool_alloc(POOL);           \
+    const void* object = mempool_alloc(POOL);              \
-    assert(mempool_get_block_index(POOL, object) == 0); \
+    (void)object; /* Silence warning in release builds. */ \
+    assert(mempool_get_block_index(POOL, object) == 0);    \
  }
 #define PLURAL(name)    name##s
 #define MEM_FIELD(name) mem.PLURAL(name)
-void scene_mem_init() {
+void scene_mem_init(void) {
  mempool_make(&mem.animas);
  mempool_make(&mem.animations);
  mempool_make(&mem.cameras);
@@ -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);
@@ -86,17 +88,44 @@ void scene_mem_init() {
  ALLOC_DUMMY(&mem.skeletons);
 }
-void scene_mem_destroy() {
+void scene_mem_destroy(void) {
  // 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)                      \
+#define DESTROY(NAME)                      \
-  mempool_foreach(&MEM_FIELD(name), obj, { \
+  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,25 +148,25 @@ 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(void) { 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) {               \
+  NAMED_INDEX(NAME) mem_get_##NAME##_index(const TYPE* obj) {               \
-    return (NAMED_INDEX(name)){                                             \
+    return (NAMED_INDEX(NAME)){                                             \
-        .val = mempool_get_block_index(&MEM_FIELD(name), obj)};             \
+        .val = mempool_get_block_index(&MEM_FIELD(NAME), obj)};             \
  }
 DEF_MEMORY(anima, Anima)
 DEF_MEMORY(animation, Animation)
-DEF_MEMORY(camera, SceneCamera)
+DEF_MEMORY(camera, Camera)
 DEF_MEMORY(light, Light)
 DEF_MEMORY(material, Material)
 DEF_MEMORY(mesh, Mesh)
diff --git a/gfx/src/scene/scene_memory.h b/src/memory.h
index d175cba..bfbee66 100644
--- a/gfx/src/scene/scene_memory.h
+++ b/src/memory.h
@@ -3,21 +3,23 @@
 #include "types.h"
+typedef struct Camera Camera;
 /// Initialize scene memory.
 ///
 /// The scene memory guarantees that every object maps to an index different
 /// than 0. This way, 0 can be used as a special index to denote "no value".
-void scene_mem_init();
+void scene_mem_init(void);
 /// Destroy the scene memory and all allocated objects.
-void scene_mem_destroy();
+void scene_mem_destroy(void);
 #define NAMED_INDEX(name) name##_idx
 #define DECL_MEMORY(name, type)                \
  typedef struct type type;                    \
  /* xyz* mem_alloc_xyz() */                   \
-  type* mem_alloc_##name();                    \
+  type* mem_alloc_##name(void);                \
  /* mem_free_xyz(xyz**) */                    \
  void mem_free_##name(type**);                \
  /* xyz* mem_get_xyz(xyz_idx); */             \
@@ -27,7 +29,7 @@ void scene_mem_destroy();
 DECL_MEMORY(anima, Anima)
 DECL_MEMORY(animation, Animation)
-DECL_MEMORY(camera, SceneCamera)
+DECL_MEMORY(camera, Camera)
 DECL_MEMORY(light, Light)
 DECL_MEMORY(material, Material)
 DECL_MEMORY(mesh, Mesh)
diff --git a/src/render/imm.c b/src/render/imm.c
new file mode 100644
index 0000000..7ab8d62
--- /dev/null
+++ b/src/render/imm.c
@@ -0,0 +1,194 @@
+#include "imm_impl.h"
+#include <gfx/core.h>
+#include <gfx/render/imm.h>
+#include <gfx/render/llr.h>
+#include <gfx/util/shader.h>
+#include <math/aabb3.h>
+#include <assert.h>
+#include <string.h> // memcpy
+bool gfx_imm_make(Imm* 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),
+                                                  .count      = num_triangle_verts}
+  });
+  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(Imm* 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(Imm* 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(Imm* 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(Imm* 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(
+    Imm* 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(Imm* renderer, const vec3 verts[3]) {
+  gfx_imm_draw_triangles(renderer, verts, 1);
+}
+void gfx_imm_draw_aabb2(Imm* 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(Imm* 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(Imm* 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(Imm* 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/render/imm_impl.h
index 5ece354..d87b910 100644
--- a/gfx/src/renderer/imm_renderer_impl.h
+++ b/src/render/imm_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.
-typedef struct ImmRenderer {
+/// TODO: Flush the buffer when it reaches its maximum size to remove this
-  GfxCore*       gfxcore;
+///  constraint.
-  ShaderProgram* shader;
+typedef struct Imm {
+  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];
+  vec3 triangle_verts[GFX_IMM_MAX_NUM_TRIANGLES * 3];
-  // Matrix stack contains pre-multiplied matrices.
+} Imm;
-  // 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;
-} ImmRenderer;
 /// Create a new immediate mode renderer.
-bool imm_renderer_make(ImmRenderer*, GfxCore*);
+bool gfx_imm_make(Imm*, GfxCore*, LLR*);
 /// Destroy the immediate mode renderer.
-void imm_renderer_destroy(ImmRenderer*);
+void gfx_imm_destroy(Imm*);
-/// Flush draw commands.
-void imm_renderer_flush(ImmRenderer*);
diff --git a/src/render/llr.c b/src/render/llr.c
new file mode 100644
index 0000000..752b65b
--- /dev/null
+++ b/src/render/llr.c
@@ -0,0 +1,441 @@
+#include "llr_impl.h"
+#include "animation_impl.h"
+#include "scene/light_impl.h"
+#include "scene/material_impl.h"
+#include "scene/mesh_impl.h"
+#include "scene/node_impl.h"
+#include <gfx/core.h>
+#include <gfx/util/ibl.h>
+#include <cassert.h>
+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;
+/// Activate the material.
+///
+/// This configures the shader uniforms that are specific to the material.
+static void material_activate(ShaderProgram* shader, const Material* material) {
+  assert(material);
+  for (int i = 0; i < material->num_uniforms; ++i) {
+    const ShaderUniform* uniform = &material->uniforms[i];
+    gfx_set_uniform(shader, uniform);
+  }
+  if (material->alpha_mode != Opaque) {
+    gfx_set_uniform(
+        shader, &(ShaderUniform){.name              = sstring_make("AlphaMode"),
+                                 .type              = UniformInt,
+                                 .value.uniform_int = material->alpha_mode});
+  }
+  if (material->alpha_mode == Mask) {
+    gfx_set_uniform(
+        shader,
+        &(ShaderUniform){.name                = sstring_make("AlphaCutoff"),
+                         .type                = UniformFloat,
+                         .value.uniform_float = material->alpha_cutoff});
+  }
+}
+/// 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;
+    // Geometry may be rendered without a material.
+    if (renderer->material) {
+      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_projection_matrix(LLR* renderer, const mat4* projection) {
+  assert(renderer);
+  renderer->projection     = *projection;
+  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/render/llr_impl.h b/src/render/llr_impl.h
new file mode 100644
index 0000000..9d70843
--- /dev/null
+++ b/src/render/llr_impl.h
@@ -0,0 +1,85 @@
+#pragma once
+#include <gfx/render/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 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/src/render/renderer.c b/src/render/renderer.c
new file mode 100644
index 0000000..a9d9bef
--- /dev/null
+++ b/src/render/renderer.c
@@ -0,0 +1,282 @@
+#include "renderer_impl.h"
+#include "animation_impl.h"
+#include "llr_impl.h"
+#include "memory.h"
+#include "scene/material_impl.h"
+#include "scene/mesh_impl.h"
+#include "scene/model_impl.h"
+#include "scene/node_impl.h"
+#include "scene/object_impl.h"
+#include <gfx/core.h>
+#include <gfx/render/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;
+  RenderSceneFilter filter;
+} 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;
+      }
+      // Filter out by material.
+      const Material* material = mesh->material;
+      if (material) {
+        const AlphaMode mode = material->alpha_mode;
+        switch (state->filter) {
+        case RenderOpaqueAndAlphaMasked:
+          if (mode == Blend) {
+            continue;
+          }
+          break;
+        case RenderTransparent:
+          if (mode != Blend) {
+            continue;
+          }
+          break;
+        }
+      }
+      // 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 Camera*  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);
+  gfx_llr_set_aspect(renderer->llr, aspect);
+  // TODO: Render Opaque and Mask alpha-mode materials first, then Blend ones.
+  // TODO: I'm not sure if this belongs to the scene renderer per se, or if it
+  //  is something that should be driven from the outside. Specifically, the
+  //  caller could pass in a filter that determines what objects to render. The
+  //  filter could include alpha mode.
+  //  This caller would be some component that understands render passes and
+  //  potentially renders the scene multiple times as needed. For example, a
+  //  depth-prepass, followed by G-buffer, followed by some post-processing,
+  //  etc. Rename this renderer to scene_renderer?
+  // TODO: When rendering transparent geometry, we need to turn off depth
+  //  writes.
+  // Opaque.
+  state.filter = RenderOpaqueAndAlphaMasked;
+  draw_recursively(&state, mat4_id(), gfx_get_scene_root(scene));
+  // Transparent.
+  state.filter = RenderTransparent;
+  draw_recursively(&state, mat4_id(), gfx_get_scene_root(scene));
+}
+static void update_rec(SceneNode* node, const Camera* 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);
+  }
+}
+// TODO: Move this outside the renderer.
+void gfx_update(Scene* scene, const Camera* camera, R t) {
+  assert(scene);
+  assert(camera);
+  SceneNode* node = gfx_get_scene_root_mut(scene);
+  update_rec(node, camera, t);
+}
diff --git a/gfx/src/renderer/renderer_impl.h b/src/render/renderer_impl.h
index fc14dcb..160ff52 100644
--- a/gfx/src/renderer/renderer_impl.h
+++ b/src/render/renderer_impl.h
@@ -1,17 +1,15 @@
 #pragma once
-#include <gfx/renderer.h>
+#include <gfx/render/renderer.h>
 #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;
+  LLR*     llr;
-  Texture* brdf_integration_map;
  struct {
    ShaderProgram* debug;
    ShaderProgram* normals;
@@ -21,7 +19,7 @@ typedef struct Renderer {
 } Renderer;
 /// Create a new renderer.
-bool renderer_make(Renderer*, GfxCore*);
+bool gfx_renderer_make(Renderer*, LLR*, GfxCore*);
 /// Destroy the renderer.
-void renderer_destroy(Renderer*);
+void gfx_renderer_destroy(Renderer*);
diff --git a/src/scene/camera.c b/src/scene/camera.c
new file mode 100644
index 0000000..fcfc496
--- /dev/null
+++ b/src/scene/camera.c
@@ -0,0 +1,18 @@
+#include <gfx/scene.h>
+#include "memory.h"
+#include <assert.h>
+#include <math/camera.h>
+Camera* gfx_make_camera(void) {
+  Camera* camera = mem_alloc_camera();
+  return camera;
+}
+void gfx_destroy_camera(Camera** camera) {
+  assert(camera);
+  if (*camera) {
+    mem_free_camera(camera);
+  }
+}
diff --git a/gfx/src/scene/light.c b/src/scene/light.c
index adbec8d..4233330 100644
--- a/gfx/src/scene/light.c
+++ b/src/scene/light.c
@@ -1,8 +1,8 @@
 #include "light_impl.h"
-#include "node_impl.h"
+#include "memory.h"
-#include "scene_memory.h"
+#include <cassert.h>
 #include <error.h>
 static void make_environment_light(
@@ -34,9 +34,6 @@ Light* gfx_make_light(const LightDesc* desc) {
 void gfx_destroy_light(Light** light) {
  assert(light);
  if (*light) {
-    if ((*light)->parent.val) {
-      gfx_del_node((*light)->parent);
-    }
    mem_free_light(light);
  }
 }
diff --git a/gfx/src/scene/light_impl.h b/src/scene/light_impl.h
index 1aa0bb4..3191a50 100644
--- a/gfx/src/scene/light_impl.h
+++ b/src/scene/light_impl.h
@@ -1,10 +1,6 @@
 #pragma once
-#include <gfx/scene/light.h>
+#include <gfx/scene.h>
-#include "types.h"
-typedef struct Texture Texture;
 /// An environment light.
 typedef struct EnvironmentLight {
@@ -12,7 +8,7 @@ typedef struct EnvironmentLight {
  const Texture* irradiance_map;              // Renderer implementation.
  const Texture* prefiltered_environment_map; // Renderer implementation.
  int max_reflection_lod; // Mandatory when prefiltered_environment_map is
-                          // given.
+  // given.
 } EnvironmentLight;
 /// A scene light.
@@ -21,5 +17,4 @@ typedef struct Light {
  union {
    EnvironmentLight environment;
  };
-  node_idx parent; // Parent SceneNode.
 } Light;
diff --git a/src/scene/material.c b/src/scene/material.c
new file mode 100644
index 0000000..9fe6c1b
--- /dev/null
+++ b/src/scene/material.c
@@ -0,0 +1,24 @@
+#include "material_impl.h"
+#include "memory.h"
+static void material_make(Material* material, const MaterialDesc* desc) {
+  assert(material);
+  assert(desc);
+  assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
+  material->alpha_mode   = desc->alpha_mode;
+  material->alpha_cutoff = desc->alpha_cutoff;
+  material->num_uniforms = (int8_t)desc->num_uniforms;
+  for (int i = 0; i < desc->num_uniforms; ++i) {
+    material->uniforms[i] = desc->uniforms[i];
+  }
+}
+Material* gfx_make_material(const MaterialDesc* desc) {
+  assert(desc);
+  Material* material = mem_alloc_material();
+  material_make(material, desc);
+  return material;
+}
+void gfx_destroy_material(Material** material) { mem_free_material(material); }
diff --git a/src/scene/material_impl.h b/src/scene/material_impl.h
new file mode 100644
index 0000000..488ffc7
--- /dev/null
+++ b/src/scene/material_impl.h
@@ -0,0 +1,13 @@
+#pragma once
+#include <gfx/scene.h>
+#include <gfx/sizes.h>
+typedef struct ShaderProgram ShaderProgram;
+typedef struct Material {
+  AlphaMode     alpha_mode;
+  float         alpha_cutoff;
+  int8_t        num_uniforms;
+  ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
+} Material;
diff --git a/gfx/src/scene/mesh.c b/src/scene/mesh.c
index 1a93bed..770c3fb 100644
--- a/gfx/src/scene/mesh.c
+++ b/src/scene/mesh.c
@@ -1,8 +1,10 @@
 #include "mesh_impl.h"
-#include "scene_memory.h"
+#include <gfx/scene.h>
-#include <assert.h>
+#include "memory.h"
+#include <cassert.h>
 static void mesh_make(Mesh* mesh, const MeshDesc* desc) {
  assert(mesh);
diff --git a/src/scene/mesh_impl.h b/src/scene/mesh_impl.h
new file mode 100644
index 0000000..c7e2211
--- /dev/null
+++ b/src/scene/mesh_impl.h
@@ -0,0 +1,11 @@
+#pragma once
+typedef struct Geometry      Geometry;
+typedef struct Material      Material;
+typedef struct ShaderProgram ShaderProgram;
+typedef struct Mesh {
+  const Geometry* geometry;
+  const Material* material;
+  ShaderProgram*  shader; // TODO: Move this back to Material?
+} Mesh;
diff --git a/gfx/src/scene/model.c b/src/scene/model.c
index cc41a9a..1bd0112 100644
--- a/gfx/src/scene/model.c
+++ b/src/scene/model.c
@@ -1,8 +1,8 @@
 #include "model_impl.h"
-#include <gfx/scene/node.h>
+#include <gfx/scene.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..72cd0ab 100644
--- a/gfx/src/scene/model_impl.h
+++ b/src/scene/model_impl.h
@@ -1,13 +1,12 @@
 #pragma once
-#include <gfx/scene/model.h>
+#include <gfx/scene.h>
-#include "scene_memory.h"
+#include "memory.h"
 /// Model.
 typedef struct Model {
  node_idx root;
-  node_idx parent; // Parent SceneNode.
 } Model;
 /// Create a new model.
diff --git a/gfx/src/scene/node.c b/src/scene/node.c
index 67ce93c..0004d27 100644
--- a/gfx/src/scene/node.c
+++ b/src/scene/node.c
@@ -1,15 +1,15 @@
 #include "node_impl.h"
 #include "animation_impl.h"
-#include "camera_impl.h"
+#include "memory.h"
-#include "light_impl.h"
-#include "model_impl.h"
 #include "object_impl.h"
+#include "render/llr_impl.h"
 #include "scene_graph.h"
-#include "scene_memory.h"
 #include "gfx_assert.h"
+#include <gfx/scene.h>
 #include <cstring.h>
 #include <log/log.h>
@@ -19,7 +19,7 @@ static void scene_node_make(SceneNode* node) {
  node->transform = mat4_id();
 }
-SceneNode* gfx_make_node() {
+SceneNode* gfx_make_node(void) {
  SceneNode* node = mem_alloc_node();
  scene_node_make(node);
  return node;
@@ -30,16 +30,14 @@ SceneNode* gfx_make_anima_node(Anima* anima) {
  SceneNode* node = gfx_make_node();
  node->type      = AnimaNode;
  node->anima     = mem_get_anima_index(anima);
-  anima->parent   = mem_get_node_index(node);
  return node;
 }
-SceneNode* gfx_make_camera_node(SceneCamera* camera) {
+SceneNode* gfx_make_camera_node(Camera* camera) {
  assert(camera);
  SceneNode* node = gfx_make_node();
  node->type      = CameraNode;
  node->camera    = mem_get_camera_index(camera);
-  camera->parent  = mem_get_node_index(node);
  return node;
 }
@@ -48,7 +46,6 @@ SceneNode* gfx_make_light_node(Light* light) {
  SceneNode* node = gfx_make_node();
  node->type      = LightNode;
  node->light     = mem_get_light_index(light);
-  light->parent   = mem_get_node_index(node);
  return node;
 }
@@ -57,7 +54,6 @@ SceneNode* gfx_make_model_node(Model* model) {
  SceneNode* node = gfx_make_node();
  node->type      = ModelNode;
  node->model     = mem_get_model_index(model);
-  model->parent   = mem_get_node_index(node);
  return node;
 }
@@ -66,7 +62,6 @@ SceneNode* gfx_make_object_node(SceneObject* object) {
  SceneNode* node = gfx_make_node();
  node->type      = ObjectNode;
  node->object    = mem_get_object_index(object);
-  object->parent  = mem_get_node_index(node);
  return node;
 }
@@ -74,24 +69,19 @@ SceneNode* gfx_make_object_node(SceneObject* object) {
 static void free_node_resource(SceneNode* node) {
  assert(node);
-  // Set the resource's parent node back to 0 to avoid a recursive call into
-  // gfx_del_node().
  switch (node->type) {
  case AnimaNode: {
-    Anima* anima      = mem_get_anima(node->anima);
+    Anima* anima = mem_get_anima(node->anima);
-    anima->parent.val = 0;
    gfx_destroy_anima(&anima);
    return;
  }
  case CameraNode: {
-    SceneCamera* camera = mem_get_camera(node->camera);
+    Camera* camera = mem_get_camera(node->camera);
-    camera->parent.val  = 0;
    gfx_destroy_camera(&camera);
    return;
  }
  case LightNode: {
-    Light* light      = mem_get_light(node->light);
+    Light* light = mem_get_light(node->light);
-    light->parent.val = 0;
    gfx_destroy_light(&light);
    return;
  }
@@ -100,63 +90,16 @@ static void free_node_resource(SceneNode* node) {
  }
  case ObjectNode: {
    SceneObject* object = mem_get_object(node->object);
-    object->parent.val  = 0;
    gfx_destroy_object(&object);
    return;
  }
-  case LogicalNode:
+  case LogicalNode: {
    return; // Logical nodes have no resource.
  }
+  }
  FAIL("unhandled node type");
 }
-void gfx_construct_anima_node(SceneNode* node, Anima* anima) {
-  assert(node);
-  assert(anima);
-  free_node_resource(node);
-  node->type    = AnimaNode;
-  node->anima   = mem_get_anima_index(anima);
-  anima->parent = mem_get_node_index(node);
-}
-void gfx_construct_camera_node(SceneNode* node, SceneCamera* camera) {
-  assert(node);
-  assert(camera);
-  free_node_resource(node);
-  node->type     = CameraNode;
-  node->camera   = mem_get_camera_index(camera);
-  camera->parent = mem_get_node_index(node);
-}
-// TODO: Add a common helper function between each gfx_make_xyz_node() and
-//  gfx_construct_xyz_node() pair.
-void gfx_construct_light_node(SceneNode* node, Light* light) {
-  assert(node);
-  assert(light);
-  free_node_resource(node);
-  node->type    = LightNode;
-  node->light   = mem_get_light_index(light);
-  light->parent = mem_get_node_index(node);
-}
-void gfx_construct_model_node(SceneNode* node, Model* model) {
-  assert(node);
-  assert(model);
-  free_node_resource(node);
-  node->type    = ModelNode;
-  node->model   = mem_get_model_index(model);
-  model->parent = mem_get_node_index(node);
-}
-void gfx_construct_object_node(SceneNode* node, SceneObject* object) {
-  assert(node);
-  assert(object);
-  free_node_resource(node);
-  node->type     = ObjectNode;
-  node->object   = mem_get_object_index(object);
-  object->parent = mem_get_node_index(node);
-}
 static void destroy_node_rec(SceneNode* node) {
  assert(node);
@@ -217,11 +160,11 @@ Anima* gfx_get_node_anima_mut(SceneNode* node) {
  NODE_GET(node, anima, AnimaNode);
 }
-const SceneCamera* gfx_get_node_camera(const SceneNode* node) {
+const Camera* gfx_get_node_camera(const SceneNode* node) {
  NODE_GET(node, camera, CameraNode);
 }
-SceneCamera* gfx_get_node_camera_mut(SceneNode* node) {
+Camera* gfx_get_node_camera_mut(SceneNode* node) {
  NODE_GET(node, camera, CameraNode);
 }
diff --git a/gfx/src/scene/node_impl.h b/src/scene/node_impl.h
index c79f252..9e65588 100644
--- a/gfx/src/scene/node_impl.h
+++ b/src/scene/node_impl.h
@@ -1,10 +1,10 @@
 #pragma once
-#include <gfx/scene/node.h>
+#include <gfx/scene.h>
-#include "types.h"
+#include "../types.h"
-#include <cstring.h>
+#include <math/camera.h>
 #include <math/mat4.h>
 /// Scene node.
diff --git a/gfx/src/scene/object.c b/src/scene/object.c
index e8e3ee6..ac86b39 100644
--- a/gfx/src/scene/object.c
+++ b/src/scene/object.c
@@ -2,9 +2,10 @@
 #include <gfx/core.h>
-#include "mesh_impl.h"
+#include "memory.h"
-#include "node_impl.h"
+#include "render/llr_impl.h"
-#include "scene_memory.h"
+#include "scene/mesh_impl.h"
+#include "scene/node_impl.h"
 #include <assert.h>
@@ -57,11 +58,7 @@ SceneObject* gfx_make_object(const ObjectDesc* desc) {
 void gfx_destroy_object(SceneObject** object) {
  assert(object);
  if (*object) {
-    if ((*object)->parent.val) {
-      gfx_del_node((*object)->parent);
-    }
    mem_free_object(object);
  }
 }
diff --git a/gfx/src/scene/object_impl.h b/src/scene/object_impl.h
index 88f8e31..345d615 100644
--- a/gfx/src/scene/object_impl.h
+++ b/src/scene/object_impl.h
@@ -1,10 +1,8 @@
 #pragma once
-#include <gfx/scene/object.h>
+#include <gfx/scene.h>
-#include "types.h"
+#include "../types.h"
-#include <math/mat4.h>
 typedef struct MeshLink {
  mesh_idx      mesh;
@@ -21,6 +19,5 @@ 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;
 } SceneObject;
diff --git a/src/scene/scene.c b/src/scene/scene.c
new file mode 100644
index 0000000..52ddb58
--- /dev/null
+++ b/src/scene/scene.c
@@ -0,0 +1,31 @@
+#include "scene_impl.h"
+#include "memory.h"
+#include "node_impl.h"
+#include <assert.h>
+Scene* gfx_make_scene(void) {
+  Scene* scene = mem_alloc_scene();
+  scene->root  = mem_get_node_index(gfx_make_node());
+  return scene;
+}
+void gfx_destroy_scene(Scene** scene) {
+  assert(scene);
+  if (*scene) {
+    SceneNode* node = mem_get_node((*scene)->root);
+    gfx_destroy_node(&node);
+    mem_free_scene(scene);
+  }
+}
+const SceneNode* gfx_get_scene_root(const Scene* scene) {
+  assert(scene);
+  return mem_get_node(scene->root);
+}
+SceneNode* gfx_get_scene_root_mut(Scene* scene) {
+  assert(scene);
+  return (SceneNode*)gfx_get_scene_root(scene);
+}
diff --git a/gfx/src/scene/scene_graph.h b/src/scene/scene_graph.h
index a26f828..36c3a98 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)                    \
+#define MEM_GET(INDEX)                  \
-  _Generic((INDEX), camera_idx            \
+  _Generic(                             \
-           : mem_get_camera, material_idx \
+      (INDEX),                          \
-           : mem_get_material, mesh_idx   \
+      camera_idx: mem_get_camera,       \
-           : mem_get_mesh, mesh_link_idx  \
+      material_idx: mem_get_material,   \
-           : mem_get_mesh_link, node_idx  \
+      mesh_idx: mem_get_mesh,           \
-           : mem_get_node, object_idx     \
+      mesh_link_idx: mem_get_mesh_link, \
-           : mem_get_object, scene_idx    \
+      node_idx: mem_get_node,           \
-           : mem_get_scene)(INDEX)
+      object_idx: mem_get_object,       \
+      scene_idx: mem_get_scene)(INDEX)
-#define MEM_GET_INDEX(ITEM)                       \
+#define MEM_GET_INDEX(ITEM)                \
-  _Generic((ITEM), SceneCamera *                  \
+  _Generic(                                \
-           : mem_get_camera_index, Material *     \
+      (ITEM),                              \
-           : mem_get_material_index, Mesh *       \
+      Camera *: mem_get_camera_index,      \
-           : mem_get_mesh_index, MeshLink *       \
+      Material *: mem_get_material_index,  \
-           : mem_get_mesh_link_index, SceneNode * \
+      Mesh *: mem_get_mesh_index,          \
-           : mem_get_node_index, SceneObject *    \
+      MeshLink *: mem_get_mesh_link_index, \
-           : mem_get_object_index, Scene *        \
+      SceneNode *: mem_get_node_index,     \
-           : mem_get_scene_index)(ITEM)
+      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/src/scene/scene_impl.h b/src/scene/scene_impl.h
new file mode 100644
index 0000000..ad2e892
--- /dev/null
+++ b/src/scene/scene_impl.h
@@ -0,0 +1,9 @@
+#pragma once
+#include <gfx/scene.h>
+#include "../types.h"
+typedef struct Scene {
+  node_idx root;
+} Scene;
diff --git a/gfx/src/scene/types.h b/src/types.h
index d0ffc41..d0ffc41 100644
--- a/gfx/src/scene/types.h
+++ b/src/types.h
diff --git a/gfx/src/util/geometry.c b/src/util/geometry.c
index afe0109..2ea0c82 100644
--- a/gfx/src/util/geometry.c
+++ b/src/util/geometry.c
@@ -17,12 +17,13 @@ static void make_quad_01_positions(vec2 positions[4]) {
 }
 static GeometryDesc make_quad_desc(vec2 positions[4]) {
-  GeometryDesc desc           = (GeometryDesc){0};
+  return (GeometryDesc){
-  desc.positions2d.data       = positions;
+      .positions2d = (BufferView2d){.data       = positions,
-  desc.positions2d.size_bytes = 4 * sizeof(vec2);
+                                    .size_bytes = 4 * sizeof(vec2),
-  desc.num_verts              = 4;
+                                    .count      = 4},
-  desc.type                   = TriangleStrip;
+      .num_verts   = 4,
-  return desc;
+      .type        = TriangleStrip
+  };
 }
 Geometry* gfx_make_quad_11(GfxCore* gfxcore) {
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..f4561f2 100644
--- a/gfx/src/util/skyquad.c
+++ b/src/util/skyquad.c
@@ -1,18 +1,11 @@
 #include <gfx/util/skyquad.h>
 #include <gfx/core.h>
-#include <gfx/gfx.h>
+#include <gfx/render/llr.h>
-#include <gfx/scene/light.h>
+#include <gfx/scene.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/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 +29,9 @@ SceneObject* gfx_make_skyquad(GfxCore* gfxcore, const Texture* texture) {
  }
  MaterialDesc material_desc = (MaterialDesc){0};
-  material_desc.uniforms[0]  = (ShaderUniform){
+  material_desc.uniforms[0]  = (ShaderUniform){.type          = UniformTexture,
-       .type          = UniformTexture,
+                                               .value.texture = texture,
-       .value.texture = texture,
+                                               .name = sstring_make("Skyquad")};
-       .name          = sstring_make("Skyquad")};
  material_desc.num_uniforms = 1;
  material                   = gfx_make_material(&material_desc);
  if (!material) {