@woosh/meep-engine 3.12.0 → 3.13.0

package/src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpatialHashRadianceCache.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.js"],"names":[],"mappings":"AAcA;IAkDI;;;;OAIG;IACH,8CAFW,MAAM,EAkBhB;IA1DD,qCAEC;IASD,mCAEC;IAQD,mBAEC;IAQD,6BAIC;IARD,0BAEC;IAiCD;;;;;;;;OAQG;IACH,gHAsGC;IAED,gBAEC;IAED,gBAEC;IAED,cAiBC;IAGD,gBAUC;IAED;;;OAqBC;IAED;;;OAGG;IACH,+BAYC;;CACJ"}
+{"version":3,"file":"SpatialHashRadianceCache.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.js"],"names":[],"mappings":"AAaA;IAkDI;;;;OAIG;IACH,8CAFW,MAAM,EAkBhB;IA1DD,qCAEC;IASD,mCAEC;IAQD,mBAEC;IAQD,6BAIC;IARD,0BAEC;IAiCD;;;;;;;;OAQG;IACH,gHAqGC;IAED,gBAEC;IAED,gBAEC;IAED,cAiBC;IAGD,gBAUC;IAED;;;OAqBC;IAED;;;OAGG;IACH,+BAYC;;CACJ"}

package/src/shade/renderer/global_illumination/sharc/SpatialHashRadianceCache.js

@@ -5,7 +5,6 @@ import { inspect_gpu_buffer_typed } from "../../buffer/inspect_gpu_buffer_typed.
 import { graph_compute_indirect_pass } from "../../shader/graph/compute/graph_compute_indirect_pass.js";
 import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
 import { graph_build_indirect_dispatch_command } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
-import { HASH_GRID_PARAMETERS_STRUCT } from "./shader/sh/HASH_GRID_PARAMETERS_STRUCT.js";
 import { shader_sharc_evict } from "./shader/shader_sharc_evict.js";
 import { shader_sharc_update } from "./shader/shader_sharc_update.js";
 import { SHARC_EVICTION_PERCENTAGE_LIMIT, SHARC_HASH_GRID_HASH_MAP_BUCKET_SIZE } from "./sharc_constants.js";
@@ -131,13 +130,12 @@ export class SpatialHashRadianceCache {
             const voxelData = resources.get(data.voxelData);
             const evictionBuffer = resources.get(data.evictionBuffer);
 
-            const gridParameters = context.encoder.allocateTransientValueBuffer(
-                HASH_GRID_PARAMETERS_STRUCT, {
-                    sceneScale: scene_scale,
-                    capacity,
-                    frame: frame_index,
-                    cameraPosition: camera.camera.transform.position.toArray()
-                })
+            const gridParameters = {
+                sceneScale: scene_scale,
+                capacity,
+                frame: frame_index,
+                cameraPosition: camera.camera.transform.position.toArray()
+            };
 
             // run a compute shader to update the hash table
 

package/src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sharc_evict.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.js"],"names":[],"mappings":"AAgGA,+CAIG;8BAhG2B,kCAAkC"}
+{"version":3,"file":"shader_sharc_evict.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.js"],"names":[],"mappings":"AAkGA,+CAIG;8BAlG2B,kCAAkC"}

package/src/shade/renderer/global_illumination/sharc/shader/shader_sharc_evict.js

@@ -26,8 +26,10 @@ const PUSH_CONSTANTS = WebGPUStruct.from({
     capacity: u32,
 });
 
+// per-dispatch, eight bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", PUSH_CONSTANTS);
+
 resources.createGroup()
-    .addUniform("settings", PUSH_CONSTANTS)
     .addStorageBuffer('hashMapData', HASH_MAP_DATA_STRUCT, true)
     .addStorageBuffer("voxelData", WebGPUArray.from(vec4u))
     .addStorageBuffer('evictionRequests', EVICTION_STRUCT);

package/src/shade/renderer/global_illumination/sharc/shader/shader_sharc_update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_sharc_update.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/sharc/shader/shader_sharc_update.js"],"names":[],"mappings":"AAiLA,gDAIG;8BAtK2B,kCAAkC"}
+{"version":3,"file":"shader_sharc_update.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/sharc/shader/shader_sharc_update.js"],"names":[],"mappings":"AAmLA,gDAIG;8BAxK2B,kCAAkC"}

