@woosh/meep-engine 3.69.0 → 3.70.0

package/src/shade/renderer/global_illumination/lpv/placement/graph_generate_probe_locations.js

@@ -1,377 +1,373 @@
-import { assert } from "../../../../../core/assert.js";
-import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
-import { AABB3 } from "../../../../../core/geom/3d/aabb/AABB3.js";
-import Vector3 from "../../../../../core/geom/Vector3.js";
-import { delay } from "../../../../../core/process/delay.js";
-import { FrameGraph } from "../../../../../engine/graphics/render/frame_graph/FrameGraph.js";
-import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
-import { ShadeGPUCommandContext } from "../../../../device/ShadeGPUCommandContext.js";
-import { atomic_u32, vec3u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { inspect_gpu_buffer_typed } from "../../../buffer/inspect_gpu_buffer_typed.js";
-import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_STRUCT.js";
-import { BVH2_NODE_STRUCT } from "../../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
-import { BVH_STRUCT } from "../../../shader/chunk/bvh/BVH_STRUCT.js";
-import { AABB3_STRUCT } from "../../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
-import { chunk_array_to_aabb3 } from "../../../shader/chunk/geometry/aabb3/chunk_array_to_aabb3.js";
-import { chunk_ray_query_occluded } from "../../../shader/chunk/geometry/ray/chunk_ray_query_occluded.js";
-import {
-    chunk_scene_point_query_is_inside_geometry
-} from "../../../shader/chunk/geometry/ray/chunk_scene_point_query_is_inside_geometry.js";
-import { RAY_STRUCT } from "../../../shader/chunk/geometry/ray/RAY_STRUCT.js";
-import { chunk_scene_point_query_nearest } from "../../../shader/chunk/sdf/chunk_scene_point_query_nearest.js";
-import { SURFACE_POINT_3D } from "../../../shader/chunk/sdf/SURFACE_POINT_3D.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { sr_create_group_RTX } from "../../../geometry/sr_create_group_RTX.js";
-import { chunk_refine_probe_placement } from "./chunk_refine_probe_placement.js";
-
-const INITIAL_PLACEMENT_SETTINGS_STRUCT = WebGPUStruct.from({
-    bounds: AABB3_STRUCT,
-    resolution: vec3u
-});
-
-const POSITION_COLLECTION_STRUCT = WebGPUStruct.from({
-    count: atomic_u32,
-    data: WebGPUArray.f32
-});
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", INITIAL_PLACEMENT_SETTINGS_STRUCT)
-    .addStorageBuffer("out", POSITION_COLLECTION_STRUCT, true)
-;
-
-sr_create_group_RTX(resources)
-
-const chunk_attempt_refine_probe_placement = CodeChunk.from(
-    //language=WGSL
-    `
-fn attempt_refine_probe_placement(
-    output:ptr<function,vec3f>,
-    probe_origin: vec3f,
-    hit: ${SURFACE_POINT_3D.wgsl_ref},
-    cell_size: vec3f,
- ) -> bool{
-    var probe_position = probe_origin;
-    
-    let to_hit = hit.position - probe_origin; 
-    
-    // don't allow motion within the entire cell, to prevent overlapping probes and sharp angles between them
-    let cell_bounds = ${AABB3_STRUCT.wgsl_ref}(
-        probe_origin - cell_size*0.3,
-        probe_origin + cell_size*0.3,
-    );
-
-    // hit is within this cell
-    probe_position = refine_probe_placement(probe_position, hit, cell_bounds);
-    
-    let cell_bounding_sphere_radius = length( cell_size );
-    
-    // check new distance
-    let corrected_hit = scene_point_query_nearest(probe_position, cell_bounding_sphere_radius);
-    
-    let new_to_hit = corrected_hit.position - probe_position;
-    
-    if(dot(corrected_hit.normal, new_to_hit) > 0){
-        // new position is behind closest surface
-        return false;
-    }
-    
-    let new_distance = length(new_to_hit);
-    let old_distance = length(to_hit);
-    
-    if(old_distance < cell_bounding_sphere_radius * 0.2 && new_distance < old_distance){
-        // we got a bad refinement
-        return false;
-    }
-    
-    if(new_distance < cell_bounding_sphere_radius * 0.05){
-        // probe too close to geometry
-        return false;
-    }
-    
-    let offset = probe_position - probe_origin;
-    
-    var penetration_ray: ${RAY_STRUCT.wgsl_ref};
-    penetration_ray.origin = probe_origin;
-    penetration_ray.direction = normalize(offset);
-    penetration_ray.tmax = length(offset);
-    
-    if(ray_query_occluded(penetration_ray)){
-        // bad probe, moved through something
-        return false;
-    }
-    
-    if(scene_point_query_is_inside_geometry(probe_position, length(cell_bounding_sphere_radius))){
-        // bad probe
-        return false;
-    }
-    
-    *output = probe_position;
-    
-    return true;
-}
-    `, [
-        chunk_refine_probe_placement,
-    ]
-)
-
-const chunk_generate_probes = CodeChunk.from(
-    //language=WGSL
-    `
-
-@compute @workgroup_size(16,16,1)
-fn main(
-@builtin(global_invocation_id) global_id : vec3<u32>,
-){
-    if(any(global_id >= settings.resolution) ){
-        // too far
-        return;
-    }
-    
-    
-    let bounds = settings.bounds;
-    let bounds_span = bounds.max - bounds.min;
-    
-    let max_coord_i = settings.resolution - 1u;
-    
-    let cell_size = bounds_span / vec3<f32>(max_coord_i);
-    
-    let cell_bounding_sphere_radius = length( cell_size );
-    
-    let probe_origin = vec3<f32>(global_id) * cell_size + bounds.min;
-        
-    let hit = scene_point_query_nearest(probe_origin, cell_bounding_sphere_radius);
-
-    if(hit.primitive == ${UINT32_MAX}){
-        // hit nothing, this position is useless
-        return;
-    }
-    
-    let to_hit = hit.position - probe_origin; 
-        
-    if(any(abs(to_hit) > cell_size)){
-        // hit crosses cell boundary, too far
-        return;
-    }
-        
-    var probe_position = probe_origin;
-       
-    if(any( abs(to_hit) < cell_size*0.5 )){
-        // some geometry is within the cell bounds
-        let refinement_succeeded = attempt_refine_probe_placement(
-            &probe_position,
-            probe_origin,
-            hit,
-            cell_size
-        );
-        
-        if(!refinement_succeeded){
-            return ;
-        }
-    }
-    
-    if(scene_point_query_is_inside_geometry(probe_position, cell_bounding_sphere_radius*4)){
-        // bad probe
-        return;
-    }
-    
-    let probe_index = atomicAdd(&out.count,1);
-
-    if(probe_index*3u + 2u >= arrayLength(&out.data)){
-        // output buffer is full
-        return;
-    }
-
-    out.data[probe_index*3] = probe_position.x;
-    out.data[probe_index*3 + 1] = probe_position.y;
-    out.data[probe_index*3 + 2] = probe_position.z;
-
-}
-`, [
-        INITIAL_PLACEMENT_SETTINGS_STRUCT.declaration_chunk,
-        POSITION_COLLECTION_STRUCT.declaration_chunk,
-        RAY_STRUCT.declaration_chunk,
-        BVH2_NODE_STRUCT.declaration_chunk,
-        GEOMETRY_METADATA_STRUCT.declaration_chunk,
-        BVH_STRUCT.declaration_chunk,
-        chunk_array_to_aabb3,
-        chunk_scene_point_query_nearest,
-        chunk_scene_point_query_is_inside_geometry,
-        chunk_attempt_refine_probe_placement,
-        chunk_ray_query_occluded,
-    ]);
-
-const shader_initial_placement = ComputeShader.from({
-    label: "Probe Placement / initial",
-    body: chunk_generate_probes,
-    resources,
-})
-
-
-/**
- *
- * @param {Object} options
- * @param {GPUSceneContext} options.scene
- * @param {GraphicsContext} options.graphics
- * @param {number} [options.resolution] probes per cubic meter
- */
-export async function graph_generate_probe_locations({
-                                                         scene,
-                                                         graphics,
-                                                         resolution = 2
-                                                     }) {
-    /*
-     FIXME the delay is due to some kind of race condition that prevents something from being updated, here's potential list:
-        - BLAS
-        - TLAS
-        - instance metadata
-        - geometry metadata
-        - geometry indices/vertices
-     */
-
-    await delay(10);
-
-    graphics.update();
-    scene.update(graphics);
-
-    const geometries = scene.geometries;
-
-
-    assert.isNonNegativeInteger(resolution, 'resolution');
-    assert.greaterThanOrEqual(resolution, 2, 'must be at least 2');
-
-    const graph = new FrameGraph('generate probe positions');
-
-    const data_initial_placement = {};
-
-    // the box the GPU built the TLAS under — the union of every drawn row's bounds as the bounds
-    // pass derived them, which is the whole scene whoever placed what
-    const scene_bounds = new Float32Array(6);
-    const has_bounds = await scene.tlas.read_scene_bounds(scene_bounds);
-
-    assert.equal(has_bounds, true, 'the scene has no mesh row to place probes around');
-
-    const bounds = new AABB3(...scene_bounds);
-
-    const largest_bounds_dimension = Math.max(bounds.width, bounds.height, bounds.depth);
-    bounds.grow(Math.max(largest_bounds_dimension, 1e-5) * 0.05);
-
-
-    const step_size_limit = largest_bounds_dimension / resolution;
-
-    const resolution_x = Math.max(2, Math.round(bounds.width / step_size_limit));
-    const resolution_y = Math.max(2, Math.round(bounds.height / step_size_limit));
-    const resolution_z = Math.max(2, Math.round(bounds.depth / step_size_limit));
-
-    const voxel_size = new Vector3(
-        bounds.width / resolution_x,
-        bounds.height / resolution_y,
-        bounds.depth / resolution_z,
-    );
-
-    // expand by a voxel to add half a voxel border around the scene
-    bounds.x0 -= voxel_size.x * 0.5;
-    bounds.y0 -= voxel_size.y * 0.5;
-    bounds.z0 -= voxel_size.z * 0.5;
-
-    bounds.x1 += voxel_size.x * 0.5;
-    bounds.y1 += voxel_size.y * 0.5;
-    bounds.z1 += voxel_size.z * 0.5;
-
-    const pass_initial = graph.add("initial point placement", data_initial_placement,
-
-        /**
-         *
-         * @param {} data
-         * @param {FramePassResources} resources
-         * @param {GraphicsExecutionContext} context
-         */
-        (data, resources, context) => {
-
-            const encoder = context.encoder;
-
-            const buffer_settings = encoder.allocateTransientValueBuffer(
-                INITIAL_PLACEMENT_SETTINGS_STRUCT, {
-                bounds: {
-                    min: [bounds.x0, bounds.y0, bounds.z0],
-                    max: [bounds.x1, bounds.y1, bounds.z1],
-                },
-                resolution: [resolution_x, resolution_y, resolution_z]
-            }, GPUBufferUsage.UNIFORM);
-
-            const buffer_output = resources.get(data.out);
-
-            /**
-             *
-             * @type {GPUGeometryBVHManager}
-             */
-            const blas = geometries.blas;
-
-
-            shader_initial_placement.dispatchThreads({
-                encoder,
-                thread_count_x: resolution_x,
-                thread_count_y: resolution_y,
-                thread_count_z: resolution_z,
-                bindings:{
-                    settings: buffer_settings,
-                    out: buffer_output,
-
-                    //
-                    scene_database: scene.scene_database_buffer,
-                    tlas: scene.tlas.buffer,
-                    blas_lookup: blas.buffer_metadata,
-                    blas_data: blas.buffer_data,
-                    geometries: geometries.buffer_metadata,
-
-                    meshlet_metadata: geometries.meshlets.buffer_metadata,
-                    meshlet_data: geometries.meshlets.buffer_data,
-                }
-            })
-
-        });
-
-    const out_buffer_descriptor = BufferResourceDescriptor.from(
-        // + 4 for the atomic_u32 count header that precedes the data array in POSITION_COLLECTION_STRUCT
-        resolution * resolution * resolution * Float32Array.BYTES_PER_ELEMENT * 3 + 4,
-        GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
-    );
-
-    const out_buffer = graphics.buffer_allocator_main.get(out_buffer_descriptor);
-
-
-    const out_resource = graph.import_resource("out", out_buffer_descriptor, out_buffer);
-    data_initial_placement.out = pass_initial.write(out_resource);
-
-
-    const encoder = ShadeGPUCommandContext.create(graphics);
-
-    encoder.encodeGraph(graph);
-
-    encoder.finish();
-
-    const [position_data] = await inspect_gpu_buffer_typed({
-        buffer: out_buffer,
-        device: graphics.device,
-        type: POSITION_COLLECTION_STRUCT,
-        count: 1
-    });
-
-    graphics.buffer_allocator_main.release(out_buffer);
-
-    const gpu_lpv = scene.light_probe_volume;
-    const buffer_lpv_probes = gpu_lpv.buffer_probes;
-
-    const possible_count = resolution_x * resolution_y * resolution_z;
-
-    const generated_count = position_data.count;
-    console.warn(`Probe count = ${generated_count}, ${(generated_count * 100 / possible_count).toFixed(2)}%`, position_data);
-
-    gpu_lpv.source.positions = position_data.data.slice(0, generated_count * 3);
-    gpu_lpv.source.build_mesh();
-
+import { assert } from "../../../../../core/assert.js";
+import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
+import { AABB3 } from "../../../../../core/geom/3d/aabb/AABB3.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import { delay } from "../../../../../core/process/delay.js";
+import { FrameGraph } from "../../../../../engine/graphics/render/frame_graph/FrameGraph.js";
+import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
+import { ShadeGPUCommandContext } from "../../../../device/ShadeGPUCommandContext.js";
+import { atomic_u32, vec3u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { inspect_gpu_buffer_typed } from "../../../buffer/inspect_gpu_buffer_typed.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_STRUCT.js";
+import { AABB3_STRUCT } from "../../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
+import { chunk_array_to_aabb3 } from "../../../shader/chunk/geometry/aabb3/chunk_array_to_aabb3.js";
+import { chunk_ray_query_occluded } from "../../../shader/chunk/geometry/ray/chunk_ray_query_occluded.js";
+import {
+    chunk_scene_point_query_is_inside_geometry
+} from "../../../shader/chunk/geometry/ray/chunk_scene_point_query_is_inside_geometry.js";
+import { RAY_STRUCT } from "../../../shader/chunk/geometry/ray/RAY_STRUCT.js";
+import { chunk_scene_point_query_nearest } from "../../../shader/chunk/sdf/chunk_scene_point_query_nearest.js";
+import { SURFACE_POINT_3D } from "../../../shader/chunk/sdf/SURFACE_POINT_3D.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { sr_create_group_RTX } from "../../../geometry/sr_create_group_RTX.js";
+import { chunk_refine_probe_placement } from "./chunk_refine_probe_placement.js";
+
+const INITIAL_PLACEMENT_SETTINGS_STRUCT = WebGPUStruct.from({
+    bounds: AABB3_STRUCT,
+    resolution: vec3u
+});
+
+const POSITION_COLLECTION_STRUCT = WebGPUStruct.from({
+    count: atomic_u32,
+    data: WebGPUArray.f32
+});
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addUniform("settings", INITIAL_PLACEMENT_SETTINGS_STRUCT)
+    .addStorageBuffer("out", POSITION_COLLECTION_STRUCT, true)
+;
+
+sr_create_group_RTX(resources)
+
+const chunk_attempt_refine_probe_placement = CodeChunk.from(
+    //language=WGSL
+    `
+fn attempt_refine_probe_placement(
+    output:ptr<function,vec3f>,
+    probe_origin: vec3f,
+    hit: ${SURFACE_POINT_3D.wgsl_ref},
+    cell_size: vec3f,
+ ) -> bool{
+    var probe_position = probe_origin;
+    
+    let to_hit = hit.position - probe_origin; 
+    
+    // don't allow motion within the entire cell, to prevent overlapping probes and sharp angles between them
+    let cell_bounds = ${AABB3_STRUCT.wgsl_ref}(
+        probe_origin - cell_size*0.3,
+        probe_origin + cell_size*0.3,
+    );
+
+    // hit is within this cell
+    probe_position = refine_probe_placement(probe_position, hit, cell_bounds);
+    
+    let cell_bounding_sphere_radius = length( cell_size );
+    
+    // check new distance
+    let corrected_hit = scene_point_query_nearest(probe_position, cell_bounding_sphere_radius);
+    
+    let new_to_hit = corrected_hit.position - probe_position;
+    
+    if(dot(corrected_hit.normal, new_to_hit) > 0){
+        // new position is behind closest surface
+        return false;
+    }
+    
+    let new_distance = length(new_to_hit);
+    let old_distance = length(to_hit);
+    
+    if(old_distance < cell_bounding_sphere_radius * 0.2 && new_distance < old_distance){
+        // we got a bad refinement
+        return false;
+    }
+    
+    if(new_distance < cell_bounding_sphere_radius * 0.05){
+        // probe too close to geometry
+        return false;
+    }
+    
+    let offset = probe_position - probe_origin;
+    
+    var penetration_ray: ${RAY_STRUCT.wgsl_ref};
+    penetration_ray.origin = probe_origin;
+    penetration_ray.direction = normalize(offset);
+    penetration_ray.tmax = length(offset);
+    
+    if(ray_query_occluded(penetration_ray)){
+        // bad probe, moved through something
+        return false;
+    }
+    
+    if(scene_point_query_is_inside_geometry(probe_position, length(cell_bounding_sphere_radius))){
+        // bad probe
+        return false;
+    }
+    
+    *output = probe_position;
+    
+    return true;
+}
+    `, [
+        chunk_refine_probe_placement,
+    ]
+)
+
+const chunk_generate_probes = CodeChunk.from(
+    //language=WGSL
+    `
+
+@compute @workgroup_size(16,16,1)
+fn main(
+@builtin(global_invocation_id) global_id : vec3<u32>,
+){
+    if(any(global_id >= settings.resolution) ){
+        // too far
+        return;
+    }
+    
+    
+    let bounds = settings.bounds;
+    let bounds_span = bounds.max - bounds.min;
+    
+    let max_coord_i = settings.resolution - 1u;
+    
+    let cell_size = bounds_span / vec3<f32>(max_coord_i);
+    
+    let cell_bounding_sphere_radius = length( cell_size );
+    
+    let probe_origin = vec3<f32>(global_id) * cell_size + bounds.min;
+        
+    let hit = scene_point_query_nearest(probe_origin, cell_bounding_sphere_radius);
+
+    if(hit.primitive == ${UINT32_MAX}){
+        // hit nothing, this position is useless
+        return;
+    }
+    
+    let to_hit = hit.position - probe_origin; 
+        
+    if(any(abs(to_hit) > cell_size)){
+        // hit crosses cell boundary, too far
+        return;
+    }
+        
+    var probe_position = probe_origin;
+       
+    if(any( abs(to_hit) < cell_size*0.5 )){
+        // some geometry is within the cell bounds
+        let refinement_succeeded = attempt_refine_probe_placement(
+            &probe_position,
+            probe_origin,
+            hit,
+            cell_size
+        );
+        
+        if(!refinement_succeeded){
+            return ;
+        }
+    }
+    
+    if(scene_point_query_is_inside_geometry(probe_position, cell_bounding_sphere_radius*4)){
+        // bad probe
+        return;
+    }
+    
+    let probe_index = atomicAdd(&out.count,1);
+
+    if(probe_index*3u + 2u >= arrayLength(&out.data)){
+        // output buffer is full
+        return;
+    }
+
+    out.data[probe_index*3] = probe_position.x;
+    out.data[probe_index*3 + 1] = probe_position.y;
+    out.data[probe_index*3 + 2] = probe_position.z;
+
+}
+`, [
+        INITIAL_PLACEMENT_SETTINGS_STRUCT.declaration_chunk,
+        POSITION_COLLECTION_STRUCT.declaration_chunk,
+        RAY_STRUCT.declaration_chunk,
+        GEOMETRY_METADATA_STRUCT.declaration_chunk,
+        chunk_array_to_aabb3,
+        chunk_scene_point_query_nearest,
+        chunk_scene_point_query_is_inside_geometry,
+        chunk_attempt_refine_probe_placement,
+        chunk_ray_query_occluded,
+    ]);
+
+const shader_initial_placement = ComputeShader.from({
+    label: "Probe Placement / initial",
+    body: chunk_generate_probes,
+    resources,
+})
+
+
+/**
+ *
+ * @param {Object} options
+ * @param {GPUSceneContext} options.scene
+ * @param {GraphicsContext} options.graphics
+ * @param {number} [options.resolution] probes per cubic meter
+ */
+export async function graph_generate_probe_locations({
+                                                         scene,
+                                                         graphics,
+                                                         resolution = 2
+                                                     }) {
+    /*
+     FIXME the delay is due to some kind of race condition that prevents something from being updated, here's potential list:
+        - BLAS
+        - TLAS
+        - instance metadata
+        - geometry metadata
+        - geometry indices/vertices
+     */
+
+    await delay(10);
+
+    graphics.update();
+    scene.update(graphics);
+
+    const geometries = scene.geometries;
+
+
+    assert.isNonNegativeInteger(resolution, 'resolution');
+    assert.greaterThanOrEqual(resolution, 2, 'must be at least 2');
+
+    const graph = new FrameGraph('generate probe positions');
+
+    const data_initial_placement = {};
+
+    // the box the GPU built the TLAS under — the union of every drawn row's bounds as the bounds
+    // pass derived them, which is the whole scene whoever placed what
+    const scene_bounds = new Float32Array(6);
+    const has_bounds = await scene.tlas.read_scene_bounds(scene_bounds);
+
+    assert.equal(has_bounds, true, 'the scene has no mesh row to place probes around');
+
+    const bounds = new AABB3(...scene_bounds);
+
+    const largest_bounds_dimension = Math.max(bounds.width, bounds.height, bounds.depth);
+    bounds.grow(Math.max(largest_bounds_dimension, 1e-5) * 0.05);
+
+
+    const step_size_limit = largest_bounds_dimension / resolution;
+
+    const resolution_x = Math.max(2, Math.round(bounds.width / step_size_limit));
+    const resolution_y = Math.max(2, Math.round(bounds.height / step_size_limit));
+    const resolution_z = Math.max(2, Math.round(bounds.depth / step_size_limit));
+
+    const voxel_size = new Vector3(
+        bounds.width / resolution_x,
+        bounds.height / resolution_y,
+        bounds.depth / resolution_z,
+    );
+
+    // expand by a voxel to add half a voxel border around the scene
+    bounds.x0 -= voxel_size.x * 0.5;
+    bounds.y0 -= voxel_size.y * 0.5;
+    bounds.z0 -= voxel_size.z * 0.5;
+
+    bounds.x1 += voxel_size.x * 0.5;
+    bounds.y1 += voxel_size.y * 0.5;
+    bounds.z1 += voxel_size.z * 0.5;
+
+    const pass_initial = graph.add("initial point placement", data_initial_placement,
+
+        /**
+         *
+         * @param {} data
+         * @param {FramePassResources} resources
+         * @param {GraphicsExecutionContext} context
+         */
+        (data, resources, context) => {
+
+            const encoder = context.encoder;
+
+            const buffer_settings = encoder.allocateTransientValueBuffer(
+                INITIAL_PLACEMENT_SETTINGS_STRUCT, {
+                bounds: {
+                    min: [bounds.x0, bounds.y0, bounds.z0],
+                    max: [bounds.x1, bounds.y1, bounds.z1],
+                },
+                resolution: [resolution_x, resolution_y, resolution_z]
+            }, GPUBufferUsage.UNIFORM);
+
+            const buffer_output = resources.get(data.out);
+
+            /**
+             *
+             * @type {GPUGeometryBVHManager}
+             */
+            const blas = geometries.blas;
+
+
+            shader_initial_placement.dispatchThreads({
+                encoder,
+                thread_count_x: resolution_x,
+                thread_count_y: resolution_y,
+                thread_count_z: resolution_z,
+                bindings:{
+                    settings: buffer_settings,
+                    out: buffer_output,
+
+                    //
+                    scene_database: scene.scene_database_buffer,
+                    tlas: scene.tlas.buffer,
+                    blas_lookup: blas.buffer_metadata,
+                    blas_data: blas.buffer_data,
+                    geometries: geometries.buffer_metadata,
+
+                    meshlet_metadata: geometries.meshlets.buffer_metadata,
+                    meshlet_data: geometries.meshlets.buffer_data,
+                }
+            })
+
+        });
+
+    const out_buffer_descriptor = BufferResourceDescriptor.from(
+        // + 4 for the atomic_u32 count header that precedes the data array in POSITION_COLLECTION_STRUCT
+        resolution * resolution * resolution * Float32Array.BYTES_PER_ELEMENT * 3 + 4,
+        GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC
+    );
+
+    const out_buffer = graphics.buffer_allocator_main.get(out_buffer_descriptor);
+
+
+    const out_resource = graph.import_resource("out", out_buffer_descriptor, out_buffer);
+    data_initial_placement.out = pass_initial.write(out_resource);
+
+
+    const encoder = ShadeGPUCommandContext.create(graphics);
+
+    encoder.encodeGraph(graph);
+
+    encoder.finish();
+
+    const [position_data] = await inspect_gpu_buffer_typed({
+        buffer: out_buffer,
+        device: graphics.device,
+        type: POSITION_COLLECTION_STRUCT,
+        count: 1
+    });
+
+    graphics.buffer_allocator_main.release(out_buffer);
+
+    const gpu_lpv = scene.light_probe_volume;
+    const buffer_lpv_probes = gpu_lpv.buffer_probes;
+
+    const possible_count = resolution_x * resolution_y * resolution_z;
+
+    const generated_count = position_data.count;
+    console.warn(`Probe count = ${generated_count}, ${(generated_count * 100 / possible_count).toFixed(2)}%`, position_data);
+
+    gpu_lpv.source.positions = position_data.data.slice(0, generated_count * 3);
+    gpu_lpv.source.build_mesh();
+
 }