simplify some integrators

Author: PearCoding

src/artic/technique/simpleguidedpathtracer.art

@@ -1,39 +1,35 @@
 struct SGPTRayPayload {
-    inv_bsdf_pdf:   f32,   // Inverse BSDF pdf
-    inv_guided_pdf: f32,   // Inverse Guided pdf
-    contrib:        Color, // Current contribution
-    depth:          i32,   // Current depth
-    eta:            f32,   // Current eta (n1 / n2)
-    gen_technique:  i32,   // Technique which generated the previous vertex (0=BSDF, 1=Guiding)
+    inv_pdf:       f32,   // Inverse pdf
+    contrib:       Color, // Current contribution
+    depth:         i32,   // Current depth
+    eta:           f32,   // Current eta (n1 / n2)
+    gen_technique: i32,   // Technique which generated the previous vertex (0=BSDF, 1=Guiding)
 }
 
 fn @write_sgptraypayload(payload: RayPayload, pt: SGPTRayPayload) -> () {
-    payload.set(0, pt.inv_bsdf_pdf);
-    payload.set(1, pt.inv_guided_pdf);
-    payload.set(2, pt.contrib.r);
-    payload.set(3, pt.contrib.g);
-    payload.set(4, pt.contrib.b);
-    payload.set(5, pt.depth as f32);
-    payload.set(6, pt.eta);
-    payload.set(7, pt.gen_technique as f32);
+    payload.set(0, pt.inv_pdf);
+    payload.set(1, pt.contrib.r);
+    payload.set(2, pt.contrib.g);
+    payload.set(3, pt.contrib.b);
+    payload.set(4, pt.depth as f32);
+    payload.set(5, pt.eta);
+    payload.set(6, pt.gen_technique as f32);
 }
 
 fn @unwrap_sgptraypayload(payload: RayPayload) = SGPTRayPayload {
-    inv_bsdf_pdf   = payload.get(0),
-    inv_guided_pdf = payload.get(1),
-    contrib        = make_color(payload.get(2), payload.get(3), payload.get(4), 1),
-    depth          = payload.get(5) as i32,
-    eta            = payload.get(6),
-    gen_technique  = payload.get(7) as i32,
+    inv_pdf       = payload.get(0),
+    contrib       = make_color(payload.get(1), payload.get(2), payload.get(3), 1),
+    depth         = payload.get(4) as i32,
+    eta           = payload.get(5),
+    gen_technique = payload.get(6) as i32,
 };
 
 fn @init_sgpt_raypayload(payload: RayPayload) = write_sgptraypayload(payload, SGPTRayPayload {
-    inv_bsdf_pdf   = 0,
-    inv_guided_pdf = 0,
-    contrib        = color_builtins::white,
-    depth          = 1,
-    eta            = 1,
-    gen_technique  = 0
+    inv_pdf       = 0,
+    contrib       = color_builtins::white,
+    depth         = 1,
+    eta           = 1,
+    gen_technique = 0
 });
 
 struct SimpleGuidingTechnique {
@@ -42,13 +38,9 @@ struct SimpleGuidingTechnique {
     prob:   fn () -> f32 // Probability to use this guider
 }
 
-fn @make_sgpt_renderer(device: Device, max_path_len: i32, min_path_len: i32, spi: i32, light_selector: LightSelector, clamp_value: f32, enable_nee: bool, enable_aovs: bool, guider: SimpleGuidingTechnique) -> Technique {
+fn @make_sgpt_renderer(_device: Device, max_path_len: i32, min_path_len: i32, _spi: i32, light_selector: LightSelector, clamp_value: f32, enable_nee: bool, _enable_aovs: bool, guider: SimpleGuidingTechnique) -> Technique {
     let offset : f32  = 0.001;
 
-    let aov_bsdf   = if enable_aovs { device.load_aov_image("BSDF Weights",   spi, 0) } else { make_empty_aov_image(0, 0) };
-    let aov_guided = if enable_aovs { device.load_aov_image("Guided Weights", spi, 0) } else { make_empty_aov_image(0, 0) };
-    let aov_nee    = if enable_aovs { device.load_aov_image("NEE Weights",    spi, 0) } else { make_empty_aov_image(0, 0) };
-
     let handle_color = make_std_color_handler(clamp_value);
 
     fn @on_shadow( ctx: ShadingContext
@@ -129,25 +121,11 @@ fn @make_sgpt_renderer(device: Device, max_path_len: i32, min_path_len: i32, spi
             let pt  = unwrap_sgptraypayload(payload);
             let dot = -vec3_dot(ctx.ray.dir, ctx.surf.local.col(2));
             if dot > flt_eps { // Only contribute proper aligned directions
-                let emit    = mat.emission(ctx);
-                let pdf_s   = emit.pdf.as_solid(dot, ctx.hit.distance * ctx.hit.distance);
-
-                let mis_denom = 1 + if pt.gen_technique == 0 { safe_div(pt.inv_bsdf_pdf, pt.inv_guided_pdf) } else { safe_div(pt.inv_guided_pdf, pt.inv_bsdf_pdf) };
-                let mis       = if enable_nee { 
-                    let inv_pdf_b = if pt.gen_technique == 0 { pt.inv_bsdf_pdf } else { pt.inv_guided_pdf }; // The actual (inverse) pdf used for the previous vertex
-                    let pdf_l_s   = light_selector.pdf(mat.light, ctx.ray.org) * pdf_s;
-                    1 / (mis_denom + inv_pdf_b * pdf_l_s)
-                } else {
-                    1 / mis_denom
-                };
+                let emit  = mat.emission(ctx);
+                let pdf_s = emit.pdf.as_solid(dot, ctx.hit.distance * ctx.hit.distance);
+                let mis   = if enable_nee { 1 / (1 + pt.inv_pdf * light_selector.pdf(mat.light, ctx.ray.org) * pdf_s) } else { 1:f32 };
 
                 let contrib = handle_color(color_mulf(color_mul(pt.contrib, emit.intensity), mis));
-                
-                if pt.gen_technique == 0 {
-                    aov_bsdf.splat(ctx.pixel, contrib);
-                } else {
-                    aov_guided.splat(ctx.pixel, contrib);
-                }
 
                 return(make_option(contrib))
             }
@@ -168,29 +146,18 @@ fn @make_sgpt_renderer(device: Device, max_path_len: i32, min_path_len: i32, spi
             if light.infinite && !light.delta {
                 inflights += 1;
 
-                let emit  = light.emission(ctx);
+                let emit = light.emission(ctx);
+                if is_black_eps(emit, flt_eps) { continue() }
+
                 let pdf   = light.pdf_direct(ctx.ray, make_invalid_surface_element());
                 let pdf_s = pdf.as_solid(1, 1/* We assume infinite lights are always given in solid angle measure */);
-                
-                let mis_denom = 1 + if pt.gen_technique == 0 { safe_div(pt.inv_bsdf_pdf, pt.inv_guided_pdf) } else { safe_div(pt.inv_guided_pdf, pt.inv_bsdf_pdf) };
-                let mis       = if enable_nee { 
-                    let inv_pdf_b = if pt.gen_technique == 0 { pt.inv_bsdf_pdf } else { pt.inv_guided_pdf }; // The actual (inverse) pdf used for the previous vertex
-                    let pdf_l_s   = light_selector.pdf(light, ctx.ray.org) * pdf_s;
-                    1 / (mis_denom + inv_pdf_b * pdf_l_s)
-                } else {
-                    1 / mis_denom
-                };
+                let mis   = if enable_nee { 1 / (1 + pt.inv_pdf * light_selector.pdf(light, ctx.ray.org) * pdf_s) } else { 1:f32 };
 
                 color = color_add(color, handle_color(color_mulf(color_mul(pt.contrib, emit), mis)));
             }
         }
 
         if inflights > 0 {
-            if pt.gen_technique == 0 {
-                aov_bsdf.splat(ctx.pixel, color);
-            } else {
-                aov_guided.splat(ctx.pixel, color);
-            }
             make_option(color)
         } else {
             Option[Color]::None
@@ -221,25 +188,29 @@ fn @make_sgpt_renderer(device: Device, max_path_len: i32, min_path_len: i32, spi
                 return(Option[Ray]::None)
             }
 
-            let inv_guided_pdf = 1 / (g_prob * pdf_g_s);
-            let mat_eval       = mat.bsdf.eval(in_dir, out_dir);
+            let full_pdf = (1 - g_prob) * mat.bsdf.pdf(in_dir, out_dir) + g_prob * pdf_g_s;
+            let inv_pdf  = 1 / full_pdf;
+            let mat_eval = mat.bsdf.eval(in_dir, out_dir);
 
-            let contrib = color_mul(pt.contrib, color_mulf(mat_eval, inv_guided_pdf));
+            let contrib = color_mul(pt.contrib, color_mulf(mat_eval, inv_pdf));
             let rr_prob = if pt.depth + 1 > min_path_len { russian_roulette_pbrt(color_mulf(contrib, pt.eta * pt.eta), 0.95) } else { 1.0 };
             if rnd.next_f32() >= rr_prob {
                 return(Option[Ray]::None)
             }
 
-            let inv_bsdf_pdf   = safe_div(1, (1 - g_prob) * mat.bsdf.pdf(in_dir, out_dir));
-            let new_contrib    = color_mulf(contrib, 1 / rr_prob);
+            let new_contrib = color_mulf(contrib, 1 / rr_prob);
+
+            // This might happen due to wrong hemisphere, texture, etc
+            if color_average(new_contrib) <= flt_eps {
+                return(Option[Ray]::None)
+            }
 
             write_sgptraypayload(payload, SGPTRayPayload {
-                inv_bsdf_pdf   = inv_bsdf_pdf,
-                inv_guided_pdf = inv_guided_pdf,
-                contrib        = new_contrib,
-                depth          = pt.depth + 1,
-                eta            = pt.eta, // * mat_sample.eta (TODO)
-                gen_technique  = 1 /* Guiding */
+                inv_pdf       = inv_pdf,
+                contrib       = new_contrib,
+                depth         = pt.depth + 1,
+                eta           = pt.eta, // * mat_sample.eta (TODO)
+                gen_technique = 1 /* Guiding */
             });
             make_option(
                 make_ray(ctx.surf.point, in_dir, offset, flt_max, ray_flag_bounce)
@@ -252,23 +223,29 @@ fn @make_sgpt_renderer(device: Device, max_path_len: i32, min_path_len: i32, spi
                     return(Option[Ray]::None)
                 }
 
-                let contrib = color_mul(pt.contrib, mat_sample.color/* Pdf and cosine are already applied!*/);
+                let full_pdf = if mat_sample.is_delta { mat_sample.pdf } else { (1 - g_prob) * mat_sample.pdf + g_prob * guider.pdf(mat_sample.in_dir, out_dir) };
+                let inv_pdf  = 1/ full_pdf;
+                let mat_eval = color_mulf(mat_sample.color, mat_sample.pdf);
+
+                let contrib = color_mul(pt.contrib, color_mulf(mat_eval, inv_pdf));
                 let rr_prob = if pt.depth + 1 > min_path_len { russian_roulette_pbrt(color_mulf(contrib, pt.eta * pt.eta), 0.95) } else { 1.0 };
                 if rnd.next_f32() >= rr_prob {
                     return(Option[Ray]::None)
                 }
 
-                let inv_bsdf_pdf   = if mat_sample.is_delta { 0 } else { 1 / ((1 - g_prob) * mat_sample.pdf) };
-                let inv_guided_pdf = if mat_sample.is_delta { 0 } else { safe_div(1, g_prob * guider.pdf(mat_sample.in_dir, out_dir)) };
                 let new_contrib    = color_mulf(contrib, 1 / (rr_prob * (1 - g_prob)));
+            
+                // This might happen due to wrong hemisphere, texture, etc
+                if color_average(new_contrib) <= flt_eps {
+                    return(Option[Ray]::None)
+                }
 
                 write_sgptraypayload(payload, SGPTRayPayload {
-                    inv_bsdf_pdf   = inv_bsdf_pdf,
-                    inv_guided_pdf = inv_guided_pdf,
-                    contrib        = new_contrib,
-                    depth          = pt.depth + 1,
-                    eta            = pt.eta * mat_sample.eta,
-                    gen_technique  = 0 /* BSDF */
+                    inv_pdf       = inv_pdf,
+                    contrib       = new_contrib,
+                    depth         = pt.depth + 1,
+                    eta           = pt.eta * mat_sample.eta,
+                    gen_technique = 0 /* BSDF */
                 });
                 make_option(
                     make_ray(ctx.surf.point, mat_sample.in_dir, offset, flt_max, ray_flag_bounce)
@@ -279,20 +256,11 @@ fn @make_sgpt_renderer(device: Device, max_path_len: i32, min_path_len: i32, spi
         }
     }
 
-    fn @on_shadow_miss( ctx: ShadingContext
-                      , _shader: MaterialShader
-                      , _: RayPayload
-                      , color: Color) -> Option[Color] {
-        aov_nee.splat(ctx.pixel, color);
-        make_option(color)
-    }
-
     make_empty_technique().{
-        on_hit         = on_hit,
-        on_miss        = on_miss,
-        on_shadow      = on_shadow,
-        on_bounce      = on_bounce,
-        on_shadow_miss = if enable_aovs { on_shadow_miss } else { TechniqueNoShadowMissFunction },
+        on_hit    = on_hit,
+        on_miss   = on_miss,
+        on_shadow = on_shadow,
+        on_bounce = on_bounce
     }
 }