package/src/shade/renderer/global_illumination/sharc/shader/shader_sharc_update.js

@@ -25,6 +25,9 @@ import { SHARC_VOXEL_DATUM_STRUCT } from "./SHARC_VOXEL_DATUM_STRUCT.js";
 
 const resources = new ShaderResourceSetDescriptor()
 
+// per-dispatch, 32 bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("gridParameters", HASH_GRID_PARAMETERS_STRUCT);
+
 resources.createGroup()
     .addTexture("tColor")
     .addTexture("tTrace", "uint")
@@ -38,7 +41,6 @@ const EVICTION_STRUCT = WebGPUStruct.from({
 
 resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addUniform("gridParameters", HASH_GRID_PARAMETERS_STRUCT)
     .addStorageBuffer("evictionRequests", EVICTION_STRUCT, true)
     .addStorageBuffer("hashMapData", HASH_MAP_DATA_STRUCT, true)
     .addStorageBuffer("voxelData", WebGPUArray.from(vec4u), true)

package/src/shade/renderer/gpu_primitive/bvh/GPU_BVH_BUILD_PLAN.md

@@ -231,9 +231,9 @@ builder is free to choose its own layout (§4.3).
   sequence, bindings, buffer sizes/usages, and host-written bytes;
   (d) browser playground verify functions (FrameGraph + `graph_import_typed_buffer` +
   `graph_inspect_gpu_buffer` readback + CPU assertions, registered as lil-gui "review checks");
-  `gpu_test.js` offers a standalone device bootstrap. GPU timing via `GPUTimer` +
-  `encoder.enable_debug_timers` (note: the `timer` argument `graph_compute_pass` forwards is
-  silently dropped by `ComputeShader.dispatch` — use the debug-timers path).
+  `gpu_test.js` offers a standalone device bootstrap. GPU timing via `encoder.enable_profiling`
+  with a `GPUFrameRecorder` (note: the `timer` argument `graph_compute_pass` forwards is silently
+  dropped by `ComputeShader.dispatch` — use the profiler).
 - **Morton chunks** (`shader/chunk/bvh/morton/`): the fixed 10-bit `chunk_v3_morton_encode`,
   spec'd bit-exact against `v3_morton_encode_magicbits`, is what the build uses (§4.2) for exact
   CPU parity, alongside the 2D encode/decode pairs. A WGSL port of the DXR Fallback's

package/src/shade/renderer/gpu_primitive/bvh/PHASE1_HANDOVER.md

@@ -144,9 +144,9 @@ for BOTH the legacy compressor and the GPU layout against the same golden bytes.
 (duplicates, degenerate AABBs, N ∈ {0,1,2,3, 2^k±1, ~100k}), readback, assert structural
 validity (every leaf exactly once, both children valid, parent AABB ⊇ children, root word),
 payload permutation, **depth histogram**, SAH cost vs the CPU oracle fed the same sorted order
-(topology must match node-for-node modulo the index mapping). Wire `GPUTimer` numbers for the
-build via `encoder.enable_debug_timers` (the `timer` param on `graph_compute_pass` is silently
-dropped — known quirk, don't use it).
+(topology must match node-for-node modulo the index mapping). Wire GPU timings for the build via
+`encoder.enable_profiling` and a `GPUFrameRecorder` (the `timer` param on `graph_compute_pass` is
+silently dropped — known quirk, don't use it).
 
 **M6 — hand back.** You cannot run the browser playground (meep is a library; the host repo
 mounts it). When `npm test` is green and everything above is in place: update

package/src/shade/renderer/gpu_primitive/bvh/graph_bvh_build_lbvh.js

@@ -1,217 +1,217 @@
-import { assert } from "../../../../core/assert.js";
-import { round_up } from "../../../../core/math/round_up.js";
-import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
-import { BVH_HEADER_WORDS, bvh_buffer_size } from "./BVH_BUFFER_LAYOUT.js";
-import { graph_radix_sort } from "../sort/graph_radix_sort.js";
-import { BVH_BUILD_SETTINGS_STRUCT, BVH_NO_ROOT_WORD } from "./BVH_BUILD_SETTINGS_STRUCT.js";
-import { shader_bvh_emit_hierarchy } from "./shader_bvh_emit_hierarchy.js";
-import { shader_bvh_morton } from "./shader_bvh_morton.js";
-import { shader_bvh_refit } from "./shader_bvh_refit.js";
-
-/**
- * Record a GPU LBVH build over a flat set of leaves: Morton code, sort, Karras emission, bottom-up
- * refit. Everything scene- or geometry-specific happens upstream, in whichever extraction pass
- * produced `leaf_bounds` / `leaf_payload` / `scene_bounds` — this recorder knows only that it has
- * `element_count` boxes with payloads and somewhere to put a tree.
- *
- * The output honours the format in {@link BVH_BUFFER_LAYOUT}: a `u32` root word, then `2N-1` nodes
- * with internal nodes at `[0, N-2]` (root = 0, by Karras's construction) and leaf `j` at `(N-1)+j`.
- * That ordering differs from the CPU path's slot-order-with-holes, which is legal because no
- * consumer reads node *order* — only the node format and the root word. It is also exactly the
- * BLAS convention (root at node 0), which is why the same recorder serves the geometry side later.
- *
- * `element_count` must be at least 1. A single leaf falls out of the same passes with no special
- * case anywhere: the sort has nothing to reorder and returns its input, emission's tail `if` skips
- * the internal node and writes leaf 0 at node 0 with `parents[0] = BVH_NULL_NODE`, and the refit's
- * one thread reads that terminator and stops. The only thing it needs is a counters buffer WebGPU
- * will accept, since a tree of one leaf has no internal node to count arrivals at.
- *
- * Zero leaves is refused. There is no tree to write and no dispatch to make — the caller writes
- * `root = BVH_NULL_NODE` host-side, which is the four bytes consumers already read as "empty".
- *
- * @param {FrameGraph} graph
- * @param {number} leaf_bounds buffer resource ID, `array<f32>`, six floats per leaf: `[min.xyz, max.xyz]`
- * @param {number} leaf_payload buffer resource ID, `array<u32>`, one per leaf — becomes the leaf's `child_2`
- * @param {number} scene_bounds buffer resource ID, `array<f32>`, six floats bounding every leaf centroid
- * @param {number} element_count number of leaves, at least 1
- * @param {number} nodes buffer resource ID to write the tree into, at least `bvh_buffer_size(element_count)` bytes
- * @param {number} [node_word_offset] u32 word the tree's node 0 starts at. Defaults to
- * {@link BVH_HEADER_WORDS} — straight after a root word, which is what a tree that owns its buffer
- * wants. A tree living inside a shared arena passes its address there instead.
- * @param {number} [root_word_offset] u32 word to write the root index into, or
- * {@link BVH_NO_ROOT_WORD} for a format that has no header. Defaults to word 0.
- * @returns {{nodes: number, keys: number, values: number}} the written tree, plus the Morton order
- * it was built from — `values[i]` is the leaf that sorted to position `i`. The permutation is what a
- * refit-only update would rewrite leaves through, and what the verify harness feeds the CPU oracle
- * so that a topology comparison tests emission rather than float rounding in the quantiser.
- */
-export function graph_bvh_build_lbvh({
-                                         graph,
-                                         leaf_bounds,
-                                         leaf_payload,
-                                         scene_bounds,
-                                         element_count,
-                                         nodes,
-                                         node_word_offset = BVH_HEADER_WORDS,
-                                         root_word_offset = 0,
-                                     }) {
-
-    assert.defined(graph, 'graph');
-    assert.isNonNegativeInteger(leaf_bounds, 'leaf_bounds');
-    assert.isNonNegativeInteger(leaf_payload, 'leaf_payload');
-    assert.isNonNegativeInteger(scene_bounds, 'scene_bounds');
-    assert.isNonNegativeInteger(nodes, 'nodes');
-    assert.isNonNegativeInteger(element_count, 'element_count');
-    assert.greaterThanOrEqual(element_count, 1, 'element_count — an empty tree is written host-side');
-    assert.isNonNegativeInteger(node_word_offset, 'node_word_offset');
-    assert.isNonNegativeInteger(root_word_offset, 'root_word_offset');
-
-    const node_count = 2 * element_count - 1;
-
-    // aligned on a 1k boundary to lower memory fragmentation, as the sort's own transients are
-    const KEY_DESCRIPTOR = BufferResourceDescriptor.from(
-        round_up(element_count * Uint32Array.BYTES_PER_ELEMENT, 1024),
-        GPUBufferUsage.STORAGE
-    );
-
-    const PARENTS_DESCRIPTOR = BufferResourceDescriptor.from(
-        round_up(node_count * Uint32Array.BYTES_PER_ELEMENT, 1024),
-        GPUBufferUsage.STORAGE
-    );
-
-    // One per internal node. A single-leaf tree has none, and a zero-sized buffer is not a thing
-    // WebGPU will hand out, so it gets one cell that nothing ever touches.
-    const counters_size = Math.max(1, element_count - 1) * Uint32Array.BYTES_PER_ELEMENT;
-
-    // Every build needs these at zero. A fresh buffer arrives zeroed; a pool-reused one carries
-    // the previous build's arrival counts, which would let a first arrival believe it was a second
-    // and fit a node from a sibling that has not been written yet.
-    const COUNTERS_DESCRIPTOR = BufferResourceDescriptor.from(
-        counters_size,
-        GPUBufferUsage.STORAGE,
-        0, counters_size
-    );
-
-    // The build owns its `parents` and `leaf_nodes` outright — they are transients of this graph,
-    // one tree to a buffer — so both start at word 0.
-    const settings = {
-        element_count,
-        node_word_offset,
-        root_word_offset,
-        parents_offset: 0,
-        leaf_nodes_offset: 0,
-    };
-
-    /**
-     * @param pass_data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute_morton(pass_data, resources, context) {
-        const encoder = context.encoder;
-
-        shader_bvh_morton.dispatchThreads({
-            encoder,
-            thread_count_x: element_count,
-            bindings: {
-                settings: encoder.allocateTransientValueBuffer(BVH_BUILD_SETTINGS_STRUCT, settings),
-                leaf_bounds: resources.get(pass_data.leaf_bounds),
-                scene_bounds: resources.get(pass_data.scene_bounds),
-                keys: resources.get(pass_data.keys),
-                values: resources.get(pass_data.values),
-            }
-        });
-    }
-
-    /**
-     * @param pass_data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute_emit(pass_data, resources, context) {
-        const encoder = context.encoder;
-
-        const output = resources.get(pass_data.nodes);
-
-        // the tree ends at its last node; where it starts is the caller's business
-        const end_byte = (node_word_offset + (2 * element_count - 1) * 8) * Uint32Array.BYTES_PER_ELEMENT;
-
-        assert.greaterThanOrEqual(output.size, end_byte, 'node buffer underflow');
-
-        shader_bvh_emit_hierarchy.dispatchThreads({
-            encoder,
-            thread_count_x: element_count,
-            bindings: {
-                settings: encoder.allocateTransientValueBuffer(BVH_BUILD_SETTINGS_STRUCT, settings),
-                keys: resources.get(pass_data.keys),
-                values: resources.get(pass_data.values),
-                leaf_bounds: resources.get(pass_data.leaf_bounds),
-                leaf_payload: resources.get(pass_data.leaf_payload),
-                nodes: output,
-                parents: resources.get(pass_data.parents),
-                leaf_nodes: resources.get(pass_data.leaf_nodes),
-            }
-        });
-    }
-
-    /**
-     * @param pass_data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute_refit(pass_data, resources, context) {
-        const encoder = context.encoder;
-
-        shader_bvh_refit.dispatchThreads({
-            encoder,
-            thread_count_x: element_count,
-            bindings: {
-                settings: encoder.allocateTransientValueBuffer(BVH_BUILD_SETTINGS_STRUCT, settings),
-                parents: resources.get(pass_data.parents),
-                leaf_nodes: resources.get(pass_data.leaf_nodes),
-                counters: resources.get(pass_data.counters),
-                nodes: resources.get(pass_data.nodes),
-            }
-        });
-    }
-
-    const morton_data = {};
-    const morton_pass = graph.add("bvh build/morton", morton_data, execute_morton);
-
-    morton_data.leaf_bounds = morton_pass.read(leaf_bounds);
-    morton_data.scene_bounds = morton_pass.read(scene_bounds);
-    morton_data.keys = morton_pass.create("bvh build/morton keys", KEY_DESCRIPTOR);
-    morton_data.values = morton_pass.create("bvh build/leaf order", KEY_DESCRIPTOR);
-
-    const sorted = graph_radix_sort({
-        graph,
-        keys: morton_data.keys,
-        values: morton_data.values,
-        element_count,
-    });
-
-    const emit_data = {};
-    const emit_pass = graph.add("bvh build/emit hierarchy", emit_data, execute_emit);
-
-    emit_data.keys = emit_pass.read(sorted.keys);
-    emit_data.values = emit_pass.read(sorted.values);
-    emit_data.leaf_bounds = emit_pass.read(leaf_bounds);
-    emit_data.leaf_payload = emit_pass.read(leaf_payload);
-    emit_data.nodes = emit_pass.write(nodes);
-    emit_data.parents = emit_pass.create("bvh build/parents", PARENTS_DESCRIPTOR);
-    emit_data.leaf_nodes = emit_pass.create("bvh build/leaf nodes", KEY_DESCRIPTOR);
-
-    const refit_data = {};
-    const refit_pass = graph.add("bvh build/refit", refit_data, execute_refit);
-
-    refit_data.parents = refit_pass.read(emit_data.parents);
-    refit_data.leaf_nodes = refit_pass.read(emit_data.leaf_nodes);
-    refit_data.counters = refit_pass.create("bvh build/refit counters", COUNTERS_DESCRIPTOR);
-    refit_data.nodes = refit_pass.write(emit_data.nodes);
-
-    return {
-        nodes: refit_data.nodes,
-        keys: sorted.keys,
-        values: sorted.values,
-    };
-}
+import { assert } from "../../../../core/assert.js";
+import { round_up } from "../../../../core/math/round_up.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { BVH_HEADER_WORDS, bvh_buffer_size } from "./BVH_BUFFER_LAYOUT.js";
+import { graph_radix_sort } from "../sort/graph_radix_sort.js";
+import { BVH_NO_ROOT_WORD } from "./BVH_BUILD_SETTINGS_STRUCT.js";
+import { shader_bvh_emit_hierarchy } from "./shader_bvh_emit_hierarchy.js";
+import { shader_bvh_morton } from "./shader_bvh_morton.js";
+import { shader_bvh_refit } from "./shader_bvh_refit.js";
+
+/**
+ * Record a GPU LBVH build over a flat set of leaves: Morton code, sort, Karras emission, bottom-up
+ * refit. Everything scene- or geometry-specific happens upstream, in whichever extraction pass
+ * produced `leaf_bounds` / `leaf_payload` / `scene_bounds` — this recorder knows only that it has
+ * `element_count` boxes with payloads and somewhere to put a tree.
+ *
+ * The output honours the format in {@link BVH_BUFFER_LAYOUT}: a `u32` root word, then `2N-1` nodes
+ * with internal nodes at `[0, N-2]` (root = 0, by Karras's construction) and leaf `j` at `(N-1)+j`.
+ * That ordering differs from the CPU path's slot-order-with-holes, which is legal because no
+ * consumer reads node *order* — only the node format and the root word. It is also exactly the
+ * BLAS convention (root at node 0), which is why the same recorder serves the geometry side later.
+ *
+ * `element_count` must be at least 1. A single leaf falls out of the same passes with no special
+ * case anywhere: the sort has nothing to reorder and returns its input, emission's tail `if` skips
+ * the internal node and writes leaf 0 at node 0 with `parents[0] = BVH_NULL_NODE`, and the refit's
+ * one thread reads that terminator and stops. The only thing it needs is a counters buffer WebGPU
+ * will accept, since a tree of one leaf has no internal node to count arrivals at.
+ *
+ * Zero leaves is refused. There is no tree to write and no dispatch to make — the caller writes
+ * `root = BVH_NULL_NODE` host-side, which is the four bytes consumers already read as "empty".
+ *
+ * @param {FrameGraph} graph
+ * @param {number} leaf_bounds buffer resource ID, `array<f32>`, six floats per leaf: `[min.xyz, max.xyz]`
+ * @param {number} leaf_payload buffer resource ID, `array<u32>`, one per leaf — becomes the leaf's `child_2`
+ * @param {number} scene_bounds buffer resource ID, `array<f32>`, six floats bounding every leaf centroid
+ * @param {number} element_count number of leaves, at least 1
+ * @param {number} nodes buffer resource ID to write the tree into, at least `bvh_buffer_size(element_count)` bytes
+ * @param {number} [node_word_offset] u32 word the tree's node 0 starts at. Defaults to
+ * {@link BVH_HEADER_WORDS} — straight after a root word, which is what a tree that owns its buffer
+ * wants. A tree living inside a shared arena passes its address there instead.
+ * @param {number} [root_word_offset] u32 word to write the root index into, or
+ * {@link BVH_NO_ROOT_WORD} for a format that has no header. Defaults to word 0.
+ * @returns {{nodes: number, keys: number, values: number}} the written tree, plus the Morton order
+ * it was built from — `values[i]` is the leaf that sorted to position `i`. The permutation is what a
+ * refit-only update would rewrite leaves through, and what the verify harness feeds the CPU oracle
+ * so that a topology comparison tests emission rather than float rounding in the quantiser.
+ */
+export function graph_bvh_build_lbvh({
+                                         graph,
+                                         leaf_bounds,
+                                         leaf_payload,
+                                         scene_bounds,
+                                         element_count,
+                                         nodes,
+                                         node_word_offset = BVH_HEADER_WORDS,
+                                         root_word_offset = 0,
+                                     }) {
+
+    assert.defined(graph, 'graph');
+    assert.isNonNegativeInteger(leaf_bounds, 'leaf_bounds');
+    assert.isNonNegativeInteger(leaf_payload, 'leaf_payload');
+    assert.isNonNegativeInteger(scene_bounds, 'scene_bounds');
+    assert.isNonNegativeInteger(nodes, 'nodes');
+    assert.isNonNegativeInteger(element_count, 'element_count');
+    assert.greaterThanOrEqual(element_count, 1, 'element_count — an empty tree is written host-side');
+    assert.isNonNegativeInteger(node_word_offset, 'node_word_offset');
+    assert.isNonNegativeInteger(root_word_offset, 'root_word_offset');
+
+    const node_count = 2 * element_count - 1;
+
+    // aligned on a 1k boundary to lower memory fragmentation, as the sort's own transients are
+    const KEY_DESCRIPTOR = BufferResourceDescriptor.from(
+        round_up(element_count * Uint32Array.BYTES_PER_ELEMENT, 1024),
+        GPUBufferUsage.STORAGE
+    );
+
+    const PARENTS_DESCRIPTOR = BufferResourceDescriptor.from(
+        round_up(node_count * Uint32Array.BYTES_PER_ELEMENT, 1024),
+        GPUBufferUsage.STORAGE
+    );
+
+    // One per internal node. A single-leaf tree has none, and a zero-sized buffer is not a thing
+    // WebGPU will hand out, so it gets one cell that nothing ever touches.
+    const counters_size = Math.max(1, element_count - 1) * Uint32Array.BYTES_PER_ELEMENT;
+
+    // Every build needs these at zero. A fresh buffer arrives zeroed; a pool-reused one carries
+    // the previous build's arrival counts, which would let a first arrival believe it was a second
+    // and fit a node from a sibling that has not been written yet.
+    const COUNTERS_DESCRIPTOR = BufferResourceDescriptor.from(
+        counters_size,
+        GPUBufferUsage.STORAGE,
+        0, counters_size
+    );
+
+    // The build owns its `parents` and `leaf_nodes` outright — they are transients of this graph,
+    // one tree to a buffer — so both start at word 0.
+    const settings = {
+        element_count,
+        node_word_offset,
+        root_word_offset,
+        parents_offset: 0,
+        leaf_nodes_offset: 0,
+    };
+
+    /**
+     * @param pass_data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute_morton(pass_data, resources, context) {
+        const encoder = context.encoder;
+
+        shader_bvh_morton.dispatchThreads({
+            encoder,
+            thread_count_x: element_count,
+            bindings: {
+                settings: settings,
+                leaf_bounds: resources.get(pass_data.leaf_bounds),
+                scene_bounds: resources.get(pass_data.scene_bounds),
+                keys: resources.get(pass_data.keys),
+                values: resources.get(pass_data.values),
+            }
+        });
+    }
+
+    /**
+     * @param pass_data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute_emit(pass_data, resources, context) {
+        const encoder = context.encoder;
+
+        const output = resources.get(pass_data.nodes);
+
+        // the tree ends at its last node; where it starts is the caller's business
+        const end_byte = (node_word_offset + (2 * element_count - 1) * 8) * Uint32Array.BYTES_PER_ELEMENT;
+
+        assert.greaterThanOrEqual(output.size, end_byte, 'node buffer underflow');
+
+        shader_bvh_emit_hierarchy.dispatchThreads({
+            encoder,
+            thread_count_x: element_count,
+            bindings: {
+                settings: settings,
+                keys: resources.get(pass_data.keys),
+                values: resources.get(pass_data.values),
+                leaf_bounds: resources.get(pass_data.leaf_bounds),
+                leaf_payload: resources.get(pass_data.leaf_payload),
+                nodes: output,
+                parents: resources.get(pass_data.parents),
+                leaf_nodes: resources.get(pass_data.leaf_nodes),
+            }
+        });
+    }
+
+    /**
+     * @param pass_data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute_refit(pass_data, resources, context) {
+        const encoder = context.encoder;
+
+        shader_bvh_refit.dispatchThreads({
+            encoder,
+            thread_count_x: element_count,
+            bindings: {
+                settings: settings,
+                parents: resources.get(pass_data.parents),
+                leaf_nodes: resources.get(pass_data.leaf_nodes),
+                counters: resources.get(pass_data.counters),
+                nodes: resources.get(pass_data.nodes),
+            }
+        });
+    }
+
+    const morton_data = {};
+    const morton_pass = graph.add("bvh build/morton", morton_data, execute_morton);
+
+    morton_data.leaf_bounds = morton_pass.read(leaf_bounds);
+    morton_data.scene_bounds = morton_pass.read(scene_bounds);
+    morton_data.keys = morton_pass.create("bvh build/morton keys", KEY_DESCRIPTOR);
+    morton_data.values = morton_pass.create("bvh build/leaf order", KEY_DESCRIPTOR);
+
+    const sorted = graph_radix_sort({
+        graph,
+        keys: morton_data.keys,
+        values: morton_data.values,
+        element_count,
+    });
+
+    const emit_data = {};
+    const emit_pass = graph.add("bvh build/emit hierarchy", emit_data, execute_emit);
+
+    emit_data.keys = emit_pass.read(sorted.keys);
+    emit_data.values = emit_pass.read(sorted.values);
+    emit_data.leaf_bounds = emit_pass.read(leaf_bounds);
+    emit_data.leaf_payload = emit_pass.read(leaf_payload);
+    emit_data.nodes = emit_pass.write(nodes);
+    emit_data.parents = emit_pass.create("bvh build/parents", PARENTS_DESCRIPTOR);
+    emit_data.leaf_nodes = emit_pass.create("bvh build/leaf nodes", KEY_DESCRIPTOR);
+
+    const refit_data = {};
+    const refit_pass = graph.add("bvh build/refit", refit_data, execute_refit);
+
+    refit_data.parents = refit_pass.read(emit_data.parents);
+    refit_data.leaf_nodes = refit_pass.read(emit_data.leaf_nodes);
+    refit_data.counters = refit_pass.create("bvh build/refit counters", COUNTERS_DESCRIPTOR);
+    refit_data.nodes = refit_pass.write(emit_data.nodes);
+
+    return {
+        nodes: refit_data.nodes,
+        keys: sorted.keys,
+        values: sorted.values,
+    };
+}

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_emit_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.js"],"names":[],"mappings":"AAgBA,yCAA0C;AAqG1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wCAFU,aAAa,CAMpB;8BAzI2B,+BAA+B"}
+{"version":3,"file":"shader_bvh_emit_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.js"],"names":[],"mappings":"AAgBA,yCAA0C;AAwG1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wCAFU,aAAa,CAMpB;8BA5I2B,+BAA+B"}