@woosh/meep-engine 3.12.0 → 3.13.0

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

@@ -1,140 +1,143 @@
-import { atomic_u32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    BVH_NODE_BOUNDS_WORD,
-    BVH_NODE_CHILD_1_WORD,
-    BVH_NODE_CHILD_2_WORD,
-    BVH_NODE_STRIDE_WORDS
-} from "./BVH_BUFFER_LAYOUT.js";
-import { BVH_BUILD_SETTINGS_STRUCT } from "./BVH_BUILD_SETTINGS_STRUCT.js";
-
-export const BVH_REFIT_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
-    .addStorageBuffer("parents", WebGPUArray.from(u32), false)
-    // node index of each leaf ordinal; the only thing this pass knows about the tree's layout
-    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
-    // one arrival counter per internal node; must be zero at the start of every build
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    // The same buffer the emission pass wrote as typed nodes, bound flat and atomic here. Every
-    // word this pass touches is communicated between workgroups, so every access to it is an
-    // atomic one — the strictest formulation WGSL offers, and the discipline the plan's R1 rests on.
-    .addStorageBuffer("nodes", WebGPUArray.from(atomic_u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
-const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
-const NODE_CHILD_1 = ${BVH_NODE_CHILD_1_WORD}u;
-const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
-
-fn bvh_node_word(node: u32) -> u32 {
-    return settings.node_word_offset + node * NODE_STRIDE;
-}
-
-fn bvh_parent(node: u32) -> u32 {
-    return parents[settings.parents_offset + node];
-}
-
-fn bvh_read_bounds_low(node_word: u32) -> vec3<f32> {
-    return vec3<f32>(
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS])),
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 1u])),
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 2u])),
-    );
-}
-
-fn bvh_read_bounds_high(node_word: u32) -> vec3<f32> {
-    return vec3<f32>(
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 3u])),
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 4u])),
-        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 5u])),
-    );
-}
-
-@compute @workgroup_size(${BVH_REFIT_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let i = gid.x;
-    let n = settings.element_count;
-
-    if (i >= n) {
-        return;
-    }
-
-    // Start above leaf i and climb. Which node that leaf is comes from the tree rather than from a
-    // layout this kernel assumes, so a tree that was built and a tree that was copied refit alike.
-    var node = bvh_parent(leaf_nodes[settings.leaf_nodes_offset + i]);
-
-    loop {
-        if (node == BVH_NULL_NODE) {
-            // climbed past the root
-            break;
-        }
-
-        // An internal node has exactly two children, so exactly two climbs pass through it. The
-        // first arrival exits — its sibling's subtree is still being fitted, and it has nothing to
-        // wait ON: no spin, no assumption about anyone else's forward progress. The second arrival
-        // finds both children written and owns the node from here up.
-        let arrivals = atomicAdd(&counters[node], 1u);
-
-        if (arrivals == 0u) {
-            break;
-        }
-
-        let node_word = bvh_node_word(node);
-
-        let child_1 = atomicLoad(&nodes[node_word + NODE_CHILD_1]);
-        let child_2 = atomicLoad(&nodes[node_word + NODE_CHILD_2]);
-
-        let word_1 = bvh_node_word(child_1);
-        let word_2 = bvh_node_word(child_2);
-
-        let low = min(bvh_read_bounds_low(word_1), bvh_read_bounds_low(word_2));
-        let high = max(bvh_read_bounds_high(word_1), bvh_read_bounds_high(word_2));
-
-        atomicStore(&nodes[node_word + NODE_BOUNDS], bitcast<u32>(low.x));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 1u], bitcast<u32>(low.y));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 2u], bitcast<u32>(low.z));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 3u], bitcast<u32>(high.x));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 4u], bitcast<u32>(high.y));
-        atomicStore(&nodes[node_word + NODE_BOUNDS + 5u], bitcast<u32>(high.z));
-
-        node = bvh_parent(node);
-    }
-}
-`, [
-    BVH_NULL_NODE_DEFINITION,
-]);
-
-/**
- * Bottom-up AABB refit — pass 4 of {@link graph_bvh_build_lbvh}, and the last thing a build does.
- *
- * One thread per leaf climbs the `parents` chain from the node `leaf_nodes` says that leaf occupies,
- * taking an arrival counter at each internal node on the way. Nothing waits: the thread that arrives first at a node simply
- * dies, and the one that arrives second is guaranteed both children are complete, because the only
- * way to arrive is to have finished a child. That is the whole synchronisation, and it assumes
- * atomic-word visibility rather than any scheduling fairness — which is why it sits on the accepted
- * side of the engine's line on cross-workgroup communication.
- *
- * The counters must be zero when the pass starts; the graph declares them with a clear range so a
- * pool-reused buffer is cleared and a fresh one arrives zeroed already.
- *
- * The same pass serves refit-only updates (topology frozen, leaf bounds rewritten) — which is what
- * per-frame skinned BLAS needs — so it exists as a standalone dispatch rather than fused into
- * emission. Node indices are local to the tree and `settings.node_word_offset` says where node 0
- * lands, so a BLAS living inside the shared geometry arena refits through this same kernel.
- *
- * @type {ComputeShader}
- */
-export const shader_bvh_refit = ComputeShader.from({
-    label: "BVHBuild/Refit",
-    resources,
-    body,
-});
+import { atomic_u32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { BVH_NULL_NODE_DEFINITION } from "../../shader/chunk/bvh/BVH_NULL_NODE_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    BVH_NODE_BOUNDS_WORD,
+    BVH_NODE_CHILD_1_WORD,
+    BVH_NODE_CHILD_2_WORD,
+    BVH_NODE_STRIDE_WORDS
+} from "./BVH_BUFFER_LAYOUT.js";
+import { BVH_BUILD_SETTINGS_STRUCT } from "./BVH_BUILD_SETTINGS_STRUCT.js";
+
+export const BVH_REFIT_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// see shader_bvh_morton — the same build settings, carried as immediate data
+resources.setImmediate("settings", BVH_BUILD_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addStorageBuffer("parents", WebGPUArray.from(u32), false)
+    // node index of each leaf ordinal; the only thing this pass knows about the tree's layout
+    .addStorageBuffer("leaf_nodes", WebGPUArray.from(u32), false)
+    // one arrival counter per internal node; must be zero at the start of every build
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
+    // The same buffer the emission pass wrote as typed nodes, bound flat and atomic here. Every
+    // word this pass touches is communicated between workgroups, so every access to it is an
+    // atomic one — the strictest formulation WGSL offers, and the discipline the plan's R1 rests on.
+    .addStorageBuffer("nodes", WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const NODE_STRIDE = ${BVH_NODE_STRIDE_WORDS}u;
+const NODE_BOUNDS = ${BVH_NODE_BOUNDS_WORD}u;
+const NODE_CHILD_1 = ${BVH_NODE_CHILD_1_WORD}u;
+const NODE_CHILD_2 = ${BVH_NODE_CHILD_2_WORD}u;
+
+fn bvh_node_word(node: u32) -> u32 {
+    return settings.node_word_offset + node * NODE_STRIDE;
+}
+
+fn bvh_parent(node: u32) -> u32 {
+    return parents[settings.parents_offset + node];
+}
+
+fn bvh_read_bounds_low(node_word: u32) -> vec3<f32> {
+    return vec3<f32>(
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS])),
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 1u])),
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 2u])),
+    );
+}
+
+fn bvh_read_bounds_high(node_word: u32) -> vec3<f32> {
+    return vec3<f32>(
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 3u])),
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 4u])),
+        bitcast<f32>(atomicLoad(&nodes[node_word + NODE_BOUNDS + 5u])),
+    );
+}
+
+@compute @workgroup_size(${BVH_REFIT_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+    let n = settings.element_count;
+
+    if (i >= n) {
+        return;
+    }
+
+    // Start above leaf i and climb. Which node that leaf is comes from the tree rather than from a
+    // layout this kernel assumes, so a tree that was built and a tree that was copied refit alike.
+    var node = bvh_parent(leaf_nodes[settings.leaf_nodes_offset + i]);
+
+    loop {
+        if (node == BVH_NULL_NODE) {
+            // climbed past the root
+            break;
+        }
+
+        // An internal node has exactly two children, so exactly two climbs pass through it. The
+        // first arrival exits — its sibling's subtree is still being fitted, and it has nothing to
+        // wait ON: no spin, no assumption about anyone else's forward progress. The second arrival
+        // finds both children written and owns the node from here up.
+        let arrivals = atomicAdd(&counters[node], 1u);
+
+        if (arrivals == 0u) {
+            break;
+        }
+
+        let node_word = bvh_node_word(node);
+
+        let child_1 = atomicLoad(&nodes[node_word + NODE_CHILD_1]);
+        let child_2 = atomicLoad(&nodes[node_word + NODE_CHILD_2]);
+
+        let word_1 = bvh_node_word(child_1);
+        let word_2 = bvh_node_word(child_2);
+
+        let low = min(bvh_read_bounds_low(word_1), bvh_read_bounds_low(word_2));
+        let high = max(bvh_read_bounds_high(word_1), bvh_read_bounds_high(word_2));
+
+        atomicStore(&nodes[node_word + NODE_BOUNDS], bitcast<u32>(low.x));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 1u], bitcast<u32>(low.y));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 2u], bitcast<u32>(low.z));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 3u], bitcast<u32>(high.x));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 4u], bitcast<u32>(high.y));
+        atomicStore(&nodes[node_word + NODE_BOUNDS + 5u], bitcast<u32>(high.z));
+
+        node = bvh_parent(node);
+    }
+}
+`, [
+    BVH_NULL_NODE_DEFINITION,
+]);
+
+/**
+ * Bottom-up AABB refit — pass 4 of {@link graph_bvh_build_lbvh}, and the last thing a build does.
+ *
+ * One thread per leaf climbs the `parents` chain from the node `leaf_nodes` says that leaf occupies,
+ * taking an arrival counter at each internal node on the way. Nothing waits: the thread that arrives first at a node simply
+ * dies, and the one that arrives second is guaranteed both children are complete, because the only
+ * way to arrive is to have finished a child. That is the whole synchronisation, and it assumes
+ * atomic-word visibility rather than any scheduling fairness — which is why it sits on the accepted
+ * side of the engine's line on cross-workgroup communication.
+ *
+ * The counters must be zero when the pass starts; the graph declares them with a clear range so a
+ * pool-reused buffer is cleared and a fresh one arrives zeroed already.
+ *
+ * The same pass serves refit-only updates (topology frozen, leaf bounds rewritten) — which is what
+ * per-frame skinned BLAS needs — so it exists as a standalone dispatch rather than fused into
+ * emission. Node indices are local to the tree and `settings.node_word_offset` says where node 0
+ * lands, so a BLAS living inside the shared geometry arena refits through this same kernel.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh_refit = ComputeShader.from({
+    label: "BVHBuild/Refit",
+    resources,
+    body,
+});

package/src/shade/renderer/gpu_primitive/bvh/verify_gpu_bvh_build.d.ts

@@ -18,8 +18,8 @@
  * And it reports what the risk register asks to be measured rather than assumed: the depth
  * histogram against the shared traversal stack, and the SAH cost of the tree.
  *
- * Per-pass GPU timings go to the console for the largest case, through the debug-timers path —
- * the `timer` argument `graph_compute_pass` forwards is silently dropped by
+ * Per-pass GPU timings go to the console for the largest case, through a {@link GPUFrameRecorder}
+ * of its own — the `timer` argument `graph_compute_pass` forwards is silently dropped by
  * `ComputeShader.dispatch`, so this is the path that actually reports anything.
  *
  * One graph and one submission per case: the transients then come and go with each build instead

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

@@ -1 +1 @@
-{"version":3,"file":"verify_gpu_bvh_build.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/verify_gpu_bvh_build.js"],"names":[],"mappings":"AAwQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,sEAKC"}
+{"version":3,"file":"verify_gpu_bvh_build.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/verify_gpu_bvh_build.js"],"names":[],"mappings":"AAyQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,sEAKC"}

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

@@ -2,6 +2,7 @@ import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { ebvh_build_hierarchy_radix } from "../../../../core/bvh2/bvh3/ebvh_build_hierarchy_radix.js";
 import { FrameGraph } from "../../../../engine/graphics/render/frame_graph/FrameGraph.js";
 import { ShadeGPUCommandContext } from "../../../device/ShadeGPUCommandContext.js";
+import { GPUFrameRecorder } from "../../../device/timing/profile/GPUFrameRecorder.js";
 import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { graph_inspect_gpu_buffer } from "../../buffer/graph_inspect_gpu_buffer.js";
@@ -282,8 +283,8 @@ function check(test_case, input, tree, sorted_keys, sorted_values) {
  * And it reports what the risk register asks to be measured rather than assumed: the depth
  * histogram against the shared traversal stack, and the SAH cost of the tree.
  *
- * Per-pass GPU timings go to the console for the largest case, through the debug-timers path —
- * the `timer` argument `graph_compute_pass` forwards is silently dropped by
+ * Per-pass GPU timings go to the console for the largest case, through a {@link GPUFrameRecorder}
+ * of its own — the `timer` argument `graph_compute_pass` forwards is silently dropped by
  * `ComputeShader.dispatch`, so this is the path that actually reports anything.
  *
  * One graph and one submission per case: the transients then come and go with each build instead
@@ -310,13 +311,22 @@ function run_case(graphics, test_case) {
 
     const cmd = ShadeGPUCommandContext.create(graphics, `verify/gpu bvh build/${test_case.name}`);
 
-    // Only the large case: the number worth having is the build time at scale, and a table per
-    // case would bury it.
+    /**
+     * Only the large case: the number worth having is the build time at scale, and a table per case
+     * would bury it.
+     *
+     * @type {GPUFrameRecorder|null}
+     */
+    let recorder = null;
+
     if (test_case.count >= 100000) {
-        cmd.enable_debug_timers(table => {
-            console.log(`[BVH] GPU timings — ${test_case.name}`);
-            console.table(table);
-        });
+        recorder = new GPUFrameRecorder(0, performance.now());
+
+        // dispatch and invocation counts alongside the durations — for a build, the interesting
+        // question is which pass is the wrong shape, not only which is slow
+        recorder.enable_work_capture();
+
+        cmd.enable_profiling(recorder, 0);
     }
 
     const storage_usage = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC;
