Some light experiments

PearCoding · PearCoding · commit 9a971ef8b91d · 2022-07-31T22:27:33.000+02:00
diff --git a/scenes/many_point_lights_scene.json b/scenes/many_point_lights_scene.json
@@ -1,8 +1,7 @@
 {
 	"technique": {
 		"type": "path",
-		"max_depth": 64,
-		"use_uniform_light_selector": false
+		"max_depth": 64
 	},
 	"camera": {
 		"type": "perspective",
diff --git a/src/artic/CMakeLists.txt b/src/artic/CMakeLists.txt
@@ -93,6 +93,7 @@ set(ARTIC_EXTRA_SRC
     ${CMAKE_CURRENT_SOURCE_DIR}/impl/emitter.art
     ${CMAKE_CURRENT_SOURCE_DIR}/impl/fresnel.art
     ${CMAKE_CURRENT_SOURCE_DIR}/impl/interval.art
+    ${CMAKE_CURRENT_SOURCE_DIR}/impl/light_hierarchy.art
     ${CMAKE_CURRENT_SOURCE_DIR}/impl/light_selector.art
     ${CMAKE_CURRENT_SOURCE_DIR}/impl/math.art
     ${CMAKE_CURRENT_SOURCE_DIR}/impl/microfacet.art
diff --git a/src/artic/impl/light_hierarchy.art b/src/artic/impl/light_hierarchy.art
@@ -0,0 +1,109 @@
+// Based on:
+// Moreau, P., Clarberg, P. (2019). Importance Sampling of Many Lights on the GPU.
+// In: Haines, E., Akenine-Möller, T. (eds) Ray Tracing Gems.
+// Apress, Berkeley, CA. https://doi.org/10.1007/978-1-4842-4427-2_18
+
+mod light_hierarchy {
+    use super as all;
+    use super::math_builtins;
+
+    type Vec3         = all::Vec3;
+    type RndState     = all::RndState;
+    type DeviceBuffer = all::DeviceBuffer;
+
+    struct LightHierarchyEntry {
+        pos:  Vec3,
+        dir:  Vec3,
+        flux: f32,
+        id:   i32,
+        leaf: bool
+    }
+
+    fn @load_entry(id: i32, data: all::DeviceBuffer) -> LightHierarchyEntry {
+        let e1 = data.load_vec4(id * 8 + 0);
+        let e2 = data.load_vec4(id * 8 + 4);
+
+        let index = all::bitcast[i32](e2.w);
+        LightHierarchyEntry {
+            pos  = all::make_vec3(e1.x, e1.y, e1.z),
+            dir  = all::make_vec3(e2.x, e2.y, e2.z),
+            flux = e1.w,
+            id   = all::select(index < 0, -index - 1, index),
+            leaf = index >= 0
+        }
+    }
+
+    fn @get_entry_cost(entry: LightHierarchyEntry, pos: Vec3) -> f32 {
+        // TODO: Normal direction?
+        let cdir  = all::vec3_sub(entry.pos, pos);
+        let dist2 = all::vec3_len2(cdir);
+        let cos_d = math_builtins::fabs(all::vec3_dot(entry.dir, cdir)); // Has dist applied
+
+        entry.flux * cos_d / math_builtins::fmax(0.0001:f32, dist2)
+    }
+
+    fn @get_left_prop(left: LightHierarchyEntry, right: LightHierarchyEntry, pos: Vec3) -> f32 {
+        let cl = get_entry_cost(left, pos);
+        let cr = get_entry_cost(right, pos);
+        cl / (cl + cr)
+    }
+
+    fn @random_select_left(rnd: &mut RndState, left: LightHierarchyEntry, right: LightHierarchyEntry, pos: Vec3) -> (bool, f32) {
+        let prop = get_left_prop(left, right, pos);
+        (all::randf(rnd) < prop, prop)
+    }
+
+    fn @sample_light_id(rnd: &mut RndState, pos: Vec3, data: DeviceBuffer) -> (i32, f32) {
+        let mut pdf   = 1:f32;
+        let mut entry = load_entry(0, data);
+        while !entry.leaf {
+            let (is_left, prop) = random_select_left(rnd, load_entry(entry.id, data), load_entry(entry.id+1, data), pos);
+
+            entry = load_entry(all::select(is_left, entry.id, entry.id+1), data);
+            pdf  *= all::select(is_left, prop, 1-prop);
+        }
+
+        (entry.id, pdf)
+    }
+
+    fn @compute_pdf(light: all::Light, pos: Vec3, codes: DeviceBuffer, data: DeviceBuffer) -> f32 {
+        let mut code  = all::bitcast[u32](codes.load_i32(light.id));
+        let mut pdf   = 1:f32;
+        let mut entry = load_entry(0, data);
+        while !entry.leaf {
+            let left  = load_entry(entry.id, data);
+            let right = load_entry(entry.id+1, data);
+            let prop  = get_left_prop(left, right, pos);
+
+            if (code & 0x1) == 0 {
+                entry = left;
+                pdf  *= prop;
+            } else {
+                entry = right;
+                pdf  *= 1 - prop;
+            }
+
+            code >>= 1;
+        }
+
+        all::select(entry.id == light.id, pdf, 0:f32)
+    }
+}
+
+struct LightHierarchy {
+    sample: fn (&mut RndState, Vec3) -> (Light, f32),
+    pdf:    fn (Light, Vec3) -> f32
+}
+
+fn @make_light_hierarchy(finite_lights: LightTable, full: DeviceBuffer) -> LightHierarchy {
+    let codes = full;
+    let data  = shift_device_buffer(round_up(finite_lights.count, 4), 0, full);
+
+    LightHierarchy {
+        sample = @|rnd, pos| {
+            let (id, pdf) = light_hierarchy::sample_light_id(rnd, pos, data);
+            (finite_lights.get(id), pdf)
+        },
+        pdf = @|light, pos| light_hierarchy::compute_pdf(light, pos, codes, data)
+    }
+}
diff --git a/src/artic/impl/light_selector.art b/src/artic/impl/light_selector.art
@@ -1,16 +1,16 @@
 // Result of sampling a direction
 struct LightSelector {
     count:     i32,
-    sample:    fn (&mut RndState) -> (Light, f32),
-    pdf:       fn (Light) -> f32,
+    sample:    fn (&mut RndState, Vec3) -> (Light, f32),
+    pdf:       fn (Light, Vec3) -> f32,
     infinites: LightTable,
     finites:   LightTable
 }
 
 fn @make_null_light_selector() = LightSelector {
     count     = 0,
-    sample    = @|_| (make_null_light(0), 1),
-    pdf       = @|_| 1,
+    sample    = @|_,_| (make_null_light(0), 1),
+    pdf       = @|_,_| 1,
     infinites = make_empty_light_table(),
     finites   = make_empty_light_table()
 };
@@ -25,21 +25,20 @@ fn @pick_light_id(rnd: &mut RndState, num_lights: i32) {
 }
 
 fn @make_uniform_light_selector(infinite_lights: LightTable, finite_lights: LightTable) -> LightSelector {
-    let num_lights     = infinite_lights.count + finite_lights.count;
-    let pdf_inf_lights = if infinite_lights.count == 0 { 1 } else { 1 / (infinite_lights.count as f32) };
-    let pdf_fin_lights = if finite_lights.count == 0   { 1 } else { 1 / (finite_lights.count as f32) };
+    let num_lights = infinite_lights.count + finite_lights.count;
+    let pdf_lights = if num_lights == 0 { 1 } else { 1 / (num_lights as f32) };
 
     LightSelector {
         count  = num_lights,
-        sample = @|rnd| {
+        sample = @|rnd,_| {
             let id = pick_light_id(rnd, num_lights);
             if id < infinite_lights.count {
-                (infinite_lights.get(id), pdf_inf_lights)
+                (infinite_lights.get(id), pdf_lights)
             } else {
-                (finite_lights.get(id - infinite_lights.count), pdf_fin_lights)
+                (finite_lights.get(id - infinite_lights.count), pdf_lights)
             }
         },
-        pdf       = @|light| select(light.infinite, pdf_inf_lights, pdf_fin_lights),
+        pdf       = @|_,_| pdf_lights,
         infinites = infinite_lights,
         finites   = finite_lights
     }
@@ -49,8 +48,8 @@ fn @make_cdf_light_selector(infinite_lights: LightTable, finite_lights: LightTab
     if infinite_lights.count == 0 {
         LightSelector {
             count     = sampler.func_size,
-            sample    = @|rnd| { let s = sampler.sample_discrete(randf(rnd)); (finite_lights.get(s.off), s.pdf) },
-            pdf       = @|light| sampler.pdf_discrete(light.id).pdf,
+            sample    = @|rnd,_| { let s = sampler.sample_discrete(randf(rnd)); (finite_lights.get(s.off), s.pdf) },
+            pdf       = @|light,_| sampler.pdf_discrete(light.id).pdf,
             infinites = infinite_lights,
             finites   = finite_lights
         }
@@ -59,24 +58,54 @@ fn @make_cdf_light_selector(infinite_lights: LightTable, finite_lights: LightTab
         let infinite_ratio      = 0.5:f32;
         LightSelector {
             count  = infinite_lights.count + sampler.func_size,
-            sample = @|rnd| {
+            sample = @|rnd,_| {
                 let q = randf(rnd);
                 if q < infinite_ratio {
                     let id = pick_light_id(rnd, infinite_lights.count);
-                    (infinite_lights.get(id), pdf_infinite_lights)
+                    (infinite_lights.get(id), pdf_infinite_lights * infinite_ratio)
                 } else {
                     let s = sampler.sample_discrete(randf(rnd));
-                    (finite_lights.get(s.off), s.pdf)
+                    (finite_lights.get(s.off), s.pdf * (1-infinite_ratio))
                 }
             },
-            pdf       = @|light| if light.infinite { pdf_infinite_lights } else { sampler.pdf_discrete(light.id).pdf },
+            pdf       = @|light,_| if light.infinite { pdf_infinite_lights * infinite_ratio } else { sampler.pdf_discrete(light.id).pdf * (1-infinite_ratio) },
             infinites = infinite_lights,
             finites   = finite_lights
         }
     }
 }
 
-fn @make_hierarchy_light_selector(infinite_lights: LightTable, finite_lights: LightTable, _data: DeviceBuffer) -> LightSelector {
-    make_uniform_light_selector(infinite_lights, finite_lights)
-    // TODO
+fn @make_hierarchy_light_selector(infinite_lights: LightTable, finite_lights: LightTable, data: DeviceBuffer) -> LightSelector {
+    if finite_lights.count == 0 {
+        make_uniform_light_selector(infinite_lights, finite_lights)
+    } else if infinite_lights.count == 0 {
+        let hierarchy = make_light_hierarchy(finite_lights, data);
+        LightSelector {
+            count     = finite_lights.count,
+            sample    = hierarchy.sample,
+            pdf       = hierarchy.pdf,
+            infinites = infinite_lights,
+            finites   = finite_lights
+        }
+    } else {
+        let pdf_infinite_lights = 1 / (infinite_lights.count as f32);
+        let infinite_ratio      = 0.5:f32;
+        let hierarchy = make_light_hierarchy(finite_lights, data);
+        LightSelector {
+            count     = finite_lights.count,
+            sample    = @|rnd, from_pos| {
+                let q = randf(rnd);
+                if q < infinite_ratio {
+                    let id = pick_light_id(rnd, infinite_lights.count);
+                    (infinite_lights.get(id), pdf_infinite_lights * infinite_ratio)
+                } else {
+                    let (l, pdf) = hierarchy.sample(rnd, from_pos);
+                    (l, pdf * (1-infinite_ratio))
+                }
+            },
+            pdf       = @|light, from_pos| if light.infinite { pdf_infinite_lights * infinite_ratio } else { hierarchy.pdf(light, from_pos) * (1-infinite_ratio) },
+            infinites = infinite_lights,
+            finites   = finite_lights
+        }
+    }
 }
diff --git a/src/artic/impl/technique/pathtracer.art b/src/artic/impl/technique/pathtracer.art
@@ -66,7 +66,7 @@ fn @make_path_renderer(max_path_len: i32, light_selector: LightSelector, aovs: A
             return(ShadowRay::None)
         }
 
-        let (light, light_select_pdf) = light_selector.sample(rnd);
+        let (light, light_select_pdf) = light_selector.sample(rnd, ctx.surf.point);
 
         let sample_direct = light.sample_direct;
         let light_sample  = @sample_direct(rnd, ctx.surf);
@@ -120,7 +120,7 @@ fn @make_path_renderer(max_path_len: i32, light_selector: LightSelector, aovs: A
             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     = 1 / (1 + pt.inv_pdf * light_selector.pdf(mat.light) * pdf_s);
+                let mis     = 1 / (1 + pt.inv_pdf * light_selector.pdf(mat.light, ctx.ray.org) * pdf_s);
                 let contrib = handle_color(color_mulf(color_mul(pt.contrib, emit.intensity), mis));
                 
                 aov_di.splat(ctx.pixel, contrib);
@@ -148,7 +148,7 @@ fn @make_path_renderer(max_path_len: i32, light_selector: LightSelector, aovs: A
                 let emit  = light.emission(make_miss_shading_context(pixel, ray));
                 let pdf   = light.pdf_direct(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   = 1 / (1 + pt.inv_pdf * light_selector.pdf(light) * pdf_s);
+                let mis   = 1 / (1 + pt.inv_pdf * light_selector.pdf(light, ray.org) * pdf_s);
                 color     = color_add(color, handle_color(color_mulf(color_mul(pt.contrib, emit), mis)));
             }
         }
diff --git a/src/artic/impl/technique/photonmapper.art b/src/artic/impl/technique/photonmapper.art
@@ -151,7 +151,7 @@ fn @make_ppm_light_emitter(light_selector: LightSelector, iter: i32) -> RayEmitt
         hash = fnv_hash(hash, y as u32);
         let mut rnd = hash /*as RndState*/;
         
-        let (light, light_pdf) = light_selector.sample(&mut rnd);
+        let (light, light_pdf) = light_selector.sample(&mut rnd, vec3_expand(0));
         let sample_emission    = light.sample_emission;
         let light_sample       = @sample_emission(rnd);
         
diff --git a/src/artic/impl/technique/volpathtracer.art b/src/artic/impl/technique/volpathtracer.art
@@ -59,7 +59,7 @@ fn @make_volume_path_renderer(max_path_len: i32, light_selector: LightSelector,
             return(ShadowRay::None)
         }
 
-        let (light, light_select_pdf) = light_selector.sample(rnd);
+        let (light, light_select_pdf) = light_selector.sample(rnd, ctx.surf.point);
         
         let sample_direct = light.sample_direct;
         let light_sample  = @sample_direct(rnd, ctx.surf);
@@ -124,7 +124,7 @@ fn @make_volume_path_renderer(max_path_len: i32, light_selector: LightSelector,
                 let emit     = mat.emission(ctx);
                 let inv_pdf  = math_builtins::fmax[f32](0/*Ignore medium interactions*/, pt.inv_pdf);
                 let pdf_s    = emit.pdf.as_solid(dot, ctx.hit.distance * ctx.hit.distance);
-                let mis      = 1 / (1 + inv_pdf * light_selector.pdf(mat.light) * pdf_s);
+                let mis      = 1 / (1 + inv_pdf * light_selector.pdf(mat.light, ctx.ray.org) * pdf_s);
                 let vol      = medium.eval(ctx.ray.org, ctx.surf.point);
                 let contrib  = handle_color(color_mulf(color_mul(pt.contrib, color_mul(emit.intensity, vol)), mis));
                 
@@ -152,7 +152,7 @@ fn @make_volume_path_renderer(max_path_len: i32, light_selector: LightSelector,
                 let emit  = light.emission(make_miss_shading_context(pixel, ray));
                 let pdf   = light.pdf_direct(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   = 1 / (1 + math_builtins::fmax[f32](0/*Ignore medium interactions*/, pt.inv_pdf) * light_selector.pdf(light) * pdf_s);
+                let mis   = 1 / (1 + math_builtins::fmax[f32](0/*Ignore medium interactions*/, pt.inv_pdf) * light_selector.pdf(light, ray.org) * pdf_s);
                 let vol   = medium.eval_inf(ray.org, ray.dir);
                 color     = color_add(color, handle_color(color_mulf(color_mul(pt.contrib, color_mul(emit, vol)), mis)));
             }
diff --git a/src/artic/render/buffer.art b/src/artic/render/buffer.art
@@ -39,5 +39,75 @@ struct DeviceBuffer {
     has_alignment:  bool // True if vec2, vec3, int2 and int3 are expected to be like vec4 or int4 in memory
 }
 
+fn @make_null_device_buffer() = DeviceBuffer {
+    add_atomic_i32 = @|_, _| 0:i32,
+    add_atomic_f32 = @|_, _| 0:f32,
+    min_atomic_i32 = @|_, _| 0:i32,
+    max_atomic_i32 = @|_, _| 0:i32,
+    load_i32_host  = @|_| 0:i32,
+    store_i32_host = @|_, _| {},
+    copy_from_host = @|_, _, _| {},
+    copy_to_host   = @|_, _, _| {},
+    load_i32       = @|_| 0:i32,
+    load_f32       = @|_| 0:f32,
+    load_vec2      = @|_| make_vec2(0,0),
+    load_vec3      = @|_| make_vec3(0,0,0),
+    load_vec4      = @|_| make_vec4(0,0,0,0),
+    load_int2      = @|_| (0,0),
+    load_int3      = @|_| (0,0,0),
+    load_int4      = @|_| (0,0,0,0),
+    load_mat3x3    = @|_| mat3x3_identity(),
+    load_mat3x4    = @|_| mat3x4_identity(),
+    load_mat4x4    = @|_| mat4x4_identity(),
+    store_i32      = @|_, _| {},
+    store_f32      = @|_, _| {},
+    store_vec2     = @|_, _| {},
+    store_vec3     = @|_, _| {},
+    store_vec4     = @|_, _| {},
+    store_int2     = @|_, _, _| {},
+    store_int3     = @|_, _, _, _| {},
+    store_int4     = @|_, _, _, _, _| {},
+    store_mat3x3   = @|_, _| {},
+    store_mat3x4   = @|_, _| {},
+    store_mat4x4   = @|_, _| {},
+    count          = 0,
+    has_alignment  = true
+};
+
+fn @shift_device_buffer(off: i32, count: i32, buffer: DeviceBuffer) = DeviceBuffer {
+    add_atomic_i32 = @|id, v| buffer.add_atomic_i32(id + off, v),
+    add_atomic_f32 = @|id, v| buffer.add_atomic_f32(id + off, v),
+    min_atomic_i32 = @|id, v| buffer.min_atomic_i32(id + off, v),
+    max_atomic_i32 = @|id, v| buffer.max_atomic_i32(id + off, v),
+    load_i32_host  = @|id| buffer.load_i32_host(id + off),
+    store_i32_host = @|id, v| buffer.store_i32_host(id + off, v),
+    copy_from_host = @|s, e, ptr| buffer.copy_from_host(s + off, e + off, ptr),
+    copy_to_host   = @|s, e, ptr| buffer.copy_to_host(s + off, e + off, ptr),
+    load_i32       = @|id| buffer.load_i32(id + off),
+    load_f32       = @|id| buffer.load_f32(id + off),
+    load_vec2      = @|id| buffer.load_vec2(id + off),
+    load_vec3      = @|id| buffer.load_vec3(id + off),
+    load_vec4      = @|id| buffer.load_vec4(id + off),
+    load_int2      = @|id| buffer.load_int2(id + off),
+    load_int3      = @|id| buffer.load_int3(id + off),
+    load_int4      = @|id| buffer.load_int4(id + off),
+    load_mat3x3    = @|id| buffer.load_mat3x3(id + off),
+    load_mat3x4    = @|id| buffer.load_mat3x4(id + off),
+    load_mat4x4    = @|id| buffer.load_mat4x4(id + off),
+    store_i32      = @|id, v| buffer.store_i32(id + off, v),
+    store_f32      = @|id, v| buffer.store_f32(id + off, v),
+    store_vec2     = @|id, v| buffer.store_vec2(id + off, v),
+    store_vec3     = @|id, v| buffer.store_vec3(id + off, v),
+    store_vec4     = @|id, v| buffer.store_vec4(id + off, v),
+    store_int2     = @|id, v1, v2| buffer.store_int2(id + off, v1, v2),
+    store_int3     = @|id, v1, v2, v3| buffer.store_int3(id + off, v1, v2, v3),
+    store_int4     = @|id, v1, v2, v3, v4| buffer.store_int4(id + off, v1, v2, v3, v4),
+    store_mat3x3   = @|id, v| buffer.store_mat3x3(id + off, v),
+    store_mat3x4   = @|id, v| buffer.store_mat3x4(id + off, v),
+    store_mat4x4   = @|id, v| buffer.store_mat4x4(id + off, v),
+    count          = count,
+    has_alignment  = buffer.has_alignment
+};
+
 // Unsized device buffer accessor
 type DeviceBufferAccessor = fn (&[u8]) -> DeviceBuffer;
diff --git a/src/backend/runtime/container/PointBvh.h b/src/backend/runtime/container/PointBvh.h
diff --git a/src/backend/runtime/container/PointBvh.inl b/src/backend/runtime/container/PointBvh.inl
diff --git a/src/backend/runtime/light/LightHierarchy.cpp b/src/backend/runtime/light/LightHierarchy.cpp
diff --git a/src/backend/runtime/loader/LoaderTechnique.cpp b/src/backend/runtime/loader/LoaderTechnique.cpp
