1 files changed, 53 insertions, 202 deletions

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);
 }