@woosh/meep-engine 3.11.3 → 3.13.0

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

@@ -3,7 +3,7 @@ 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 { 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";
@@ -110,11 +110,11 @@ export function graph_bvh_build_lbvh({
     function execute_morton(pass_data, resources, context) {
         const encoder = context.encoder;
 
-        shader_bvh_morton.dispatchLinear({
+        shader_bvh_morton.dispatchThreads({
             encoder,
-            element_count,
+            thread_count_x: element_count,
             bindings: {
-                settings: encoder.allocateTransientValueBuffer(BVH_BUILD_SETTINGS_STRUCT, settings),
+                settings: settings,
                 leaf_bounds: resources.get(pass_data.leaf_bounds),
                 scene_bounds: resources.get(pass_data.scene_bounds),
                 keys: resources.get(pass_data.keys),
@@ -138,11 +138,11 @@ export function graph_bvh_build_lbvh({
 
         assert.greaterThanOrEqual(output.size, end_byte, 'node buffer underflow');
 
-        shader_bvh_emit_hierarchy.dispatchLinear({
+        shader_bvh_emit_hierarchy.dispatchThreads({
             encoder,
-            element_count,
+            thread_count_x: element_count,
             bindings: {
-                settings: encoder.allocateTransientValueBuffer(BVH_BUILD_SETTINGS_STRUCT, settings),
+                settings: settings,
                 keys: resources.get(pass_data.keys),
                 values: resources.get(pass_data.values),
                 leaf_bounds: resources.get(pass_data.leaf_bounds),
@@ -162,11 +162,11 @@ export function graph_bvh_build_lbvh({
     function execute_refit(pass_data, resources, context) {
         const encoder = context.encoder;
 
-        shader_bvh_refit.dispatchLinear({
+        shader_bvh_refit.dispatchThreads({
             encoder,
-            element_count,
+            thread_count_x: element_count,
             bindings: {
-                settings: encoder.allocateTransientValueBuffer(BVH_BUILD_SETTINGS_STRUCT, settings),
+                settings: settings,
                 parents: resources.get(pass_data.parents),
                 leaf_nodes: resources.get(pass_data.leaf_nodes),
                 counters: resources.get(pass_data.counters),

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,CAOpB;8BA1I2B,+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"}

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

@@ -17,8 +17,11 @@ import { chunk_bvh_find_split } from "./chunk_bvh_find_split.js";
 export const BVH_EMIT_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()
-    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
     // sorted Morton codes, and the leaf index each one came from
     .addStorageBuffer("keys", WebGPUArray.from(u32), false)
     .addStorageBuffer("values", WebGPUArray.from(u32), false)
@@ -139,5 +142,4 @@ export const shader_bvh_emit_hierarchy = ComputeShader.from({
     label: "BVHBuild/EmitHierarchy",
     resources,
     body,
-    group_size: [BVH_EMIT_WORKGROUP_SIZE, 1, 1],
 });

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

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_morton.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js"],"names":[],"mappings":"AAQA,2CAA4C;AAwD5C;;;;;;;;;;;;GAYG;AACH,gCAFU,aAAa,CAOpB;8BA9E2B,+BAA+B"}
+{"version":3,"file":"shader_bvh_morton.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js"],"names":[],"mappings":"AAQA,2CAA4C;AA6D5C;;;;;;;;;;;;GAYG;AACH,gCAFU,aAAa,CAMpB;8BAlF2B,+BAA+B"}

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

@@ -1,83 +1,87 @@
-import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { chunk_v3_morton_encode } from "../../shader/chunk/bvh/morton/chunk_v3_morton_encode.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { BVH_BUILD_SETTINGS_STRUCT } from "./BVH_BUILD_SETTINGS_STRUCT.js";
-
-export const BVH_MORTON_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("settings", BVH_BUILD_SETTINGS_STRUCT)
-    // six floats per leaf: [min.xyz, max.xyz]
-    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), false)
-    // the same six floats over the whole set, produced by the extraction pass
-    .addStorageBuffer("scene_bounds", WebGPUArray.from(f32), false)
-    .addStorageBuffer("keys", WebGPUArray.from(u32), true)
-    .addStorageBuffer("values", WebGPUArray.from(u32), true);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${BVH_MORTON_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let i = gid.x;
-
-    if (i >= settings.element_count) {
-        return;
-    }
-
-    let base = i * 6u;
-
-    let low = vec3<f32>(leaf_bounds[base], leaf_bounds[base + 1u], leaf_bounds[base + 2u]);
-    let high = vec3<f32>(leaf_bounds[base + 3u], leaf_bounds[base + 4u], leaf_bounds[base + 5u]);
-
-    let centroid = (low + high) * 0.5;
-
-    let scene_low = vec3<f32>(scene_bounds[0], scene_bounds[1], scene_bounds[2]);
-    let scene_high = vec3<f32>(scene_bounds[3], scene_bounds[4], scene_bounds[5]);
-
-    let span = scene_high - scene_low;
-
-    // An axis of zero extent contributes nothing to the code, exactly as it does in
-    // v3_morton_encode_bounded — every centroid quantises to 0 along it rather than to a division
-    // by zero.
-    let scale = select(vec3<f32>(0.0), vec3<f32>(1.0) / span, span != vec3<f32>(0.0));
-
-    // The centroid of a leaf box is inside the union of every leaf box by construction, so the
-    // clamp never binds on well-formed input; it is here so that a rounding error at the extreme,
-    // or a NaN-free degenerate box, cannot produce an out-of-range quantised coordinate.
-    let normalized = clamp((centroid - scene_low) * scale, vec3<f32>(0.0), vec3<f32>(1.0));
-
-    let quantised = vec3<u32>(round(normalized * 1023.0));
-
-    keys[i] = v3_morton_encode(quantised.x, quantised.y, quantised.z);
-
-    // the sort carries this along as the payload, so after it the leaves are in Morton order
-    values[i] = i;
-}
-`, [
-    chunk_v3_morton_encode,
-]);
-
-/**
- * Morton code per leaf — pass 1 of {@link graph_bvh_build_lbvh}.
- *
- * The leaf's centroid is quantised to ten bits per axis inside the scene bounds and interleaved
- * into a 30-bit code, matching `v3_morton_encode_bounded` + `v3_morton_encode_normalized` on the
- * CPU term for term (`round(1023 * t)`, zero-extent axes scaled by zero). `values[i] = i` seeds the
- * permutation the sort then carries.
- *
- * Pure per-invocation: no barriers, no atomics, no subgroups — which is what lets the emulator tier
- * run it point-wise against the CPU encoder.
- *
- * @type {ComputeShader}
- */
-export const shader_bvh_morton = ComputeShader.from({
-    label: "BVHBuild/Morton",
-    resources,
-    body,
-    group_size: [BVH_MORTON_WORKGROUP_SIZE, 1, 1],
-});
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_v3_morton_encode } from "../../shader/chunk/bvh/morton/chunk_v3_morton_encode.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { BVH_BUILD_SETTINGS_STRUCT } from "./BVH_BUILD_SETTINGS_STRUCT.js";
+
+export const BVH_MORTON_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 20 bytes, read-only: immediate data rather than a uniform buffer. An LBVH build
+// dispatches this shader, emit_hierarchy and refit in sequence, each of which was allocating and
+// filling its own copy of the same settings.
+resources.setImmediate("settings", BVH_BUILD_SETTINGS_STRUCT);
+
+resources.createGroup()
+    // six floats per leaf: [min.xyz, max.xyz]
+    .addStorageBuffer("leaf_bounds", WebGPUArray.from(f32), false)
+    // the same six floats over the whole set, produced by the extraction pass
+    .addStorageBuffer("scene_bounds", WebGPUArray.from(f32), false)
+    .addStorageBuffer("keys", WebGPUArray.from(u32), true)
+    .addStorageBuffer("values", WebGPUArray.from(u32), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${BVH_MORTON_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
+    let i = gid.x;
+
+    if (i >= settings.element_count) {
+        return;
+    }
+
+    let base = i * 6u;
+
+    let low = vec3<f32>(leaf_bounds[base], leaf_bounds[base + 1u], leaf_bounds[base + 2u]);
+    let high = vec3<f32>(leaf_bounds[base + 3u], leaf_bounds[base + 4u], leaf_bounds[base + 5u]);
+
+    let centroid = (low + high) * 0.5;
+
+    let scene_low = vec3<f32>(scene_bounds[0], scene_bounds[1], scene_bounds[2]);
+    let scene_high = vec3<f32>(scene_bounds[3], scene_bounds[4], scene_bounds[5]);
+
+    let span = scene_high - scene_low;
+
+    // An axis of zero extent contributes nothing to the code, exactly as it does in
+    // v3_morton_encode_bounded — every centroid quantises to 0 along it rather than to a division
+    // by zero.
+    let scale = select(vec3<f32>(0.0), vec3<f32>(1.0) / span, span != vec3<f32>(0.0));
+
+    // The centroid of a leaf box is inside the union of every leaf box by construction, so the
+    // clamp never binds on well-formed input; it is here so that a rounding error at the extreme,
+    // or a NaN-free degenerate box, cannot produce an out-of-range quantised coordinate.
+    let normalized = clamp((centroid - scene_low) * scale, vec3<f32>(0.0), vec3<f32>(1.0));
+
+    let quantised = vec3<u32>(round(normalized * 1023.0));
+
+    keys[i] = v3_morton_encode(quantised.x, quantised.y, quantised.z);
+
+    // the sort carries this along as the payload, so after it the leaves are in Morton order
+    values[i] = i;
+}
+`, [
+    chunk_v3_morton_encode,
+]);
+
+/**
+ * Morton code per leaf — pass 1 of {@link graph_bvh_build_lbvh}.
+ *
+ * The leaf's centroid is quantised to ten bits per axis inside the scene bounds and interleaved
+ * into a 30-bit code, matching `v3_morton_encode_bounded` + `v3_morton_encode_normalized` on the
+ * CPU term for term (`round(1023 * t)`, zero-extent axes scaled by zero). `values[i] = i` seeds the
+ * permutation the sort then carries.
+ *
+ * Pure per-invocation: no barriers, no atomics, no subgroups — which is what lets the emulator tier
+ * run it point-wise against the CPU encoder.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_bvh_morton = ComputeShader.from({
+    label: "BVHBuild/Morton",
+    resources,
+    body,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_refit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_refit.js"],"names":[],"mappings":"AAcA,0CAA2C;AAqG3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+BAFU,aAAa,CAOpB;8BAxI2B,+BAA+B"}
+{"version":3,"file":"shader_bvh_refit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_refit.js"],"names":[],"mappings":"AAcA,0CAA2C;AAwG3C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+BAFU,aAAa,CAMpB;8BA1I2B,+BAA+B"}

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

@@ -15,8 +15,11 @@ 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()
-    .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)
@@ -137,5 +140,4 @@ export const shader_bvh_refit = ComputeShader.from({
     label: "BVHBuild/Refit",
     resources,
     body,
-    group_size: [BVH_REFIT_WORKGROUP_SIZE, 1, 1],
 });

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,CAOpB;8BAjF2B,+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,85 +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,
-    group_size: [SORT_WORKGROUP_SIZE, 1, 1],
-});
+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,CAOpB;8BA3L2B,+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"}