@@ -417,6 +427,31 @@ function run_case(graphics, test_case) {
         });
     }
 
+    if (recorder !== null) {
+        // subscribed before the graph runs, so each pass is attributed to the node that opened it
+        recorder.attach_graph(graph);
+    }
+
     cmd.encodeGraph(graph);
     cmd.finish();
+
+    if (recorder !== null) {
+        const captured = recorder;
+
+        /*
+         `profiling_absorbed`, not `done`. `done` resolves at submit, before a single timestamp has
+         been read back — closing there reports an empty table every time.
+        */
+        cmd.profiling_absorbed.then(() => {
+            const frame = captured.close(performance.now());
+
+            console.log(`[BVH] GPU timings — ${test_case.name}`);
+            console.table(frame.spans.map(span => ({
+                label: span.label,
+                duration_ms: span.duration_ns * 1e-6,
+                dispatches: span.work?.dispatch_count ?? 0,
+                invocations: span.work?.invocation_count ?? 0
+            })));
+        });
+    }
 }

package/src/shade/renderer/gpu_primitive/sort/graph_radix_sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_radix_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/graph_radix_sort.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,uFAFa;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,CA4JxC"}
+{"version":3,"file":"graph_radix_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/graph_radix_sort.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,uFAFa;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,CA4JxC"}

