18 files changed, 909 insertions, 0 deletions

diff --git a/gfx/src/scene/camera.c b/gfx/src/scene/camera.c
new file mode 100644
index 0000000..df161c2
--- /dev/null
+++ b/gfx/src/scene/camera.c
@@ -0,0 +1,42 @@
+#include "camera_impl.h"
+
+#include "node_impl.h"
+#include "scene_memory.h"
+
+#include <assert.h>
+
+static void scene_camera_make(SceneCamera* camera) {
+  assert(camera);
+  camera->camera =
+      camera_perspective(/*fovy=*/90.0 * TO_RAD, /*aspect=*/16.0 / 9.0,
+                         /*near=*/0.1, /*far=*/1000);
+}
+
+SceneCamera* gfx_make_camera() {
+  SceneCamera* camera = mem_alloc_camera();
+  if (!camera) {
+    return 0;
+  }
+  scene_camera_make(camera);
+  return camera;
+}
+
+void gfx_destroy_camera(SceneCamera** camera) {
+  assert(camera);
+  assert(*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
new file mode 100644
index 0000000..20c3890
--- /dev/null
+++ b/gfx/src/scene/camera_impl.h
@@ -0,0 +1,12 @@
+#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/light.c b/gfx/src/scene/light.c
new file mode 100644
index 0000000..2ca1a01
--- /dev/null
+++ b/gfx/src/scene/light.c
@@ -0,0 +1,45 @@
+#include "light_impl.h"
+
+#include "node_impl.h"
+#include "scene_memory.h"
+
+#include <gfx/error.h>
+
+static void make_environment_light(Light* light,
+                                   const EnvironmentLightDesc* desc) {
+  assert(light);
+  assert(desc);
+
+  light->type = EnvironmentLightType;
+  light->environment.environment_map = desc->environment_map;
+}
+
+Light* gfx_make_light(const LightDesc* desc) {
+  assert(desc);
+
+  Light* light = mem_alloc_light();
+  if (!light) {
+    return 0;
+  }
+
+  switch (desc->type) {
+  case EnvironmentLightType:
+    make_environment_light(light, &desc->light.environment);
+    break;
+  default:
+    gfx_set_error("Unhandled light type");
+    gfx_destroy_light(&light);
+    return 0;
+  }
+
+  return light;
+}
+
+void gfx_destroy_light(Light** light) {
+  assert(light);
+  assert(*light);
+  if ((*light)->parent.val) {
+    gfx_del_node((*light)->parent);
+  }
+  mem_free_light(light);
+}
diff --git a/gfx/src/scene/light_impl.h b/gfx/src/scene/light_impl.h
new file mode 100644
index 0000000..1aa0bb4
--- /dev/null
+++ b/gfx/src/scene/light_impl.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <gfx/scene/light.h>
+
+#include "types.h"
+
+typedef struct Texture Texture;
+
+/// An environment light.
+typedef struct EnvironmentLight {
+  const Texture* environment_map;
+  const Texture* irradiance_map;              // Renderer implementation.
+  const Texture* prefiltered_environment_map; // Renderer implementation.
+  int max_reflection_lod; // Mandatory when prefiltered_environment_map is
+                          // given.
+} EnvironmentLight;
+
+/// A scene light.
+typedef struct Light {
+  LightType type;
+  union {
+    EnvironmentLight environment;
+  };
+  node_idx parent; // Parent SceneNode.
+} Light;
diff --git a/gfx/src/scene/material.c b/gfx/src/scene/material.c
new file mode 100644
index 0000000..d44746a
--- /dev/null
+++ b/gfx/src/scene/material.c
@@ -0,0 +1,57 @@
+#include "material_impl.h"
+
+#include "scene_memory.h"
+
+#include <gfx/render_backend.h>
+
+static void material_make(Material* material, const MaterialDesc* desc) {
+  assert(material);
+  assert(desc);
+  assert(desc->num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
+  material->shader = desc->shader;
+  material->num_uniforms = desc->num_uniforms;
+  for (int i = 0; i < desc->num_uniforms; ++i) {
+    material->uniforms[i] = desc->uniforms[i];
+  }
+}
+
+Material* gfx_make_material(const MaterialDesc* desc) {
+  assert(desc);
+  Material* material = mem_alloc_material();
+  if (!material) {
+    return 0;
+  }
+  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;
+  }
+}
+
+void material_activate(const Material* material) {
+  assert(material);
+  gfx_activate_shader_program(material->shader);
+  for (int i = 0; i < material->num_uniforms; ++i) {
+    const ShaderUniform* uniform = &material->uniforms[i];
+    set_uniform(material->shader, uniform);
+  }
+}
diff --git a/gfx/src/scene/material_impl.h b/gfx/src/scene/material_impl.h
new file mode 100644
index 0000000..c680ccf
--- /dev/null
+++ b/gfx/src/scene/material_impl.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <gfx/scene/material.h>
+
+typedef struct ShaderProgram ShaderProgram;
+
+typedef struct Material {
+  ShaderProgram* shader;
+  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(const Material* material);
diff --git a/gfx/src/scene/mesh.c b/gfx/src/scene/mesh.c
new file mode 100644
index 0000000..722eae7
--- /dev/null
+++ b/gfx/src/scene/mesh.c
@@ -0,0 +1,25 @@
+#include "mesh_impl.h"
+
+#include "scene_memory.h"
+
+#include <assert.h>
+
+static void mesh_make(Mesh* mesh, const MeshDesc* desc) {
+  assert(mesh);
+  assert(desc);
+  assert(desc->geometry);
+  assert(desc->material);
+  mesh->geometry = desc->geometry;
+  mesh->material = desc->material;
+}
+
+Mesh* gfx_make_mesh(const MeshDesc* desc) {
+  Mesh* mesh = mem_alloc_mesh();
+  if (!mesh) {
+    return 0;
+  }
+  mesh_make(mesh, desc);
+  return mesh;
+}
+
+void gfx_destroy_mesh(Mesh** mesh) { mem_free_mesh(mesh); }
diff --git a/gfx/src/scene/mesh_impl.h b/gfx/src/scene/mesh_impl.h
new file mode 100644
index 0000000..858b147
--- /dev/null
+++ b/gfx/src/scene/mesh_impl.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include <gfx/scene/mesh.h>
+
+typedef struct Mesh {
+  const Geometry* geometry;
+  const Material* material;
+} 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/node.c b/gfx/src/scene/node.c
new file mode 100644
index 0000000..7d7f69f
--- /dev/null
+++ b/gfx/src/scene/node.c
@@ -0,0 +1,115 @@
+#include "node_impl.h"
+
+#include "camera_impl.h"
+#include "light_impl.h"
+#include "object_impl.h"
+#include "scene_graph.h"
+#include "scene_memory.h"
+
+#include <assert.h>
+
+static void scene_node_make(SceneNode* node) {
+  assert(node);
+  node->type = LogicalNode;
+  node->transform = mat4_id();
+}
+
+SceneNode* gfx_make_node() {
+  SceneNode* node = mem_alloc_node();
+  if (!node) {
+    return 0;
+  }
+  scene_node_make(node);
+  return node;
+}
+
+SceneNode* gfx_make_camera_node(SceneCamera* camera) {
+  assert(camera);
+  SceneNode* node = gfx_make_node();
+  if (!node) {
+    return 0;
+  }
+  node->type = CameraNode;
+  node->camera = mem_get_camera_index(camera);
+  camera->parent = mem_get_node_index(node);
+  return node;
+}
+
+SceneNode* gfx_make_light_node(Light* light) {
+  assert(light);
+  SceneNode* node = gfx_make_node();
+  if (!node) {
+    return 0;
+  }
+  node->type = LightNode;
+  node->light = mem_get_light_index(light);
+  light->parent = mem_get_node_index(node);
+  return node;
+}
+
+SceneNode* gfx_make_object_node(SceneObject* object) {
+  assert(object);
+  SceneNode* node = gfx_make_node();
+  if (!node) {
+    return 0;
+  }
+  node->type = ObjectNode;
+  node->object = mem_get_object_index(object);
+  object->parent = mem_get_node_index(node);
+  return node;
+}
+
+void gfx_destroy_node(SceneNode** node) {
+  assert(node);
+  assert(*node);
+
+  // Destroy the node's resources.
+  // Camera.
+  if ((*node)->type == CameraNode) {
+    SceneCamera* camera = mem_get_camera((*node)->camera);
+    camera->parent.val = 0; // Avoid recursive call into gfx_destroy_node().
+    gfx_destroy_camera(&camera);
+  }
+  // TODO: free light.
+  // Object.
+  if ((*node)->type == ObjectNode) {
+    SceneObject* object = mem_get_object((*node)->object);
+    object->parent.val = 0; // Avoid recursive call into gfx_destroy_node().
+    gfx_destroy_object(&object);
+  }
+
+  TREE_REMOVE(*node);
+  mem_free_node(node);
+}
+
+void gfx_del_node(node_idx index) {
+  assert(index.val);
+  SceneNode* node = mem_get_node(index);
+  assert(node);
+  TREE_REMOVE(node);
+  mem_free_node(&node);
+}
+
+void gfx_set_node_parent(SceneNode* child, SceneNode* parent) {
+  assert(child);
+  assert(parent);
+  SET_PARENT(child, parent);
+}
+
+void gfx_set_node_transform(SceneNode* node, const mat4* transform) {
+  assert(node);
+  assert(transform);
+  node->transform = *transform;
+}
+
+void gfx_set_node_position(SceneNode* node, const vec3* position) {
+  assert(node);
+  assert(position);
+  mat4_set_v3(&node->transform, *position);
+}
+
+void gfx_set_node_rotation(SceneNode* node, const mat4* rotation) {
+  assert(node);
+  assert(rotation);
+  mat4_set_3x3(&node->transform, *rotation);
+}
diff --git a/gfx/src/scene/node_impl.h b/gfx/src/scene/node_impl.h
new file mode 100644
index 0000000..ce3b769
--- /dev/null
+++ b/gfx/src/scene/node_impl.h
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <gfx/scene/node.h>
+
+#include "types.h"
+
+#include <math/mat4.h>
+
+/// Scene node type.
+typedef enum NodeType {
+  CameraNode,
+  LightNode,
+  LogicalNode,
+  ObjectNode
+} NodeType;
+
+/// Scene node.
+///
+/// The SceneNode owns its cameras, objects, lights and child nodes. These
+/// together form a strict tree hierarchy and not a more general DAG.
+typedef struct SceneNode {
+  NodeType type;
+  union {
+    camera_idx camera;
+    light_idx light;
+    object_idx object;
+  };
+  mat4 transform;  // Transformation for this node and its children.
+  node_idx parent; // Parent SceneNode.
+  node_idx child;  // First child SceneNode.
+  node_idx next;   // Next sibling SceneNode.
+  node_idx prev;   // Previous sibling SceneNode.
+} SceneNode;
+
+/// Destroy a node given its index.
+///
+/// The node is conveniently removed from the scene graph.
+void gfx_del_node(node_idx);
diff --git a/gfx/src/scene/object.c b/gfx/src/scene/object.c
new file mode 100644
index 0000000..7f23e92
--- /dev/null
+++ b/gfx/src/scene/object.c
@@ -0,0 +1,71 @@
+#include "object_impl.h"
+
+#include "node_impl.h"
+#include "scene_memory.h"
+
+#include <assert.h>
+
+static void scene_object_make(SceneObject* object) {
+  assert(object);
+  object->transform = mat4_id();
+}
+
+SceneObject* gfx_make_object() {
+  SceneObject* object = mem_alloc_object();
+  if (!object) {
+    return 0;
+  }
+  scene_object_make(object);
+  return object;
+}
+
+void gfx_destroy_object(SceneObject** object) {
+  assert(object);
+  assert(*object);
+  if ((*object)->parent.val) {
+    gfx_del_node((*object)->parent);
+  }
+  mem_free_object(object);
+}
+
+void gfx_set_object_transform(SceneObject* object, const mat4* transform) {
+  assert(object);
+  assert(transform);
+  object->transform = *transform;
+}
+
+void gfx_add_object_mesh(SceneObject* object, Mesh* mesh) {
+  assert(object);
+  assert(mesh);
+
+  MeshLink* link = mem_alloc_mesh_link();
+  assert(link);
+  link->mesh = mem_get_mesh_index(mesh);
+  link->next = object->mesh_link;
+  object->mesh_link = mem_get_mesh_link_index(link);
+}
+
+void gfx_remove_object_mesh(SceneObject* object, Mesh* mesh) {
+  assert(object);
+  assert(mesh);
+
+  MeshLink* prev = 0;
+  const mesh_idx mesh_index = mem_get_mesh_index(mesh);
+
+  // Find the MeshLink in the object that contains the given mesh.
+  for (mesh_link_idx mesh_link_index = object->mesh_link;
+       mesh_link_index.val;) {
+    MeshLink* mesh_link = mem_get_mesh_link(mesh_link_index);
+    if (mesh_link->mesh.val == mesh_index.val) {
+      if (prev) {
+        prev->next = mesh_link->next;
+      } else {
+        object->mesh_link = mesh_link->next;
+      }
+      mem_free_mesh_link(&mesh_link);
+      break;
+    }
+    prev = mesh_link;
+    mesh_link_index = mesh_link->next;
+  }
+}
diff --git a/gfx/src/scene/object_impl.h b/gfx/src/scene/object_impl.h
new file mode 100644
index 0000000..bd3fdbc
--- /dev/null
+++ b/gfx/src/scene/object_impl.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <gfx/scene/object.h>
+
+#include "types.h"
+
+#include <math/mat4.h>
+
+typedef struct MeshLink {
+  mesh_idx mesh;
+  mesh_link_idx next; // Next MeshLink in the list.
+} MeshLink;
+
+/// Scene object.
+///
+/// A SceneObject does not own its Meshes, and they are instead shared for
+/// re-use. The SceneObject consequently embeds a list of MeshLinks as opposed
+/// to a list of Meshes. The MeshLinks define a list of Meshes, which can be
+/// different for each SceneObject. Each SceneObject may then have a unique list
+/// of Meshes, and the Meshes are re-used.
+typedef struct SceneObject {
+  mat4 transform;
+  mesh_link_idx mesh_link; // First MeshLink in the list.
+  node_idx parent;         // Parent SceneNode.
+} SceneObject;
diff --git a/gfx/src/scene/scene.c b/gfx/src/scene/scene.c
new file mode 100644
index 0000000..9e974de
--- /dev/null
+++ b/gfx/src/scene/scene.c
@@ -0,0 +1,43 @@
+#include "scene_impl.h"
+
+#include "camera_impl.h"
+#include "node_impl.h"
+#include "object_impl.h"
+#include "scene_graph.h"
+#include "scene_memory.h"
+
+static void scene_destroy_rec(node_idx node_index) {
+  assert(node_index.val);
+
+  SceneNode* node = mem_get_node(node_index);
+  assert(node);
+
+  // First child.
+  if (node->child.val) {
+    scene_destroy_rec(node->child);
+  }
+
+  // Right sibling.
+  if (node->next.val) {
+    scene_destroy_rec(node->next);
+  }
+
+  gfx_destroy_node(&node);
+}
+
+void scene_make(Scene* scene) {
+  assert(scene);
+  SceneNode* root = gfx_make_node();
+  assert(root);
+  scene->root = mem_get_node_index(root);
+}
+
+void scene_destroy(Scene* scene) {
+  assert(scene);
+  scene_destroy_rec(scene->root);
+}
+
+SceneNode* gfx_get_scene_root(Scene* scene) {
+  assert(scene);
+  return mem_get_node(scene->root);
+}
diff --git a/gfx/src/scene/scene_graph.h b/gfx/src/scene/scene_graph.h
new file mode 100644
index 0000000..b9b3a14
--- /dev/null
+++ b/gfx/src/scene/scene_graph.h
@@ -0,0 +1,67 @@
+/// Functions for list manipulation.
+#pragma once
+
+#include "scene_memory.h"
+
+// Note that SceneMemory guarantees that index 0 can be regarded as an invalid
+// index.
+
+#define MEM_GET(INDEX)                                                         \
+  _Generic((INDEX), camera_idx                                                 \
+           : mem_get_camera, material_idx                                      \
+           : mem_get_material, mesh_idx                                        \
+           : mem_get_mesh, mesh_link_idx                                       \
+           : mem_get_mesh_link, node_idx                                       \
+           : mem_get_node, object_idx                                          \
+           : mem_get_object, scene_idx                                         \
+           : mem_get_scene)(INDEX)
+
+#define MEM_GET_INDEX(ITEM)                                                    \
+  _Generic((ITEM), SceneCamera *                                               \
+           : mem_get_camera_index, Material *                                  \
+           : mem_get_material_index, Mesh *                                    \
+           : mem_get_mesh_index, MeshLink *                                    \
+           : mem_get_mesh_link_index, SceneNode *                              \
+           : mem_get_node_index, SceneObject *                                 \
+           : mem_get_object_index, Scene *                                     \
+           : mem_get_scene_index)(ITEM)
+
+#define LIST_PREPEND(HEAD_INDEX, ITEM)                                         \
+  ITEM->next = HEAD_INDEX;                                                     \
+  if (HEAD_INDEX.val) {                                                        \
+    typeof(ITEM) old_head = MEM_GET(HEAD_INDEX);                               \
+    old_head->prev = MEM_GET_INDEX(ITEM);                                      \
+  }                                                                            \
+  HEAD_INDEX = MEM_GET_INDEX(ITEM);
+
+#define LIST_REMOVE(ITEM)                                                      \
+  if ((ITEM)->prev.val) {                                                      \
+    typeof(ITEM) prev_sibling = MEM_GET((ITEM)->prev);                         \
+    prev_sibling->next = (ITEM)->next;                                         \
+  }                                                                            \
+  if ((ITEM)->next.val) {                                                      \
+    typeof(ITEM) next_sibling = MEM_GET((ITEM)->next);                         \
+    next_sibling->prev = (ITEM)->prev;                                         \
+  }
+
+#define SET_PARENT(CHILD, PARENT)                                              \
+  assert(CHILD);                                                               \
+  if (CHILD->parent.val) {                                                     \
+    LIST_REMOVE(CHILD);                                                        \
+  }                                                                            \
+  if (parent) {                                                                \
+    LIST_PREPEND(PARENT->CHILD, CHILD);                                        \
+  }
+
+#define TREE_REMOVE(ITEM)                                                      \
+  if ((ITEM)->prev.val) {                                                      \
+    typeof(ITEM) prev_sibling = MEM_GET((ITEM)->prev);                         \
+    prev_sibling->next = (ITEM)->next;                                         \
+  }                                                                            \
+  if ((ITEM)->next.val) {                                                      \
+    typeof(ITEM) next_sibling = MEM_GET((ITEM)->next);                         \
+    next_sibling->prev = (ITEM)->prev;                                         \
+  }                                                                            \
+  if ((ITEM)->parent.val) {                                                    \
+    MEM_GET((ITEM)->parent)->child.val = 0;                                    \
+  }
diff --git a/gfx/src/scene/scene_impl.h b/gfx/src/scene/scene_impl.h
new file mode 100644
index 0000000..e0c25bf
--- /dev/null
+++ b/gfx/src/scene/scene_impl.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <gfx/scene/scene.h>
+
+#include "types.h"
+
+typedef struct Scene {
+  node_idx root;
+  scene_idx next;
+  scene_idx prev;
+} Scene;
+
+/// Create a new scene.
+void scene_make(Scene*);
+
+/// Destroy the scene.
+void scene_destroy(Scene*);
diff --git a/gfx/src/scene/scene_memory.c b/gfx/src/scene/scene_memory.c
new file mode 100644
index 0000000..cd4a79c
--- /dev/null
+++ b/gfx/src/scene/scene_memory.c
@@ -0,0 +1,148 @@
+#include "scene_memory.h"
+
+#include <gfx/sizes.h>
+
+#include "camera_impl.h"
+#include "light_impl.h"
+#include "material_impl.h"
+#include "mesh_impl.h"
+#include "node_impl.h"
+#include "object_impl.h"
+#include "scene_impl.h"
+#include "types.h"
+
+#include <mempool.h>
+
+DEF_MEMPOOL(camera_pool, SceneCamera, 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)
+DEF_MEMPOOL(mesh_link_pool, MeshLink, GFX_MAX_NUM_MESH_LINKS)
+DEF_MEMPOOL(node_pool, SceneNode, GFX_MAX_NUM_NODES)
+DEF_MEMPOOL(object_pool, SceneObject, GFX_MAX_NUM_OBJECTS)
+DEF_MEMPOOL(scene_pool, Scene, GFX_MAX_NUM_SCENES)
+
+/// Scene memory.
+///
+/// Holds memory pools for every type of scene object.
+typedef struct SceneMemory {
+  camera_pool cameras;
+  light_pool lights;
+  material_pool materials;
+  mesh_pool meshes;
+  mesh_link_pool mesh_links;
+  node_pool nodes;
+  object_pool objects;
+  scene_pool scenes;
+} SceneMemory;
+
+static SceneMemory mem;
+
+#define ALLOC_DUMMY(POOL)                                                      \
+  assert(mempool_get_block_index(POOL, mempool_alloc(POOL)) == 0)
+
+void scene_mem_init() {
+  mempool_make(&mem.cameras);
+  mempool_make(&mem.lights);
+  mempool_make(&mem.materials);
+  mempool_make(&mem.meshes);
+  mempool_make(&mem.mesh_links);
+  mempool_make(&mem.nodes);
+  mempool_make(&mem.objects);
+  mempool_make(&mem.scenes);
+
+  // Allocate dummy objects at index 0 to guarantee that no objects allocated by
+  // the caller map to index 0.
+  ALLOC_DUMMY(&mem.cameras);
+  ALLOC_DUMMY(&mem.lights);
+  ALLOC_DUMMY(&mem.materials);
+  ALLOC_DUMMY(&mem.meshes);
+  ALLOC_DUMMY(&mem.mesh_links);
+  ALLOC_DUMMY(&mem.nodes);
+  ALLOC_DUMMY(&mem.objects);
+  ALLOC_DUMMY(&mem.scenes);
+}
+
+void scene_mem_destroy() {}
+
+// Memory allocation.
+SceneCamera* mem_alloc_camera() { return mempool_alloc(&mem.cameras); }
+Light* mem_alloc_light() { return mempool_alloc(&mem.lights); }
+Material* mem_alloc_material() { return mempool_alloc(&mem.materials); }
+Mesh* mem_alloc_mesh() { return mempool_alloc(&mem.meshes); }
+MeshLink* mem_alloc_mesh_link() { return mempool_alloc(&mem.mesh_links); }
+SceneNode* mem_alloc_node() { return mempool_alloc(&mem.nodes); }
+SceneObject* mem_alloc_object() { return mempool_alloc(&mem.objects); }
+Scene* mem_alloc_scene() { return mempool_alloc(&mem.scenes); }
+
+// Memory free.
+void mem_free_camera(SceneCamera** camera) {
+  mempool_free(&mem.cameras, camera);
+}
+void mem_free_light(Light** light) { mempool_free(&mem.lights, light); }
+void mem_free_material(Material** material) {
+  mempool_free(&mem.materials, material);
+}
+void mem_free_mesh(Mesh** mesh) { mempool_free(&mem.meshes, mesh); }
+void mem_free_mesh_link(MeshLink** mesh_link) {
+  mempool_free(&mem.mesh_links, mesh_link);
+}
+void mem_free_node(SceneNode** node) { mempool_free(&mem.nodes, node); }
+void mem_free_object(SceneObject** object) {
+  mempool_free(&mem.objects, object);
+}
+void mem_free_scene(Scene** scene) { mempool_free(&mem.scenes, scene); }
+
+// Query by index.
+SceneCamera* mem_get_camera(camera_idx index) {
+  return mempool_get_block(&mem.cameras, index.val);
+}
+Light* mem_get_light(light_idx index) {
+  return mempool_get_block(&mem.lights, index.val);
+}
+Material* mem_get_material(material_idx index) {
+  return mempool_get_block(&mem.materials, index.val);
+}
+Mesh* mem_get_mesh(mesh_idx index) {
+  return mempool_get_block(&mem.meshes, index.val);
+}
+MeshLink* mem_get_mesh_link(mesh_link_idx index) {
+  return mempool_get_block(&mem.mesh_links, index.val);
+}
+SceneNode* mem_get_node(node_idx index) {
+  return mempool_get_block(&mem.nodes, index.val);
+}
+SceneObject* mem_get_object(object_idx index) {
+  return mempool_get_block(&mem.objects, index.val);
+}
+Scene* mem_get_scene(scene_idx index) {
+  return mempool_get_block(&mem.scenes, index.val);
+}
+
+// Map object to index.
+camera_idx mem_get_camera_index(const SceneCamera* camera) {
+  return (camera_idx){.val = mempool_get_block_index(&mem.cameras, camera)};
+}
+light_idx mem_get_light_index(const Light* light) {
+  return (light_idx){.val = mempool_get_block_index(&mem.lights, light)};
+}
+material_idx mem_get_material_index(const Material* material) {
+  return (material_idx){.val =
+                            mempool_get_block_index(&mem.materials, material)};
+}
+mesh_idx mem_get_mesh_index(const Mesh* mesh) {
+  return (mesh_idx){.val = mempool_get_block_index(&mem.meshes, mesh)};
+}
+mesh_link_idx mem_get_mesh_link_index(const MeshLink* mesh_link) {
+  return (mesh_link_idx){
+      .val = mempool_get_block_index(&mem.mesh_links, mesh_link)};
+}
+node_idx mem_get_node_index(const SceneNode* node) {
+  return (node_idx){.val = mempool_get_block_index(&mem.nodes, node)};
+}
+object_idx mem_get_object_index(const SceneObject* object) {
+  return (object_idx){.val = mempool_get_block_index(&mem.objects, object)};
+}
+scene_idx mem_get_scene_index(const Scene* scene) {
+  return (scene_idx){.val = mempool_get_block_index(&mem.scenes, scene)};
+}
diff --git a/gfx/src/scene/scene_memory.h b/gfx/src/scene/scene_memory.h
new file mode 100644
index 0000000..dff5bd8
--- /dev/null
+++ b/gfx/src/scene/scene_memory.h
@@ -0,0 +1,130 @@
+/// Memory management of scene objects.
+#pragma once
+
+#include "types.h"
+
+typedef struct Light Light;
+typedef struct Material Material;
+typedef struct Mesh Mesh;
+typedef struct MeshLink MeshLink;
+typedef struct SceneCamera SceneCamera;
+typedef struct SceneNode SceneNode;
+typedef struct SceneObject SceneObject;
+typedef struct Scene Scene;
+
+/// Initialize scene memory.
+///
+/// The scene memory guarantees that every object maps to an index different
+/// than 0. In this way, 0 can be used as a special index to denote "no value".
+void scene_mem_init();
+
+/// Destroy the scene memory.
+void scene_mem_destroy();
+
+/// ----------------------------------------------------------------------------
+/// Memory allocation.
+/// ----------------------------------------------------------------------------
+
+/// Allocate space for a camera.
+SceneCamera* mem_alloc_camera();
+
+/// Allocate space for a light.
+Light* mem_alloc_light();
+
+/// Allocate space for a material.
+Material* mem_alloc_material();
+
+/// Allocate space for a mesh.
+Mesh* mem_alloc_mesh();
+
+/// Allocate space for a mesh link.
+MeshLink* mem_alloc_mesh_link();
+
+/// Allocate space for a scene node.
+SceneNode* mem_alloc_node();
+
+/// Allocate space for a scene object.
+SceneObject* mem_alloc_object();
+
+/// Allocate space for a scene.
+Scene* mem_alloc_scene();
+
+/// Free the camera.
+void mem_free_camera(SceneCamera**);
+
+/// Free the light.
+void mem_free_light(Light**);
+
+/// Free the material.
+void mem_free_material(Material**);
+
+/// Free the mesh.
+void mem_free_mesh(Mesh**);
+
+/// Free the mesh link.
+void mem_free_mesh_link(MeshLink**);
+
+/// Free the scene node.
+void mem_free_node(SceneNode**);
+
+/// Free the scene object.
+void mem_free_object(SceneObject**);
+
+/// Free the scene.
+void mem_free_scene(Scene**);
+
+/// ----------------------------------------------------------------------------
+/// Query objects by index.
+/// ----------------------------------------------------------------------------
+
+/// Get a camera by index.
+SceneCamera* mem_get_camera(camera_idx);
+
+/// Get a light by index.
+Light* mem_get_light(light_idx);
+
+/// Get a material by index.
+Material* mem_get_material(material_idx);
+
+/// Get a mesh by index.
+Mesh* mem_get_mesh(mesh_idx);
+
+/// Get a mesh link by index.
+MeshLink* mem_get_mesh_link(mesh_link_idx);
+
+/// Get a node by index.
+SceneNode* mem_get_node(node_idx);
+
+/// Get an object by index.
+SceneObject* mem_get_object(object_idx);
+
+/// Get a scene by index.
+Scene* mem_get_scene(scene_idx);
+
+/// ----------------------------------------------------------------------------
+/// Map objects to indices.
+/// ----------------------------------------------------------------------------
+
+/// Get the camera's index.
+camera_idx mem_get_camera_index(const SceneCamera*);
+
+/// Get the light's index.
+light_idx mem_get_light_index(const Light*);
+
+/// Get the material's index.
+material_idx mem_get_material_index(const Material*);
+
+/// Get the mesh's index.
+mesh_idx mem_get_mesh_index(const Mesh*);
+
+/// Get the mesh link's index.
+mesh_link_idx mem_get_mesh_link_index(const MeshLink*);
+
+/// Get the node's index.
+node_idx mem_get_node_index(const SceneNode*);
+
+/// Get the object's index.
+object_idx mem_get_object_index(const SceneObject*);
+
+/// Get the scene's index.
+scene_idx mem_get_scene_index(const Scene*);
diff --git a/gfx/src/scene/types.h b/gfx/src/scene/types.h
new file mode 100644
index 0000000..2863ac7
--- /dev/null
+++ b/gfx/src/scene/types.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef uint16_t gfx_idx;
+
+// Strongly-typed indices.
+
+#define DEF_STRONG_INDEX(TYPE_NAME)                                            \
+  typedef struct TYPE_NAME##_idx {                                             \
+    gfx_idx val;                                                               \
+  } TYPE_NAME##_idx;
+
+DEF_STRONG_INDEX(camera)
+DEF_STRONG_INDEX(light)
+DEF_STRONG_INDEX(material)
+DEF_STRONG_INDEX(mesh)
+DEF_STRONG_INDEX(mesh_link)
+DEF_STRONG_INDEX(node)
+DEF_STRONG_INDEX(object)
+DEF_STRONG_INDEX(scene)