Restructure projectHEADmain

4 files changed, 727 insertions, 0 deletions

diff --git a/src/renderer/imm_renderer.c b/src/renderer/imm_renderer.c
new file mode 100644
index 0000000..8cf3a10
--- /dev/null
+++ b/src/renderer/imm_renderer.c
@@ -0,0 +1,260 @@
+#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/src/renderer/imm_renderer_impl.h b/src/renderer/imm_renderer_impl.h
new file mode 100644
index 0000000..5ece354
--- /dev/null
+++ b/src/renderer/imm_renderer_impl.h
@@ -0,0 +1,44 @@
+#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 ShaderProgram ShaderProgram;
+
+/// 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 {
+  GfxCore*       gfxcore;
+  ShaderProgram* shader;
+  Geometry*      triangles;
+  size_t         num_triangle_verts; // Number of triangle verts this frame.
+  // TODO: wireframe rendering.
+  struct {
+    bool wireframe : 1;
+  } flags;
+  vec3 triangle_verts[IMM_MAX_NUM_TRIANGLES * 3];
+  // Matrix stack contains pre-multiplied matrices.
+  // It is also never empty. The top of the stack is an identity matrix when the
+  // stack is "empty" from the user's perspective.
+  mat4 matrix_stack[IMM_MAX_NUM_MATRICES];
+  int  stack_pointer;
+} ImmRenderer;
+
+/// Create a new immediate mode renderer.
+bool imm_renderer_make(ImmRenderer*, GfxCore*);
+
+/// Destroy the immediate mode renderer.
+void imm_renderer_destroy(ImmRenderer*);
+
+/// Flush draw commands.
+void imm_renderer_flush(ImmRenderer*);
diff --git a/src/renderer/renderer.c b/src/renderer/renderer.c
new file mode 100644
index 0000000..c2a7dda
--- /dev/null
+++ b/src/renderer/renderer.c
@@ -0,0 +1,396 @@
+#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/src/renderer/renderer_impl.h b/src/renderer/renderer_impl.h
new file mode 100644
index 0000000..fc14dcb
--- /dev/null
+++ b/src/renderer/renderer_impl.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <gfx/renderer.h>
+
+#include <stdbool.h>
+
+typedef struct IBL           IBL;
+typedef struct ShaderProgram ShaderProgram;
+typedef struct Texture       Texture;
+
+typedef struct Renderer {
+  GfxCore* gfxcore;
+  IBL*     ibl;
+  Texture* brdf_integration_map;
+  struct {
+    ShaderProgram* debug;
+    ShaderProgram* normals;
+    ShaderProgram* normal_mapped_normals;
+    ShaderProgram* tangents;
+  } shaders;
+} Renderer;
+
+/// Create a new renderer.
+bool renderer_make(Renderer*, GfxCore*);
+
+/// Destroy the renderer.
+void renderer_destroy(Renderer*);