4 files changed, 71 insertions, 146 deletions

diff --git a/src/render/imm.c b/src/render/imm.c
index 8a93488..7ab8d62 100644
--- a/src/render/imm.c
+++ b/src/render/imm.c
@@ -21,12 +21,14 @@ bool gfx_imm_make(Imm* renderer, GfxCore* gfxcore, LLR* llr) {
   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)}});
+      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;
   }
diff --git a/src/render/llr.c b/src/render/llr.c
index 76935f9..752b65b 100644
--- a/src/render/llr.c
+++ b/src/render/llr.c
@@ -1,14 +1,15 @@
 #include "llr_impl.h"
 
 #include "animation_impl.h"
-#include "memory.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>
-#include <error.h>
 
 static const int IRRADIANCE_MAP_WIDTH               = 1024;
 static const int IRRADIANCE_MAP_HEIGHT              = 1024;
@@ -17,114 +18,30 @@ static const int PREFILTERED_ENVIRONMENT_MAP_HEIGHT = 128;
 static const int BRDF_INTEGRATION_MAP_WIDTH         = 512;
 static const int BRDF_INTEGRATION_MAP_HEIGHT        = 512;
 
-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();
-
-  switch (desc->type) {
-  case EnvironmentLightType:
-    make_environment_light(light, &desc->light.environment);
-    break;
-  default:
-    log_error("Unhandled light type");
-    gfx_destroy_light(&light);
-    return 0;
-  }
-
-  return light;
-}
-
-void gfx_destroy_light(Light** light) {
-  assert(light);
-  if (*light) {
-    mem_free_light(light);
-  }
-}
-
-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;
-  }
-}
-
 /// Activate the material.
 ///
 /// This configures the shader uniforms that are specific to the material.
-static void gfx_material_activate(
-    ShaderProgram* shader, const Material* 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];
-    set_uniform(shader, uniform);
+    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});
   }
 }
 
-static void mesh_make(Mesh* mesh, const MeshDesc* desc) {
-  assert(mesh);
-  assert(desc);
-  assert(desc->geometry);
-  assert(desc->material);
-  assert(desc->shader);
-  mesh->geometry = desc->geometry;
-  mesh->material = desc->material;
-  mesh->shader   = desc->shader;
-}
-
-Mesh* gfx_make_mesh(const MeshDesc* desc) {
-  Mesh* mesh = mem_alloc_mesh();
-  mesh_make(mesh, desc);
-  return mesh;
-}
-
-void gfx_destroy_mesh(Mesh** mesh) { mem_free_mesh(mesh); }
-
 /// Initialize renderer state for IBL.
 static bool init_ibl(LLR* renderer) {
   assert(renderer);
@@ -314,7 +231,7 @@ static void configure_state(LLR* renderer) {
 
     // Geometry may be rendered without a material.
     if (renderer->material) {
-      gfx_material_activate(renderer->shader, renderer->material);
+      material_activate(renderer->shader, renderer->material);
     }
   }
 
diff --git a/src/render/llr_impl.h b/src/render/llr_impl.h
index c85ad15..9d70843 100644
--- a/src/render/llr_impl.h
+++ b/src/render/llr_impl.h
@@ -3,8 +3,6 @@
 #include <gfx/render/llr.h>
 #include <gfx/sizes.h>
 
-#include "../types.h"
-
 #include <math/mat4.h>
 #include <math/vec3.h>
 
@@ -12,41 +10,12 @@
 #include <stddef.h>
 #include <stdint.h>
 
-typedef struct Geometry      Geometry;
 typedef struct GfxCore       GfxCore;
 typedef struct IBL           IBL;
 typedef struct Material      Material;
 typedef struct ShaderProgram ShaderProgram;
 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;
-  };
-} Light;
-
-typedef struct Material {
-  ShaderUniform uniforms[GFX_MAX_UNIFORMS_PER_MATERIAL];
-  int           num_uniforms;
-} Material;
-
-typedef struct Mesh {
-  const Geometry* geometry;
-  const Material* material;
-  ShaderProgram*  shader; // TODO: Move this back to Material?
-} Mesh;
-
 /// Immediate mode renderer.
 ///
 /// The renderer caches state changes in memory and only programs the underlying
diff --git a/src/render/renderer.c b/src/render/renderer.c
index b513ed4..a9d9bef 100644
--- a/src/render/renderer.c
+++ b/src/render/renderer.c
@@ -3,10 +3,11 @@
 #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 "scene/scene_impl.h"
 
 #include <gfx/core.h>
 #include <gfx/render/llr.h>
@@ -86,12 +87,13 @@ static ShaderProgram* load_shader(Renderer* renderer, RenderSceneMode mode) {
 // }
 
 typedef struct RenderState {
-  GfxCore*       gfxcore;
-  LLR*           llr;
-  Renderer*      renderer;
-  ShaderProgram* shader; // Null to use scene shaders.
-  const Scene*   scene;
-  const Anima*   anima;
+  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(
@@ -153,6 +155,24 @@ static void draw_recursively(
         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.
@@ -208,6 +228,22 @@ void gfx_render_scene(Renderer* renderer, const RenderSceneParams* params) {
 
   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));
 }
 
@@ -236,6 +272,7 @@ static void update_rec(SceneNode* node, const Camera* camera, R t) {
   }
 }
 
+// TODO: Move this outside the renderer.
 void gfx_update(Scene* scene, const Camera* camera, R t) {
   assert(scene);
   assert(camera);