package/src/shade/renderer/gpu_primitive/sort/graph_radix_sort.js

@@ -4,7 +4,6 @@ import { warn_limited } from "../../../util/warn_limited.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { graph_prefix_scan_csdldf } from "../prefix_sum/v1/graph_prefix_scan_csdldf.js";
 import { RADIX, RADIX_LOG, RADIX_PASSES, SORT_TILE_SIZE, SPINE_HEADER_WORDS } from "./defs.js";
-import { SORT_PASS_SETTINGS_STRUCT } from "./SORT_PASS_SETTINGS_STRUCT.js";
 import { shader_radix_sort_histogram } from "./shader_radix_sort_histogram.js";
 import { shader_radix_sort_scatter } from "./shader_radix_sort_scatter.js";
 
@@ -95,11 +94,11 @@ export function graph_radix_sort({
             encoder,
             group_count_x: tile_count,
             bindings: {
-                settings: encoder.allocateTransientValueBuffer(SORT_PASS_SETTINGS_STRUCT, {
+                settings: {
                     shift: pass_data.shift,
                     element_count,
                     tile_count,
-                }),
+                },
                 keys: resources.get(pass_data.keys),
                 spine: resources.get(pass_data.spine),
             }
@@ -130,11 +129,11 @@ export function graph_radix_sort({
             encoder,
             group_count_x: tile_count,
             bindings: {
-                settings: encoder.allocateTransientValueBuffer(SORT_PASS_SETTINGS_STRUCT, {
+                settings: {
                     shift: pass_data.shift,
                     element_count,
                     tile_count,
-                }),
+                },
                 in_keys,
                 in_values,
                 out_keys,

package/src/shade/renderer/gpu_primitive/sort/shader_radix_sort_histogram.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_radix_sort_histogram.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/shader_radix_sort_histogram.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;GAYG;AACH,0CAFU,aAAa,CAMpB;8BAhF2B,+BAA+B"}
+{"version":3,"file":"shader_radix_sort_histogram.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/shader_radix_sort_histogram.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;;;GAYG;AACH,0CAFU,aAAa,CAMpB;8BApF2B,+BAA+B"}

package/src/shade/renderer/gpu_primitive/sort/shader_radix_sort_histogram.js

@@ -1,84 +1,88 @@
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_sort_digit } from "./chunk_sort_digit.js";
-import { RADIX, SORT_KEYS_PER_THREAD, SORT_TILE_SIZE, SORT_WORKGROUP_SIZE } from "./defs.js";
-import { SORT_PASS_SETTINGS_STRUCT } from "./SORT_PASS_SETTINGS_STRUCT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", SORT_PASS_SETTINGS_STRUCT)
-    .addStorageBuffer("keys", WebGPUArray.from(u32), false)
-    // `{count: u32, elements: array<vec4u>}` as the scan sees it, flat as this pass writes it.
-    // Every cell is produced by exactly one thread of one workgroup, so no atomics: the only
-    // consumer is a later dispatch, and WebGPU orders dispatches against each other.
-    .addStorageBuffer("spine", WebGPUArray.from(u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const WORKGROUP_SIZE = ${SORT_WORKGROUP_SIZE}u;
-const KEYS_PER_THREAD = ${SORT_KEYS_PER_THREAD}u;
-const TILE_SIZE = ${SORT_TILE_SIZE}u;
-const RADIX = ${RADIX}u;
-
-// One bin per thread — RADIX and the workgroup size are equal, so the clear and the write-out are
-// both a single unstrided step.
-var<workgroup> wg_histogram: array<atomic<u32>, RADIX>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(local_invocation_index) thread_id: u32,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>,
-) {
-    let tile = workgroup_id.x;
-
-    atomicStore(&wg_histogram[thread_id], 0u);
-
-    workgroupBarrier();
-
-    // Striped so that neighbouring threads read neighbouring addresses. The tail tile is partial;
-    // the keys past the end are not counted, which is what lets the scatter recognise them later
-    // by position alone.
-    let tile_base = tile * TILE_SIZE;
-    for (var k = 0u; k < KEYS_PER_THREAD; k += 1u) {
-        let source = tile_base + k * WORKGROUP_SIZE + thread_id;
-
-        if (source < settings.element_count) {
-            atomicAdd(&wg_histogram[sort_extract_digit(keys[source], settings.shift)], 1u);
-        }
-    }
-
-    workgroupBarrier();
-
-    spine[sort_spine_index(thread_id, tile, settings.tile_count)] = atomicLoad(&wg_histogram[thread_id]);
-
-    // The scan is indirect-dispatched off an element count it reads from word 0 of this buffer.
-    if (tile == 0u && thread_id == 0u) {
-        spine[0] = settings.tile_count * RADIX;
-    }
-}
-`, [
-    chunk_sort_digit,
-]);
-
-/**
- * Per-tile 256-bin digit histogram — stage (a) of one digit pass of {@link graph_radix_sort}.
- *
- * One workgroup per tile; the counts land in the spine bin-major, so that the single scan that
- * follows produces global digit offsets and per-tile offsets in one traversal.
- *
- * Subgroup ballot peer-aggregation ahead of the workgroup atomics (the deleted one-sweep port's
- * `WarpLevelMultiSplit`) is the recorded upgrade here; it is left out of v1 because this pass reads
- * each key once and is bandwidth-shaped, while the machinery it needs is the widest part of the
- * subgroup-size surface.
- *
- * @type {ComputeShader}
- */
-export const shader_radix_sort_histogram = ComputeShader.from({
-    label: "RadixSort/Histogram",
-    resources,
-    body,
-});
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_sort_digit } from "./chunk_sort_digit.js";
+import { RADIX, SORT_KEYS_PER_THREAD, SORT_TILE_SIZE, SORT_WORKGROUP_SIZE } from "./defs.js";
+import { SORT_PASS_SETTINGS_STRUCT } from "./SORT_PASS_SETTINGS_STRUCT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, 12 bytes, read-only: immediate data rather than a uniform buffer. A 32-bit key sort
+// runs four passes, and both this shader and the scatter took a buffer of their own in each.
+resources.setImmediate("settings", SORT_PASS_SETTINGS_STRUCT);
+
+resources.createGroup()
+    .addStorageBuffer("keys", WebGPUArray.from(u32), false)
+    // `{count: u32, elements: array<vec4u>}` as the scan sees it, flat as this pass writes it.
+    // Every cell is produced by exactly one thread of one workgroup, so no atomics: the only
+    // consumer is a later dispatch, and WebGPU orders dispatches against each other.
+    .addStorageBuffer("spine", WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const WORKGROUP_SIZE = ${SORT_WORKGROUP_SIZE}u;
+const KEYS_PER_THREAD = ${SORT_KEYS_PER_THREAD}u;
+const TILE_SIZE = ${SORT_TILE_SIZE}u;
+const RADIX = ${RADIX}u;
+
+// One bin per thread — RADIX and the workgroup size are equal, so the clear and the write-out are
+// both a single unstrided step.
+var<workgroup> wg_histogram: array<atomic<u32>, RADIX>;
+
+@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
+fn main(
+    @builtin(local_invocation_index) thread_id: u32,
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+) {
+    let tile = workgroup_id.x;
+
+    atomicStore(&wg_histogram[thread_id], 0u);
+
+    workgroupBarrier();
+
+    // Striped so that neighbouring threads read neighbouring addresses. The tail tile is partial;
+    // the keys past the end are not counted, which is what lets the scatter recognise them later
+    // by position alone.
+    let tile_base = tile * TILE_SIZE;
+    for (var k = 0u; k < KEYS_PER_THREAD; k += 1u) {
+        let source = tile_base + k * WORKGROUP_SIZE + thread_id;
+
+        if (source < settings.element_count) {
+            atomicAdd(&wg_histogram[sort_extract_digit(keys[source], settings.shift)], 1u);
+        }
+    }
+
+    workgroupBarrier();
+
+    spine[sort_spine_index(thread_id, tile, settings.tile_count)] = atomicLoad(&wg_histogram[thread_id]);
+
+    // The scan is indirect-dispatched off an element count it reads from word 0 of this buffer.
+    if (tile == 0u && thread_id == 0u) {
+        spine[0] = settings.tile_count * RADIX;
+    }
+}
+`, [
+    chunk_sort_digit,
+]);
+
+/**
+ * Per-tile 256-bin digit histogram — stage (a) of one digit pass of {@link graph_radix_sort}.
+ *
+ * One workgroup per tile; the counts land in the spine bin-major, so that the single scan that
+ * follows produces global digit offsets and per-tile offsets in one traversal.
+ *
+ * Subgroup ballot peer-aggregation ahead of the workgroup atomics (the deleted one-sweep port's
+ * `WarpLevelMultiSplit`) is the recorded upgrade here; it is left out of v1 because this pass reads
+ * each key once and is bandwidth-shaped, while the machinery it needs is the widest part of the
+ * subgroup-size surface.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_radix_sort_histogram = ComputeShader.from({
+    label: "RadixSort/Histogram",
+    resources,
+    body,
+});

package/src/shade/renderer/gpu_primitive/sort/shader_radix_sort_scatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_radix_sort_scatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/shader_radix_sort_scatter.js"],"names":[],"mappings":"AA8KA;;;;;;;;;;;GAWG;AACH,wCAFU,aAAa,CAMpB;8BA1L2B,+BAA+B"}
+{"version":3,"file":"shader_radix_sort_scatter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/shader_radix_sort_scatter.js"],"names":[],"mappings":"AAiLA;;;;;;;;;;;GAWG;AACH,wCAFU,aAAa,CAMpB;8BA7L2B,+BAA+B"}