merian-shaders/graph: improve specular / delta handling

- add delta lobe support
- fix nan when the exit of an interface was missed (light bulbs on Bathroom)
- Bump slang because there was a bug which surfaced with these changes; this made other fixes necessary because its caching mechanism changed.

Author: LDAP

include/merian-graph/nodes/gbuffer_rt/gbuffer_rt.slang

@@ -61,7 +61,7 @@ void main(ParameterBlock<Scene> scene, ParameterBlock<WGBuffer> gbuffer) {
             }
 
             const ShadingData sd = ShadingData(-ray.Direction, surface.pos, surface.uv, scene.time,
-                                               frame, face_normal, uint16_t(0), 1.0f, front_facing);
+                                               frame, face_normal, uint16_t(0), front_facing);
             float3 mat_emission;
             OrthonormalFrame mat_shading_frame;
             let mat = scene.material_system.get_material_sample(

include/merian-graph/nodes/render_pt/render_pt.slang

@@ -27,7 +27,6 @@ float3 trace_path(const ParameterBlock<Scene> scene,
                   inout RandomGenerator rng) {
     // Medium the ray is travelling through; updated on transmission events.
     HomogeneousVolume medium = scene.exterior_volume;
-    float current_ior = 1.0f;
 
     float3 throughput = medium.transmittance(distance(ray.Origin, sp.pos));
     float3 radiance = merian_render_emission_on_primary ? throughput * sp.emission : float3(0);
@@ -60,7 +59,6 @@ float3 trace_path(const ParameterBlock<Scene> scene,
         const bool transmission = wi_local.z * bs.wo.z < 0.f;
         if (transmission) {
             const IsotropicVolume interior = sp.surface_material.get_interior_volume();
-            current_ior /= interior.get_eta();
             // leaving a surface puts the ray back into the medium enclosing the scene
             if (dot(-ray.Direction, sp.get_face_normal()) >= 0.f)
                 medium = interior;
@@ -76,7 +74,7 @@ float3 trace_path(const ParameterBlock<Scene> scene,
 
         // the last vertex is never scattered from, so its material sample would be dead
         sp = scene.trace_and_get_shading_point(
-            ray, merian_render_instance_mask, RenderContext(uint16_t(bounce), current_ior),
+            ray, merian_render_instance_mask, RenderContext(uint16_t(bounce)),
             DefaultLODSampler(), bounce + 1 < merian_render_max_path_length);
 
         // Beer-Lambert attenuation over the segment just travelled inside the medium. In-scattering

include/merian-graph/nodes/render_pt_mcpg/render_pt_mcpg.slang

@@ -50,7 +50,6 @@ float3 trace_path(const ParameterBlock<Scene> scene,
 
     // Medium the ray is travelling through; updated on transmission events.
     HomogeneousVolume medium = scene.exterior_volume;
-    float current_ior = 1.0f;
 
     float3 throughput = medium.transmittance(distance(ray.Origin, sp.pos));
     float3 radiance = merian_render_emission_on_primary ? throughput * sp.emission : float3(0);
@@ -112,14 +111,19 @@ float3 trace_path(const ParameterBlock<Scene> scene,
 
         // Sample wo from the BSDF or the selected lobe
         const bool guide = can_guide && rng.next_float() < p_guide;
+        const float bsdf_w = can_guide ? (1.0 - p_guide) : 1.0;
         float3 wo_world;
         float3 wo_local;
+        bool delta = false;
+        float3 delta_weight = float3(0);
         if (guide) {
             wo_world = vmfs[0].sample(rng);
             wo_local = frame.to_local(wo_world);
-        } else if (let local = m_bsdf.sample(wi_local, rng)) {
-            wo_local = local;
-            wo_world = frame.to_world(local);
+        } else if (let s = m_bsdf.sample_eval(wi_local, rng)) {
+            wo_local = s.wo;
+            wo_world = frame.to_world(s.wo);
+            delta = s.lobe == BSDFLobe::Delta;
+            delta_weight = s.weight;
             selected = MCState();
             selected_pos = HashGridPos();
             selected_level = params.mcpg.grid.target_level_for_pos(cur_pos, cam_pos, rng);
@@ -128,17 +132,24 @@ float3 trace_path(const ParameterBlock<Scene> scene,
         }
 
         // Stochastic MIS
-        float wo_p = 0.0;
-        if (can_guide) {
-            for (int i = 0; i < mc_samples; i++) {
-                wo_p += scores[i] * vmfs[i].pdf(wo_world);
+        float wo_p;
+        float3 bsdf;
+        if (delta) {
+            // the guiding mixture cannot produce a delta direction, only the BSDF strategy can
+            wo_p = bsdf_w;
+            bsdf = bsdf_w * delta_weight;
+        } else {
+            float guide_p = 0.0;
+            if (can_guide) {
+                for (int i = 0; i < mc_samples; i++) {
+                    guide_p += scores[i] * vmfs[i].pdf(wo_world);
+                }
+                guide_p /= score_sum;
             }
-            wo_p /= score_sum;
+            wo_p = bsdf_w * m_bsdf.pdf(wi_local, wo_local) +
+                   select(can_guide, p_guide, 0.0) * guide_p;
+            bsdf = m_bsdf.eval(wi_local, wo_local, rng);
         }
-        const float bsdf_w = can_guide ? (1.0 - p_guide) : 1.0;
-        wo_p = bsdf_w * m_bsdf.pdf(wi_local, wo_local) + select(can_guide, p_guide, 0.0) * wo_p;
-
-        const float3 bsdf = m_bsdf.eval(wi_local, wo_local, rng);
         const bool transmission = wi_local.z * wo_local.z < 0.f;
         Optional<RayDesc> next_ray = none;
         if (any(bsdf > 0.0))
@@ -151,7 +162,6 @@ float3 trace_path(const ParameterBlock<Scene> scene,
         if (let next = next_ray) {
             if (transmission) {
                 const IsotropicVolume interior = sp.surface_material.get_interior_volume();
-                current_ior /= interior.get_eta();
                 // leaving a surface puts the ray back into the medium enclosing the scene
                 if (dot(-ray.Direction, sp.get_face_normal()) >= 0.f)
                     medium = interior;
@@ -161,7 +171,7 @@ float3 trace_path(const ParameterBlock<Scene> scene,
             ray = next;
             // the last vertex is never scattered from, so its material sample would be dead
             sp = scene.trace_and_get_shading_point(
-                ray, merian_render_instance_mask, RenderContext(bounce, current_ior),
+                ray, merian_render_instance_mask, RenderContext(bounce),
                 DefaultLODSampler(), bounce + 1 < merian_render_max_path_length);
             next_pos = sp.pos;
 

include/merian-graph/nodes/render_pt_mcpg/volume.slang

@@ -170,7 +170,7 @@ void render_pixel(const uint2 pixel,
         ray.TMax = SCENE_RAY_TMAX;
         // single scattering never scatters off this surface, so the material sample would be dead
         const ShadingPoint sp = scene.trace_and_get_shading_point(
-            ray, merian_render_instance_mask, RenderContext(uint16_t(1), 1.0f),
+            ray, merian_render_instance_mask, RenderContext(uint16_t(1)),
             DefaultLODSampler(), false);
 
         float3 incident = sp.emission;

include/merian-graph/nodes/render_ssmm/render_ssmm.slang

@@ -146,6 +146,7 @@ void main(ParameterBlock<Scene> scene, ParameterBlock<SSMMBinding> params) {
 
     float3 sample_dirs[SSMM_MAX_SPP];
     float3 sample_weights[SSMM_MAX_SPP];
+    bool sample_delta[SSMM_MAX_SPP];
     float4 vmfs[SSMM_MAX_SPP];
 
     mc_state_t curr = mc_state_new(); // zero current state
@@ -170,6 +171,7 @@ void main(ParameterBlock<Scene> scene, ParameterBlock<SSMMBinding> params) {
                 mc_state_shuffle(tent, (WaveGetLaneIndex() + 1) % WaveGetLaneCount());
                 sample_dirs[s] = float3(0);
                 sample_weights[s] = float3(0);
+                sample_delta[s] = false;
 
                 read_neighbour_state(params.gbuffer, scene.camera.position, resolution, tent,
                                      sp.pos, normal, int2(pixel), mv, rng);
@@ -183,24 +185,29 @@ void main(ParameterBlock<Scene> scene, ParameterBlock<SSMMBinding> params) {
                 float3 direction = float3(0);
                 float3 position = float3(0);
                 bool bsdf_sample = false;
+                float3 throughput = float3(0);
                 do {
                     if (vmfs[s].w == 0 || rng.next_float() < merian_ssmm_bsdf_p) {
-                        let wo_local = bsdf.sample(wi_local, rng);
-                        if (!wo_local.hasValue)
+                        let bs_opt = bsdf.sample_eval(wi_local, rng);
+                        if (!bs_opt.hasValue)
                             break;
-                        direction = frame.to_world(wo_local.value);
+                        const ShadingFunctionSample bs = bs_opt.value;
+                        direction = frame.to_world(bs.wo);
                         if (dot(direction, normal) <= 1e-3 || dot(direction, geonormal) <= 1e-3)
                             break;
 
-                        pdf = bsdf.pdf(wi_local, wo_local.value);
+                        sample_delta[s] = bs.lobe == BSDFLobe::Delta;
+                        // a delta weight is already f / p
+                        pdf = sample_delta[s] ? 1.0 : bs.pdf;
+                        throughput =
+                            sample_delta[s] ? bs.weight : bsdf.eval(wi_local, bs.wo, rng);
                         bsdf_sample = true;
                     } else {
                         direction = vmf_sample_tokuyosh(vmfs[s].xyz, vmfs[s].w, rng.next_float2());
                         pdf = vmf_pdf_tokuyoshi(direction, vmfs[s].xyz, vmfs[s].w);
+                        throughput = bsdf.eval(wi_local, frame.to_local(direction), rng);
                     }
 
-                    const float3 throughput = bsdf.eval(wi_local, frame.to_local(direction), rng);
-
                     RayDesc ray;
                     // Pull back the ray such that it cannot excape through corners (and to
                     // prevent self collision)
@@ -209,7 +216,7 @@ void main(ParameterBlock<Scene> scene, ParameterBlock<SSMMBinding> params) {
                     ray.TMin = SCENE_RAY_TMIN;
                     ray.TMax = SCENE_RAY_TMAX;
                     const ShadingPoint next_sp = scene.trace_and_get_shading_point(
-                        ray, 0xffu, RenderContext(uint16_t(1), 1.0f));
+                        ray, 0xffu, RenderContext(uint16_t(1)));
 
                     position = next_sp.pos;
                     directContrib = throughput * next_sp.emission / pdf;
@@ -236,16 +243,22 @@ void main(ParameterBlock<Scene> scene, ParameterBlock<SSMMBinding> params) {
                 if (all(sample_weights[s] == float3(0)))
                     continue;
 
-                const float bsdf_pdf = bsdf.pdf(wi_local, frame.to_local(sample_dirs[s]));
-                float sum_pdf = 0;
-                for (int t = 0; t < merian_ssmm_spp; t++) {
-                    sum_pdf += vmfs[t].w > 0
-                                   ? vmf_pdf_tokuyoshi(sample_dirs[s], vmfs[t].xyz, vmfs[t].w)
-                                   : bsdf_pdf;
-                }
+                float sum_pdf;
+                if (sample_delta[s]) {
+                    // only the BSDF strategy, shared by the whole group, reaches a delta direction
+                    sum_pdf = merian_ssmm_bsdf_p * merian_ssmm_smis_group_size;
+                } else {
+                    const float bsdf_pdf = bsdf.pdf(wi_local, frame.to_local(sample_dirs[s]));
+                    sum_pdf = 0;
+                    for (int t = 0; t < merian_ssmm_spp; t++) {
+                        sum_pdf += vmfs[t].w > 0
+                                       ? vmf_pdf_tokuyoshi(sample_dirs[s], vmfs[t].xyz, vmfs[t].w)
+                                       : bsdf_pdf;
+                    }
 
-                sum_pdf = merian_ssmm_bsdf_p * merian_ssmm_smis_group_size * bsdf_pdf +
-                          (1 - merian_ssmm_bsdf_p) * sum_pdf;
+                    sum_pdf = merian_ssmm_bsdf_p * merian_ssmm_smis_group_size * bsdf_pdf +
+                              (1 - merian_ssmm_bsdf_p) * sum_pdf;
+                }
 
                 if (sum_pdf > 0) {
                     const float3 con = sample_weights[s] / sum_pdf;

include/merian-graph/nodes/shadertoy/shadertoy.hpp

@@ -59,6 +59,9 @@ class Shadertoy : public AbstractCompute {
     // Validates the composed shader; stores the error and returns false on failure.
     bool try_compile(const std::string& body);
 
+    // Unique per instance: several Shadertoy nodes coexist, and a module name binds to one source.
+    const std::string module_name;
+
     int shader_source_selector = 0;
     std::string shader_glsl;
     std::string shader_path = {0};

include/merian-shaders/scene/scene.slang

@@ -438,7 +438,7 @@ struct Scene {
         }
 
         const ShadingData sd = ShadingData(-ray.Direction, surface.pos, surface.uv, time, frame,
-                                           face_normal, ctx.bounce, ctx.ior, front_facing);
+                                           face_normal, ctx.bounce, front_facing);
 
         ShadingPoint sp;
         sp.pos = surface.pos;
@@ -485,7 +485,7 @@ struct Scene {
         const float3 pos = ray.Origin + ray.Direction * ENV_MAP_DISTANCE;
         const ShadingData sd =
             ShadingData(-ray.Direction, pos, float2(0), time, OrthonormalFrame(-ray.Direction),
-                        -ray.Direction, ctx.bounce, ctx.ior, true);
+                        -ray.Direction, ctx.bounce, true);
 
         ShadingPoint sp;
         sp.pos = pos;