4 files changed, 292 insertions, 208 deletions

diff --git a/src/renderer/imm_renderer.c b/src/renderer/imm_renderer.c
new file mode 100644
index 0000000..01cc5bb
--- /dev/null
+++ b/src/renderer/imm_renderer.c
@@ -0,0 +1,192 @@
+#include "imm_renderer_impl.h"
+
+#include <gfx/core.h>
+#include <gfx/llr/llr.h>
+#include <gfx/renderer/imm_renderer.h>
+#include <gfx/util/shader.h>
+
+#include <math/aabb3.h>
+
+#include <assert.h>
+#include <string.h> // memcpy
+
+bool gfx_imm_make(ImmRenderer* renderer, GfxCore* gfxcore, LLR* llr) {
+  assert(renderer);
+  assert(gfxcore);
+  assert(llr);
+
+  const size_t num_triangle_verts = GFX_IMM_MAX_NUM_TRIANGLES * 3;
+
+  renderer->gfxcore = gfxcore;
+  renderer->llr     = llr;
+
+  renderer->triangles = gfx_make_geometry(
+      gfxcore,
+      &(GeometryDesc){.type         = Triangles,
+                      .buffer_usage = BufferDynamic,
+                      .num_verts    = num_triangle_verts,
+                      .positions3d  = (BufferView3d){
+                           .size_bytes = num_triangle_verts * sizeof(vec3)}});
+  if (!renderer->triangles) {
+    goto cleanup;
+  }
+
+  renderer->shader = gfx_make_immediate_mode_shader(gfxcore);
+  if (!renderer->shader) {
+    goto cleanup;
+  }
+
+  gfx_imm_set_colour(renderer, vec4_make(0.0f, 0.0f, 0.0f, 1.0f));
+
+  return true;
+
+cleanup:
+  gfx_imm_destroy(renderer);
+  return false;
+}
+
+void gfx_imm_destroy(ImmRenderer* renderer) {
+  assert(renderer);
+  assert(renderer->gfxcore);
+
+  if (renderer->triangles) {
+    gfx_destroy_geometry(renderer->gfxcore, &renderer->triangles);
+    // TODO: Could also destroy the geometry's buffers here.
+  }
+
+  if (renderer->shader) {
+    gfx_destroy_shader_program(renderer->gfxcore, &renderer->shader);
+  }
+}
+
+void gfx_imm_flush(ImmRenderer* renderer) {
+  assert(renderer);
+
+  if (renderer->num_triangle_verts > 0) {
+    gfx_update_geometry(
+        renderer->triangles,
+        &(GeometryDesc){
+            .num_verts   = renderer->num_triangle_verts,
+            .positions3d = (BufferView3d){
+                                          .data       = renderer->triangle_verts,
+                                          .size_bytes = renderer->num_triangle_verts * sizeof(vec3)}
+    });
+
+    gfx_llr_render_geometry(renderer->llr, renderer->triangles);
+
+    renderer->num_triangle_verts = 0;
+  }
+}
+
+void gfx_imm_start(ImmRenderer* renderer) {
+  assert(renderer);
+
+  // Shader uniforms are applied lazily.
+  // TODO: In the event that gfx_activate_shader_program() activates uniforms
+  //  automatically for convenience, call an overload here that doesn't do so.
+  // gfx_activate_shader_program(renderer->shader);
+  gfx_llr_set_shader(renderer->llr, renderer->shader);
+}
+
+void gfx_imm_end(ImmRenderer* renderer) {
+  assert(renderer);
+
+  gfx_imm_flush(renderer);
+  // gfx_deactivate_shader_program(renderer->shader);
+  gfx_llr_set_shader(renderer->llr, 0);
+}
+
+void gfx_imm_draw_triangles(
+    ImmRenderer* renderer, const vec3 verts[], size_t num_triangles) {
+  assert(renderer);
+  assert(verts);
+  const size_t new_verts = num_triangles * 3;
+  assert(
+      renderer->num_triangle_verts + new_verts <
+      (GFX_IMM_MAX_NUM_TRIANGLES * 3));
+
+  memcpy(
+      renderer->triangle_verts + renderer->num_triangle_verts, verts,
+      new_verts * sizeof(vec3));
+
+  renderer->num_triangle_verts += new_verts;
+}
+
+void gfx_imm_draw_triangle(ImmRenderer* renderer, const vec3 verts[3]) {
+  gfx_imm_draw_triangles(renderer, verts, 1);
+}
+
+void gfx_imm_draw_aabb2(ImmRenderer* renderer, aabb2 box) {
+  assert(renderer);
+
+  // clang-format off
+  const vec3 verts[4] = {
+      vec3_make(box.min.x, box.min.y, 0),    // 3 ---- 2
+      vec3_make(box.max.x, box.min.y, 0),    // |      |
+      vec3_make(box.max.x, box.max.y, 0),    // |      |
+      vec3_make(box.min.x, box.max.y, 0)};   // 0 ---- 1
+  // clang-format on
+
+#define tri(i0, i1, i2) verts[i0], verts[i1], verts[i2]
+  const vec3 tris[6] = {tri(0, 1, 2), tri(0, 2, 3)};
+#undef tri
+
+  gfx_imm_draw_triangles(renderer, tris, 2);
+}
+
+void gfx_imm_draw_aabb3(ImmRenderer* renderer, aabb3 box) {
+  assert(renderer);
+
+  // clang-format off
+  const vec3 vertices[8] = {
+      vec3_make(box.min.x, box.min.y, box.max.z), //     7 ----- 6
+      vec3_make(box.max.x, box.min.y, box.max.z), //    /       /|
+      vec3_make(box.max.x, box.max.y, box.max.z), //   3 ----- 2 |
+      vec3_make(box.min.x, box.max.y, box.max.z), //   |       | |
+      vec3_make(box.min.x, box.min.y, box.min.z), //   | 4 ----- 5
+      vec3_make(box.max.x, box.min.y, box.min.z), //   |/      |/
+      vec3_make(box.max.x, box.max.y, box.min.z), //   0 ----- 1
+      vec3_make(box.min.x, box.max.y, box.min.z)};
+  // clang-format on
+
+  gfx_imm_draw_box3(renderer, vertices);
+}
+
+void gfx_imm_draw_box3(ImmRenderer* renderer, const vec3 vertices[8]) {
+  assert(renderer);
+  assert(vertices);
+
+  //     7 ----- 6
+  //    /       /|
+  //   3 ----- 2 |
+  //   |       | |
+  //   | 4 ----- 5
+  //   |/      |/
+  //   0 ----- 1
+
+#define tri(i0, i1, i2) vertices[i0], vertices[i1], vertices[i2]
+  const vec3 tris[36] = {
+      // Front.
+      tri(0, 1, 2), tri(0, 2, 3),
+      // Right.
+      tri(1, 5, 6), tri(1, 6, 2),
+      // Back.
+      tri(5, 4, 7), tri(5, 7, 6),
+      // Left.
+      tri(4, 0, 03), tri(4, 3, 7),
+      // Top.
+      tri(3, 2, 6), tri(3, 6, 7),
+      // Bottom.
+      tri(0, 4, 5), tri(0, 5, 1)};
+
+  gfx_imm_draw_triangles(renderer, tris, 12);
+}
+
+void gfx_imm_set_colour(ImmRenderer* renderer, vec4 colour) {
+  assert(renderer);
+  assert(renderer->shader);
+
+  gfx_imm_flush(renderer);
+
+  gfx_set_vec4_uniform(renderer->shader, "Colour", colour);
+}
diff --git a/src/renderer/imm_renderer_impl.h b/src/renderer/imm_renderer_impl.h
new file mode 100644
index 0000000..61b49a7
--- /dev/null
+++ b/src/renderer/imm_renderer_impl.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <gfx/sizes.h>
+
+#include <math/vec3.h>
+
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef struct Geometry      Geometry;
+typedef struct GfxCore       GfxCore;
+typedef struct IBL           IBL;
+typedef struct LLR           LLR;
+typedef struct Material      Material;
+typedef struct ShaderProgram ShaderProgram;
+typedef struct Texture       Texture;
+
+/// Immediate mode renderer.
+///
+/// Currently, the immediate mode renderer can only draw up to a maximum number
+/// of primitives per frame. It does not adjust this number dynamically. Keeps
+/// things simple while the extra complexity is not needed.
+/// TODO: Flush the buffer when it reaches its maximum size to remove this
+///  constraint.
+typedef struct ImmRenderer {
+  GfxCore* gfxcore;
+  LLR*     llr;
+
+  ShaderProgram* shader; // Immediate-mode shader program for primitives.
+  Geometry*      triangles;
+  size_t         num_triangle_verts; // Number of triangle verts this frame.
+  // TODO: wireframe rendering.
+  struct {
+    bool wireframe : 1;
+  } flags;
+  vec3 triangle_verts[GFX_IMM_MAX_NUM_TRIANGLES * 3];
+} ImmRenderer;
+
+/// Create a new immediate mode renderer.
+bool gfx_imm_make(ImmRenderer*, GfxCore*, LLR*);
+
+/// Destroy the immediate mode renderer.
+void gfx_imm_destroy(ImmRenderer*);
diff --git a/src/renderer/renderer.c b/src/renderer/renderer.c
index c2a7dda..29a1813 100644
--- a/src/renderer/renderer.c
+++ b/src/renderer/renderer.c
@@ -1,10 +1,9 @@
 #include "renderer_impl.h"
 
+#include "llr/light_impl.h"
+#include "llr/mesh_impl.h"
 #include "scene/animation_impl.h"
 #include "scene/camera_impl.h"
-#include "scene/light_impl.h"
-#include "scene/material_impl.h"
-#include "scene/mesh_impl.h"
 #include "scene/model_impl.h"
 #include "scene/node_impl.h"
 #include "scene/object_impl.h"
@@ -12,41 +11,30 @@
 #include "scene/scene_memory.h"
 
 #include <gfx/core.h>
-#include <gfx/util/ibl.h>
+#include <gfx/llr/llr.h>
 #include <gfx/util/shader.h>
 
-#include <log/log.h>
 #include <math/mat4.h>
-#include <math/spatial3.h>
 
 #include <assert.h>
 
-// TODO: Move to a header like "constants.h".
-static const int IRRADIANCE_MAP_WIDTH               = 1024;
-static const int IRRADIANCE_MAP_HEIGHT              = 1024;
-static const int PREFILTERED_ENVIRONMENT_MAP_WIDTH  = 128;
-static const int PREFILTERED_ENVIRONMENT_MAP_HEIGHT = 128;
-static const int BRDF_INTEGRATION_MAP_WIDTH         = 512;
-static const int BRDF_INTEGRATION_MAP_HEIGHT        = 512;
-
-bool renderer_make(Renderer* renderer, GfxCore* gfxcore) {
+bool gfx_renderer_make(Renderer* renderer, LLR* llr, GfxCore* gfxcore) {
   assert(renderer);
+  assert(llr);
   assert(gfxcore);
 
   renderer->gfxcore = gfxcore;
+  renderer->llr     = llr;
 
   return true;
 }
 
-void renderer_destroy(Renderer* renderer) {
+void gfx_renderer_destroy(Renderer* renderer) {
   if (!renderer) {
     return;
   }
   assert(renderer->gfxcore);
   GfxCore* gfxcore = renderer->gfxcore;
-  if (renderer->ibl) {
-    gfx_destroy_ibl(gfxcore, &renderer->ibl);
-  }
   if (renderer->shaders.debug) {
     gfx_destroy_shader_program(gfxcore, &renderer->shaders.debug);
   }
@@ -62,24 +50,6 @@ void renderer_destroy(Renderer* renderer) {
   }
 }
 
-/// Initialize renderer state for IBL if not already initialized.
-static bool init_ibl(Renderer* renderer) {
-  assert(renderer);
-
-  if (!renderer->ibl && !(renderer->ibl = gfx_make_ibl(renderer->gfxcore))) {
-    return false;
-  }
-
-  if (!renderer->brdf_integration_map &&
-      !(renderer->brdf_integration_map = gfx_make_brdf_integration_map(
-            renderer->ibl, renderer->gfxcore, BRDF_INTEGRATION_MAP_WIDTH,
-            BRDF_INTEGRATION_MAP_HEIGHT))) {
-    return false;
-  }
-
-  return true;
-}
-
 static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) {
   assert(renderer);
 
@@ -117,89 +87,17 @@ static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) {
 //   }
 // }
 
-/// Computes irradiance and prefiltered environment maps for the light if they
-/// have not been already computed.
-static bool setup_environment_light(
-    Renderer* renderer, GfxCore* gfxcore, EnvironmentLight* light) {
-  assert(renderer);
-  assert(light);
-
-  if (!init_ibl(renderer)) {
-    return false;
-  }
-
-  if (light->irradiance_map) {
-    assert(light->prefiltered_environment_map);
-    return true;
-  }
-
-  Texture* irradiance_map              = 0;
-  Texture* prefiltered_environment_map = 0;
-
-  if (!(irradiance_map = gfx_make_irradiance_map(
-            renderer->ibl, gfxcore, light->environment_map,
-            IRRADIANCE_MAP_WIDTH, IRRADIANCE_MAP_HEIGHT))) {
-    goto cleanup;
-  }
-
-  int max_mip_level = 0;
-  if (!(prefiltered_environment_map = gfx_make_prefiltered_environment_map(
-            renderer->ibl, gfxcore, light->environment_map,
-            PREFILTERED_ENVIRONMENT_MAP_WIDTH,
-            PREFILTERED_ENVIRONMENT_MAP_HEIGHT, &max_mip_level))) {
-    goto cleanup;
-  }
-
-  light->irradiance_map              = irradiance_map;
-  light->prefiltered_environment_map = prefiltered_environment_map;
-  light->max_reflection_lod          = max_mip_level;
-
-  return true;
-
-cleanup:
-  if (irradiance_map) {
-    gfx_destroy_texture(gfxcore, &irradiance_map);
-  }
-  if (prefiltered_environment_map) {
-    gfx_destroy_texture(gfxcore, &prefiltered_environment_map);
-  }
-  return false;
-}
-
 typedef struct RenderState {
   GfxCore*       gfxcore;
+  LLR*           llr;
   Renderer*      renderer;
   ShaderProgram* shader; // Null to use scene shaders.
   const Scene*   scene;
-  const Camera*  camera;
-  const mat4*    camera_rotation; // From camera to world space, rotation only.
-  const mat4*    view_matrix;
-  const mat4*    projection;
-  const float    fovy;
-  const float    aspect;
-  Light*         environment_light;
   const Anima*   anima;
-  size_t         num_joints;
-  mat4           joint_matrices[GFX_MAX_NUM_JOINTS];
 } RenderState;
 
-/// Load joint matrices into the render state.
-static void load_skeleton(RenderState* state, skeleton_idx skeleton_index) {
-  assert(state);
-  assert(skeleton_index.val != 0);
-
-  const Skeleton* skeleton = mem_get_skeleton(skeleton_index);
-  assert(skeleton);
-  assert(skeleton->num_joints <= GFX_MAX_NUM_JOINTS);
-
-  state->num_joints = skeleton->num_joints;
-
-  for (size_t i = 0; i < skeleton->num_joints; ++i) {
-    const joint_idx joint_index = skeleton->joints[i];
-    const Joint*    joint       = &state->anima->joints[joint_index];
-    state->joint_matrices[i]    = joint->joint_matrix;
-  }
-}
+static void draw_children(
+    RenderState* state, const mat4* node_transform, const SceneNode* node);
 
 /// Draw the scene recursively.
 static void draw_recursively(
@@ -209,26 +107,27 @@ static void draw_recursively(
 
   // Anima.
   if (node->type == AnimaNode) {
+    // Save the anima so that we can animate objects.
     state->anima = gfx_get_node_anima(node);
+
+    draw_children(state, &node_transform, node);
   }
   // Activate light.
   else if (node->type == LightNode) {
     Light* light = mem_get_light(node->light);
     assert(light);
-
-    if (light->type == EnvironmentLightType) {
-      bool result = setup_environment_light(
-          state->renderer, state->gfxcore, &light->environment);
-      // TODO: Handle the result in a better way.
-      assert(result);
-      state->environment_light = light;
+    gfx_llr_push_light(state->llr, light);
+    {
+      draw_children(state, &node_transform, node);
     }
+    gfx_llr_pop_light(state->llr);
   }
   // Model.
   else if (node->type == ModelNode) {
     const Model*     model = gfx_get_node_model(node);
     const SceneNode* root  = mem_get_node(model->root);
     draw_recursively(state, parent_transform, root);
+    draw_children(state, &node_transform, node);
   }
   // Render object.
   else if (node->type == ObjectNode) {
@@ -237,16 +136,15 @@ static void draw_recursively(
 
     // TODO: Here we would frustum-cull the object.
 
-    // TODO: Avoid computing matrices like Modelview or MVP if the shader does
-    // not use them.
-    const mat4 model_matrix = node_transform;
-    const mat4 modelview    = mat4_mul(*state->view_matrix, model_matrix);
-    const mat4 mvp          = mat4_mul(*state->projection, modelview);
-
+    // A model/anima can have many skeletons. We need to animate the given
+    // object using its skeleton, not just any skeleton of the anima.
     if (object->skeleton.val) {
-      load_skeleton(state, object->skeleton);
+      const Skeleton* skeleton = mem_get_skeleton(object->skeleton);
+      gfx_llr_set_skeleton(state->llr, state->anima, skeleton);
     }
 
+    const mat4 model_matrix = node_transform;
+
     for (mesh_link_idx mesh_link_index = object->mesh_link;
          mesh_link_index.val;) {
       const MeshLink* mesh_link = mem_get_mesh_link(mesh_link_index);
@@ -256,63 +154,34 @@ static void draw_recursively(
       if (!mesh) {
         continue;
       }
-      assert(mesh->geometry);
-      assert(mesh->material);
 
       // TODO: Here we would frustum-cull the mesh. The AABB would have to be
-      // transformed by the model matrix. Rotation would make the AABB
-      // relatively large, but still, the culling would be conservative.
+      //  transformed by the model matrix. Rotation would make the AABB
+      //  relatively large, but still, the culling would be conservative.
 
-      // Apply common shader uniforms not captured by materials.
       ShaderProgram* shader = state->shader ? state->shader : mesh->shader;
-      gfx_set_mat4_uniform(shader, "ModelMatrix", &model_matrix);
-      gfx_set_mat4_uniform(shader, "Modelview", &modelview);
-      gfx_set_mat4_uniform(shader, "View", state->view_matrix);
-      gfx_set_mat4_uniform(shader, "Projection", state->projection);
-      gfx_set_mat4_uniform(shader, "MVP", &mvp);
-      gfx_set_mat4_uniform(shader, "CameraRotation", state->camera_rotation);
-      gfx_set_float_uniform(shader, "Fovy", state->fovy);
-      gfx_set_float_uniform(shader, "Aspect", state->aspect);
-      if (state->camera) {
-        gfx_set_vec3_uniform(
-            shader, "CameraPosition", state->camera->spatial.p);
-      }
-      if (state->num_joints > 0) {
-        gfx_set_mat4_array_uniform(
-            shader, "JointMatrices", state->joint_matrices, state->num_joints);
-      }
-      // Apply lights.
-      if (state->environment_light) {
-        const EnvironmentLight* light = &state->environment_light->environment;
-        assert(light->environment_map);
-        assert(light->irradiance_map);
-        assert(light->prefiltered_environment_map);
-        assert(state->renderer->brdf_integration_map);
-        gfx_set_texture_uniform(
-            shader, "BRDFIntegrationMap",
-            state->renderer->brdf_integration_map);
-        gfx_set_texture_uniform(shader, "Sky", light->environment_map);
-        gfx_set_texture_uniform(shader, "IrradianceMap", light->irradiance_map);
-        gfx_set_texture_uniform(
-            shader, "PrefilteredEnvironmentMap",
-            light->prefiltered_environment_map);
-        gfx_set_float_uniform(
-            shader, "MaxReflectionLOD", light->max_reflection_lod);
-      }
-      material_activate(shader, mesh->material);
-      gfx_activate_shader_program(shader);
-      gfx_apply_uniforms(shader);
-      gfx_render_geometry(mesh->geometry);
+      gfx_llr_set_shader(state->llr, shader);
+      gfx_llr_set_model_matrix(state->llr, &model_matrix);
+      gfx_llr_render_mesh(state->llr, mesh);
     }
 
-    // Reset state for next object.
-    state->num_joints = 0;
+    if (object->skeleton.val) {
+      gfx_llr_clear_skeleton(state->llr);
+    }
+
+    draw_children(state, &node_transform, node);
+  } else {
+    draw_children(state, &node_transform, node);
   }
+}
 
+/// Draw the node's children.
+static void draw_children(
+    RenderState* state, const mat4* node_transform, const SceneNode* node) {
   // Render children recursively.
   for (node_idx child_index = node->child; child_index.val;) {
     const SceneNode* child = mem_get_node(child_index);
-    draw_recursively(state, node_transform, child);
+    draw_recursively(state, *node_transform, child);
     child_index = child->next;
   }
 }
@@ -324,41 +193,23 @@ void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) {
 
   ShaderProgram* const shader = load_shader(renderer, params->mode);
 
-  const Scene*       scene  = params->scene;
-  const SceneCamera* camera = params->camera;
-
-  GfxCore* gfxcore = renderer->gfxcore;
-
-  mat4 projection, camera_rotation, view_matrix;
-  if (camera) {
-    projection = camera->camera.projection;
-    camera_rotation =
-        mat4_rotation(spatial3_transform(&camera->camera.spatial));
-    view_matrix = spatial3_inverse_transform(&camera->camera.spatial);
-  } else {
-    projection      = mat4_id();
-    camera_rotation = mat4_id();
-    view_matrix     = mat4_id();
-  }
+  const Scene*       scene   = params->scene;
+  const SceneCamera* camera  = params->camera;
+  GfxCore* const     gfxcore = renderer->gfxcore;
 
   int x, y, width, height;
   gfx_get_viewport(gfxcore, &x, &y, &width, &height);
-  const float aspect = (float)width / (float)height;
+  const R aspect = (R)width / (R)height;
 
   RenderState state = {
-      .gfxcore           = gfxcore,
-      .renderer          = renderer,
-      .shader            = shader,
-      .scene             = scene,
-      .camera            = &camera->camera,
-      .camera_rotation   = &camera_rotation,
-      .view_matrix       = &view_matrix,
-      .projection        = &projection,
-      .environment_light = 0,
-      // Assuming a perspective matrix.
-      .fovy   = atan(1.0 / (mat4_at(projection, 1, 1))) * 2,
-      .aspect = aspect};
-
+      .gfxcore  = gfxcore,
+      .llr      = renderer->llr,
+      .renderer = renderer,
+      .shader   = shader,
+      .scene    = scene};
+
+  gfx_llr_set_camera(renderer->llr, &camera->camera);
+  gfx_llr_set_aspect(renderer->llr, aspect);
   draw_recursively(&state, mat4_id(), scene->root);
 }
 
diff --git a/src/renderer/renderer_impl.h b/src/renderer/renderer_impl.h
index fc14dcb..7395915 100644
--- a/src/renderer/renderer_impl.h
+++ b/src/renderer/renderer_impl.h
@@ -4,14 +4,12 @@
 
 #include <stdbool.h>
 
-typedef struct IBL           IBL;
+typedef struct LLR           LLR;
 typedef struct ShaderProgram ShaderProgram;
-typedef struct Texture       Texture;
 
 typedef struct Renderer {
   GfxCore* gfxcore;
-  IBL*     ibl;
-  Texture* brdf_integration_map;
+  LLR*     llr;
   struct {
     ShaderProgram* debug;
     ShaderProgram* normals;
@@ -21,7 +19,7 @@ typedef struct Renderer {
 } Renderer;
 
 /// Create a new renderer.
-bool renderer_make(Renderer*, GfxCore*);
+bool gfx_renderer_make(Renderer*, LLR*, GfxCore*);
 
 /// Destroy the renderer.
-void renderer_destroy(Renderer*);
+void gfx_renderer_destroy(Renderer*);