@woosh/meep-engine 3.42.0 → 3.44.0

package/src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_vgeo_expand_instances_to_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAX+B,KAAK;IACT,YAAY,EAA5B,MAAM;IACU,eAAe,EAA/B,MAAM;IACkB,IAAI;IACO,OAAO;IACb,MAAM;IACjC,MAAM,CA4TlB"}
+{"version":3,"file":"graph_vgeo_expand_instances_to_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IAX+B,KAAK;IACT,YAAY,EAA5B,MAAM;IACU,eAAe,EAA/B,MAAM;IACkB,IAAI;IACO,OAAO;IACb,MAAM;IACjC,MAAM,CA6TlB"}

package/src/shade/renderer/geometry/virtual/runtime/graph_vgeo_expand_instances_to_meshlets.js

@@ -5,8 +5,12 @@ import {
     graph_build_indirect_dispatch_command,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
 } from "../../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
-import { graph_prefix_scan_csdldf } from "../../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import {
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
 import { RasterizationCollectionType } from "../../../rasterize/expand/RasterizationCollectionType.js";
+import { graph_create_buffer } from "../../../shader/graph/graph_create_buffer.js";
 import { shader_vgeo_cut_collect } from "./cut/shader_vgeo_cut_collect.js";
 import { shader_vgeo_cut_queue_prepare } from "./cut/shader_vgeo_cut_queue_prepare.js";
 import { shader_vgeo_cut_queue_remainder } from "./cut/shader_vgeo_cut_queue_remainder.js";
@@ -186,7 +190,8 @@ export function graph_vgeo_expand_instances_to_meshlets({
      */
     const prefix_sums = graph_prefix_scan_csdldf({
         graph,
-        data: collect_data.claim_widths,
+        input: collect_data.claim_widths,
+        output: graph_create_buffer(graph, "vg claim offsets", prefix_scan_csdldf_output_descriptor(instance_capacity)),
         element_max_count: instance_capacity,
     });
 

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.d.ts

@@ -1,25 +1,43 @@
+/**
+ * A transient {@link graph_prefix_scan_csdldf} output for up to `element_max_count` elements: the count, padded to 16
+ * bytes, then the sums in whole vec4 blocks. The scan writes the count itself, so nothing needs clearing.
+ *
+ * @param {number} element_max_count
+ * @returns {BufferResourceDescriptor}
+ */
+export function prefix_scan_csdldf_output_descriptor(element_max_count: number): BufferResourceDescriptor;
 /**
  * Indirect pass.
- * Input data is expected to be counts in form:
+ * Inclusive prefix sums of `input` into `output`.
+ * Both are expected in the form:
  * ```wgsl
  *  struct InputData{
  *     count:u32,
  *     elements: array<u32> // counts: [count0, count1, count2, ... countN-1]
  *  }
  * ```
- * Data is modified in-place, elements are replaced with prefix sums.
- * Make sure to set `element_max_count` to be at least equal to the number of elements in the input, otherwise an incomplete scan will be performed.
- * The penalty for `element_max_count` being too big is fairly small, requiring more memory for the pass and a larger `bufferClear` region.
+ * `output` receives the input's count and, for each of its elements, the sum of the elements up to and including it.
+ * `input` is never written: the scan's fallback re-reads a tile's inputs while other tiles are writing their sums, so
+ * the two cannot be one buffer.
+ *
+ * The work follows the input's count, read on the device; `element_max_count` sizes only the memory — the spine, and
+ * what `output` must hold — so make it at least the most elements the input can carry, otherwise an incomplete scan will
+ * be performed. Where a count records demand and runs past a soft limit — a culled collection does — that is what the
+ * buffer holds, not the limit. The penalty for `element_max_count` being too big is fairly small: a larger spine to clear.
  *
  * @param {Object} options
  * @param {FrameGraph} options.graph
- * @param {number} options.data buffer resource ID, array<u32> first position must be "count". The buffer must be 16-byte aligned.
+ * @param {number} options.input buffer resource ID, array<u32> first position must be "count". The buffer must be 16-byte aligned.
+ * @param {number} options.output buffer resource ID of the same layout, at least `16 + ⌈element_max_count / 4⌉ · 16` bytes;
+ * see {@link prefix_scan_csdldf_output_descriptor}
  * @param {number} [options.element_max_count=1,048,576] how many elements might be in the input, this is a limit
- * @returns {number} buffer resource ID with prefix sums, this is rewritten input. The first position (count) is untouched.
+ * @returns {number} buffer resource ID of the written output
  */
-export function graph_prefix_scan_csdldf({ graph, data, element_max_count, }: {
+export function graph_prefix_scan_csdldf({ graph, input, output, element_max_count, }: {
     graph: FrameGraph;
-    data: number;
+    input: number;
+    output: number;
     element_max_count?: number;
 }): number;
+import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
 //# sourceMappingURL=graph_prefix_scan_csdldf.d.ts.map

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_prefix_scan_csdldf.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAL+B,KAAK;IACT,IAAI,EAApB,MAAM;IACW,iBAAiB,GAAlC,MAAM;IACJ,MAAM,CAgFlB"}
+{"version":3,"file":"graph_prefix_scan_csdldf.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,wEAHW,MAAM,GACJ,wBAAwB,CAMpC;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAP+B,KAAK;IACT,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IAEW,iBAAiB,GAAlC,MAAM;IACJ,MAAM,CAwElB;yCA3HwC,sDAAsD"}

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js

@@ -3,51 +3,74 @@ import { round_up } from "../../../../../core/math/round_up.js";
 import { warn_limited } from "../../../../util/warn_limited.js";
 import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
 import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { INDIRECT_COMPUTE_COMMAND_DESCRIPTOR } from "../../indirect/IndirectComputeCommandBuildPass.js";
 import {
-    build_indirect_compute_dispatch_command,
-    INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
-} from "../../indirect/IndirectComputeCommandBuildPass.js";
-import { PREFIX_SCAN_CSDLDF_PARTITION_SIZE, shader_prefix_scan_csdldf } from "./shader_prefix_scan_csdldf.js";
+    WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION
+} from "../../indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
+import {
+    PREFIX_SCAN_CSDLDF_PARTITION_SIZE,
+    shader_prefix_scan_csdldf,
+    shader_prefix_scan_csdldf_prepare
+} from "./shader_prefix_scan_csdldf.js";
+
+/**
+ * A transient {@link graph_prefix_scan_csdldf} output for up to `element_max_count` elements: the count, padded to 16
+ * bytes, then the sums in whole vec4 blocks. The scan writes the count itself, so nothing needs clearing.
+ *
+ * @param {number} element_max_count
+ * @returns {BufferResourceDescriptor}
+ */
+export function prefix_scan_csdldf_output_descriptor(element_max_count) {
+    assert.isNonNegativeInteger(element_max_count, 'element_max_count');
+
+    return BufferResourceDescriptor.from(16 + Math.max(1, Math.ceil(element_max_count / 4)) * 16, GPUBufferUsage.STORAGE);
+}
 
 
 /**
  * Indirect pass.
- * Input data is expected to be counts in form:
+ * Inclusive prefix sums of `input` into `output`.
+ * Both are expected in the form:
  * ```wgsl
  *  struct InputData{
  *     count:u32,
  *     elements: array<u32> // counts: [count0, count1, count2, ... countN-1]
  *  }
  * ```
- * Data is modified in-place, elements are replaced with prefix sums.
- * Make sure to set `element_max_count` to be at least equal to the number of elements in the input, otherwise an incomplete scan will be performed.
- * The penalty for `element_max_count` being too big is fairly small, requiring more memory for the pass and a larger `bufferClear` region.
+ * `output` receives the input's count and, for each of its elements, the sum of the elements up to and including it.
+ * `input` is never written: the scan's fallback re-reads a tile's inputs while other tiles are writing their sums, so
+ * the two cannot be one buffer.
+ *
+ * The work follows the input's count, read on the device; `element_max_count` sizes only the memory — the spine, and
+ * what `output` must hold — so make it at least the most elements the input can carry, otherwise an incomplete scan will
+ * be performed. Where a count records demand and runs past a soft limit — a culled collection does — that is what the
+ * buffer holds, not the limit. The penalty for `element_max_count` being too big is fairly small: a larger spine to clear.
  *
  * @param {Object} options
  * @param {FrameGraph} options.graph
- * @param {number} options.data buffer resource ID, array<u32> first position must be "count". The buffer must be 16-byte aligned.
+ * @param {number} options.input buffer resource ID, array<u32> first position must be "count". The buffer must be 16-byte aligned.
+ * @param {number} options.output buffer resource ID of the same layout, at least `16 + ⌈element_max_count / 4⌉ · 16` bytes;
+ * see {@link prefix_scan_csdldf_output_descriptor}
  * @param {number} [options.element_max_count=1,048,576] how many elements might be in the input, this is a limit
- * @returns {number} buffer resource ID with prefix sums, this is rewritten input. The first position (count) is untouched.
+ * @returns {number} buffer resource ID of the written output
  */
 export function graph_prefix_scan_csdldf({
                                              graph,
-                                             data,
+                                             input,
+                                             output,
                                              element_max_count = 1048576,
                                          }) {
 
     assert.isNonNegativeInteger(element_max_count, 'element_max_count');
 
-    if (element_max_count <= 0) {
-        console.warn("element_max_count <= 0, returning input");
-
-        return data;
-    }
-
     // TODO run a special prefix scan if element_max_count fits into a single group
 
-
     const group_count = Math.ceil(element_max_count / PREFIX_SCAN_CSDLDF_PARTITION_SIZE);
 
+    if (group_count > WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION) {
+        warn_limited(`group_count(=${group_count} > MAX_DISPATCH_SIZE(=${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}). Prefix scan likely incomplete`);
+    }
+
     const pass_data = {};
 
     /**
@@ -58,41 +81,35 @@ export function graph_prefix_scan_csdldf({
      */
     function execute(pass_data, resources, context) {
 
-        const data = resources.get(pass_data.data);
-        const partition_descriptor_buffer = resources.get(pass_data.partition_descriptor_buffer);
-        const command = resources.get(pass_data.command);
-
         const encoder = context.encoder;
 
-        const MAX_DISPATCH_SIZE = encoder.device.limits.maxComputeWorkgroupsPerDimension;
+        const scan_in = resources.get(pass_data.input);
+        const scan_out = resources.get(pass_data.output);
+        const command = resources.get(pass_data.command);
 
-        if (group_count > MAX_DISPATCH_SIZE) {
-            warn_limited(`group_count(=${group_count} > MAX_DISPATCH_SIZE(=${MAX_DISPATCH_SIZE}). Prefix scan likely incomplete`);
-        }
+        assert.notEqual(scan_in, scan_out, 'input and output must be different buffers');
+        assert.greaterThanOrEqual(scan_out.size, 16 + Math.ceil(element_max_count / 4) * 16, 'output is too small for element_max_count');
 
-        build_indirect_compute_dispatch_command(
-            PREFIX_SCAN_CSDLDF_PARTITION_SIZE,
+        shader_prefix_scan_csdldf_prepare.dispatch({
             encoder,
-            data,
-            0,
-            command,
-            0,
-        );
+            bindings: { scan_in, scan_out, command },
+        });
 
         shader_prefix_scan_csdldf.dispatchIndirect({
             encoder,
             command,
             bindings: {
-                scan_in: data,
-                spine: partition_descriptor_buffer,
+                scan_in,
+                scan_out,
+                spine: resources.get(pass_data.partition_descriptor_buffer),
             }
         });
     }
 
     const pass = graph.add("prefix sum", pass_data, execute);
 
-    pass.read(data);
-    pass_data.data = pass.write(data);
+    pass_data.input = pass.read(input);
+    pass_data.output = pass.write(pass.read(output));
 
     pass_data.command = pass.create("command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
 
@@ -106,5 +123,5 @@ export function graph_prefix_scan_csdldf({
         )
     );
 
-    return pass_data.data;
-}
+    return pass_data.output;
+}

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.d.ts

@@ -23,5 +23,12 @@ export const PREFIX_SCAN_CSDLDF_HEADER_WORDS: number;
  * @type {ComputeShader}
  */
 export const shader_prefix_scan_csdldf: ComputeShader;
+/**
+ * One thread ahead of {@link shader_prefix_scan_csdldf}: the scan's dispatch, a workgroup per partition of the input's
+ * count, and the output's count. The output gets its count here rather than from the scan's first tile because an input
+ * of no elements dispatches no tile at all.
+ * @type {ComputeShader}
+ */
+export const shader_prefix_scan_csdldf_prepare: ComputeShader;
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_prefix_scan_csdldf.d.ts.map

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_prefix_scan_csdldf.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,gDAFU,MAAM,CAEsC;AAOtD;;;;;;;;;;GAUG;AACH,8CAFU,MAAM,CAE6E;AA0S7F;;;;;GAKG;AACH,wCAFU,aAAa,CAMpB;8BA9U2B,kCAAkC"}
+{"version":3,"file":"shader_prefix_scan_csdldf.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,gDAFU,MAAM,CAEsC;AAOtD;;;;;;;;;;GAUG;AACH,8CAFU,MAAM,CAE6E;AAmT7F;;;;;GAKG;AACH,wCAFU,aAAa,CAMpB;AAQH;;;;;GAKG;AACH,gDAFU,aAAa,CAkBpB;8BArX2B,kCAAkC"}

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.js

@@ -1,4 +1,7 @@
 import { WebGPUExtensionType } from "../../../../descriptor/WebGPUExtensionType.js";
+import {
+    WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION
+} from "../../indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
 import { atomic_u32, u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
@@ -32,9 +35,18 @@ const DATA_STRUCT = WebGPUStruct.from({
  */
 export const PREFIX_SCAN_CSDLDF_HEADER_WORDS = DATA_STRUCT.get("elements").offset / u32.size;
 
+/*
+ The input is bound read-only and the sums go to a buffer of their own, as in both references: a tile that does not see
+ its predecessor's flag within MAX_SPIN_COUNT re-reduces the predecessor's elements itself (the fallback), so those
+ elements must still be the inputs while any tile of the dispatch runs. Scanned in place, a predecessor that had already
+ written its sums handed the fallback a mix of inputs and sums, and the tiles after it carried the difference: on an
+ RTX 4090 one scan of 3,100 came back wrong (196,608 elements, tiles 5–12 all off by 33,721,938), and with
+ MAX_SPIN_COUNT at 1, 65 of 500.
+*/
 const resources = new ShaderResourceSetDescriptor();
 resources.createGroup()
-    .addStorageBuffer("scan_in", DATA_STRUCT, true)
+    .addStorageBuffer("scan_in", DATA_STRUCT)
+    .addStorageBuffer("scan_out", DATA_STRUCT, true)
     .addStorageBuffer("spine", WebGPUArray.from(WebGPUArray.from(atomic_u32, 2)), true)
 
 const body = CodeChunk.from(
@@ -93,7 +105,7 @@ fn main(
     @builtin(subgroup_invocation_id) lane_id: u32,
     @builtin(subgroup_size) lane_count: u32,
 ) {
-    
+
     let vec_size = divide_round_up_u32(scan_in.count, 4);
     let work_tiles = divide_round_up_u32(scan_in.count, ${PREFIX_SCAN_CSDLDF_PARTITION_SIZE});
 
@@ -306,7 +318,7 @@ fn main(
         let prev = wg_broadcast + select(0u, wg_partials[subgroup_id - 1u], subgroup_id != 0u); //wg_broadcast is 0 for tile_id 0
         if(tile_id < work_tiles - 1u){
             for(var k = 0u; k < VEC4_SPT; k += 1u){
-                scan_in.elements[i] = t_scan[k] + prev;
+                scan_out.elements[i] = t_scan[k] + prev;
                 i += lane_count;
             }
         }
@@ -314,7 +326,7 @@ fn main(
         if(tile_id == work_tiles - 1u){
             for(var k = 0u; k < VEC4_SPT; k += 1u){
                 if(i < vec_size){
-                    scan_in.elements[i] = t_scan[k] + prev;
+                    scan_out.elements[i] = t_scan[k] + prev;
                 }
                 i += lane_count;
             }
@@ -338,4 +350,34 @@ export const shader_prefix_scan_csdldf = ComputeShader.from({
     label: "Prefix Scan / CSDLDF",
     body,
     resources,
+});
+
+const prepare_resources = new ShaderResourceSetDescriptor();
+prepare_resources.createGroup()
+    .addStorageBuffer("scan_in", DATA_STRUCT)
+    .addStorageBuffer("scan_out", DATA_STRUCT, true)
+    .addStorageBuffer("command", WebGPUArray.u32, true);
+
+/**
+ * One thread ahead of {@link shader_prefix_scan_csdldf}: the scan's dispatch, a workgroup per partition of the input's
+ * count, and the output's count. The output gets its count here rather than from the scan's first tile because an input
+ * of no elements dispatches no tile at all.
+ * @type {ComputeShader}
+ */
+export const shader_prefix_scan_csdldf_prepare = ComputeShader.from({
+    label: "Prefix Scan / CSDLDF prepare",
+    resources: prepare_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(1)
+fn main() {
+    let count = scan_in.count;
+    scan_out.count = count;
+    // the scan reads its tile from workgroup_id.x alone; past one dimension's guaranteed width it is incomplete
+    command[0] = min(divide_round_up_u32(count, ${PREFIX_SCAN_CSDLDF_PARTITION_SIZE}u), ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u);
+    command[1] = 1u;
+    command[2] = 1u;
+}
+`, [chunk_divide_round_up_u32]),
 });

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/test_prefix_sum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test_prefix_sum.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/test_prefix_sum.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,0EA8DC"}
+{"version":3,"file":"test_prefix_sum.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/test_prefix_sum.js"],"names":[],"mappings":"AA4BA;;;GAGG;AACH,0EA+DC"}

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/test_prefix_sum.js

@@ -12,7 +12,8 @@ import { WGSLAttributes } from "../../../shader/type/WGSLAttributes.js";
 import { WGSLStructField } from "../../../shader/type/WGSLStructField.js";
 import { graph_inspect_gpu_buffer } from "../../../buffer/graph_inspect_gpu_buffer.js";
 import { graph_import_typed_buffer } from "../../../shader/graph/graph_import_typed_buffer.js";
-import { graph_prefix_scan_csdldf } from "./graph_prefix_scan_csdldf.js";
+import { graph_create_buffer } from "../../../shader/graph/graph_create_buffer.js";
+import { graph_prefix_scan_csdldf, prefix_scan_csdldf_output_descriptor } from "./graph_prefix_scan_csdldf.js";
 
 function cpu_prefix_sum(input) {
     const output = new Uint32Array(input.length);
@@ -57,7 +58,8 @@ export async function test_prefix_sum(graphics) {
 
     const prefix_sum = graph_prefix_scan_csdldf({
         graph,
-        data,
+        input: data,
+        output: graph_create_buffer(graph, "prefix sum", prefix_scan_csdldf_output_descriptor(input.length)),
         element_max_count: input.length,
     });
 

package/src/shade/renderer/gpu_primitive/sort/defs.d.ts

@@ -63,8 +63,8 @@ export const MAX_SUBGROUPS_PER_WORKGROUP: number;
  * Words of `{count: u32, elements: array<vec4u>}` header that sit in front of the spine's elements.
  *
  * {@link graph_prefix_scan_csdldf} reads its element count from word 0 and its `elements` member is
- * `@align(16)`, so the first count word lives at word 4. The histogram and scatter shaders bind the
- * same buffer flat and have to step over the header by hand.
+ * `@align(16)`, so the first count word lives at word 4. The histogram shader binds the spine flat and
+ * the scatter its scan, laid out the same, and both have to step over the header by hand.
  * @type {number}
  */
 export const SPINE_HEADER_WORDS: number;

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

@@ -1,79 +1,79 @@
-/**
- * Shared configuration for the key-value radix sort.
- *
- * The sort is LSD reduce-then-scan: four 8-bit digit passes, each of them a per-tile histogram,
- * a spine scan through {@link graph_prefix_scan_csdldf}, and a rank-and-scatter. The numbers below
- * are what the three stages have to agree on, so they live in one place rather than in each
- * shader's template literal.
- */
-
-/**
- * Number of digit bins. 8-bit digits — one `u32` key is covered by {@link RADIX_PASSES} of them.
- * @type {number}
- */
-export const RADIX = 256;
-
-/**
- * `log2(RADIX)` — also the number of binary split rounds the scatter's in-tile sort runs.
- * @type {number}
- */
-export const RADIX_LOG = 8;
-
-/**
- * (key width) / RADIX_LOG. Four passes over a 32-bit key.
- *
- * Even, which is what puts the result back in the caller's buffers rather than in the ping-pong
- * scratch — see {@link graph_radix_sort}.
- * @type {number}
- */
-export const RADIX_PASSES = 4;
-
-/**
- * Threads per workgroup, in both the histogram and the scatter.
- *
- * 256 is `maxComputeInvocationsPerWorkgroup`'s default value, and it is also exactly {@link RADIX},
- * which is what lets the scatter run "one thread per bin" over its local histogram with no strided
- * loop.
- * @type {number}
- */
-export const SORT_WORKGROUP_SIZE = 256;
-
-/**
- * Keys each thread carries through a tile.
- * @type {number}
- */
-export const SORT_KEYS_PER_THREAD = 4;
-
-/**
- * Keys one workgroup processes. Also the granularity of the spine: the spine holds one 256-bin
- * histogram per tile.
- * @type {number}
- */
-export const SORT_TILE_SIZE = SORT_WORKGROUP_SIZE * SORT_KEYS_PER_THREAD;
-
-/**
- * The smallest subgroup size WebGPU permits, and therefore the largest number of subgroups a
- * workgroup can be split into: `SORT_WORKGROUP_SIZE / MIN_SUBGROUP_SIZE`.
- *
- * Subgroup size is a runtime value in [4, 128]; nothing here may bake a width in. What the bound
- * buys is a *compile-time* trip count for the loop that scans the per-subgroup partials — a loop
- * that contains barriers, and whose bound therefore has to be provably uniform. Iterations past
- * the real subgroup count do nothing.
- * @type {number}
- */
-export const MIN_SUBGROUP_SIZE = 4;
-
-/**
- * @type {number}
- */
-export const MAX_SUBGROUPS_PER_WORKGROUP = SORT_WORKGROUP_SIZE / MIN_SUBGROUP_SIZE;
-
-/**
- * Words of `{count: u32, elements: array<vec4u>}` header that sit in front of the spine's elements.
- *
- * {@link graph_prefix_scan_csdldf} reads its element count from word 0 and its `elements` member is
- * `@align(16)`, so the first count word lives at word 4. The histogram and scatter shaders bind the
- * same buffer flat and have to step over the header by hand.
- * @type {number}
- */
-export const SPINE_HEADER_WORDS = 4;
+/**
+ * Shared configuration for the key-value radix sort.
+ *
+ * The sort is LSD reduce-then-scan: four 8-bit digit passes, each of them a per-tile histogram,
+ * a spine scan through {@link graph_prefix_scan_csdldf}, and a rank-and-scatter. The numbers below
+ * are what the three stages have to agree on, so they live in one place rather than in each
+ * shader's template literal.
+ */
+
+/**
+ * Number of digit bins. 8-bit digits — one `u32` key is covered by {@link RADIX_PASSES} of them.
+ * @type {number}
+ */
+export const RADIX = 256;
+
+/**
+ * `log2(RADIX)` — also the number of binary split rounds the scatter's in-tile sort runs.
+ * @type {number}
+ */
+export const RADIX_LOG = 8;
+
+/**
+ * (key width) / RADIX_LOG. Four passes over a 32-bit key.
+ *
+ * Even, which is what puts the result back in the caller's buffers rather than in the ping-pong
+ * scratch — see {@link graph_radix_sort}.
+ * @type {number}
+ */
+export const RADIX_PASSES = 4;
+
+/**
+ * Threads per workgroup, in both the histogram and the scatter.
+ *
+ * 256 is `maxComputeInvocationsPerWorkgroup`'s default value, and it is also exactly {@link RADIX},
+ * which is what lets the scatter run "one thread per bin" over its local histogram with no strided
+ * loop.
+ * @type {number}
+ */
+export const SORT_WORKGROUP_SIZE = 256;
+
+/**
+ * Keys each thread carries through a tile.
+ * @type {number}
+ */
+export const SORT_KEYS_PER_THREAD = 4;
+
+/**
+ * Keys one workgroup processes. Also the granularity of the spine: the spine holds one 256-bin
+ * histogram per tile.
+ * @type {number}
+ */
+export const SORT_TILE_SIZE = SORT_WORKGROUP_SIZE * SORT_KEYS_PER_THREAD;
+
+/**
+ * The smallest subgroup size WebGPU permits, and therefore the largest number of subgroups a
+ * workgroup can be split into: `SORT_WORKGROUP_SIZE / MIN_SUBGROUP_SIZE`.
+ *
+ * Subgroup size is a runtime value in [4, 128]; nothing here may bake a width in. What the bound
+ * buys is a *compile-time* trip count for the loop that scans the per-subgroup partials — a loop
+ * that contains barriers, and whose bound therefore has to be provably uniform. Iterations past
+ * the real subgroup count do nothing.
+ * @type {number}
+ */
+export const MIN_SUBGROUP_SIZE = 4;
+
+/**
+ * @type {number}
+ */
+export const MAX_SUBGROUPS_PER_WORKGROUP = SORT_WORKGROUP_SIZE / MIN_SUBGROUP_SIZE;
+
+/**
+ * Words of `{count: u32, elements: array<vec4u>}` header that sit in front of the spine's elements.
+ *
+ * {@link graph_prefix_scan_csdldf} reads its element count from word 0 and its `elements` member is
+ * `@align(16)`, so the first count word lives at word 4. The histogram shader binds the spine flat and
+ * the scatter its scan, laid out the same, and both have to step over the header by hand.
+ * @type {number}
+ */
+export const SPINE_HEADER_WORDS = 4;

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

@@ -13,7 +13,7 @@
  *      bin-major;
  *   2. {@link graph_prefix_scan_csdldf}, reused as-is — one running scan over the whole spine
  *      therefore yields the global start of every digit and the per-tile offset within it together.
- *      That scan is inclusive-only and in-place, so the scatter recovers the exclusive value by
+ *      That scan is inclusive-only, so the scatter recovers the exclusive value by
  *      subtracting the tile's own count (which it has, having re-derived the tile histogram to rank
  *      its keys anyway);
  *   3. {@link shader_radix_sort_scatter} — rank within the tile, then scatter.

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":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAN+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,aAAa,EAA7B,MAAM;IACJ;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":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAN+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,aAAa,EAA7B,MAAM;IACJ;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,CA+JxC"}

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

@@ -2,7 +2,8 @@ import { assert } from "../../../../core/assert.js";
 import { round_up } from "../../../../core/math/round_up.js";
 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 { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
+import { graph_prefix_scan_csdldf, prefix_scan_csdldf_output_descriptor } 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 { shader_radix_sort_histogram } from "./shader_radix_sort_histogram.js";
 import { shader_radix_sort_scatter } from "./shader_radix_sort_scatter.js";
@@ -22,7 +23,7 @@ import { shader_radix_sort_scatter } from "./shader_radix_sort_scatter.js";
  *      bin-major;
  *   2. {@link graph_prefix_scan_csdldf}, reused as-is — one running scan over the whole spine
  *      therefore yields the global start of every digit and the per-tile offset within it together.
- *      That scan is inclusive-only and in-place, so the scatter recovers the exclusive value by
+ *      That scan is inclusive-only, so the scatter recovers the exclusive value by
  *      subtracting the tile's own count (which it has, having re-derived the tile histogram to rank
  *      its keys anyway);
  *   3. {@link shader_radix_sort_scatter} — rank within the tile, then scatter.
@@ -71,6 +72,8 @@ export function graph_radix_sort({
         0, spine_size
     );
 
+    const SCANNED_SPINE_DESCRIPTOR = prefix_scan_csdldf_output_descriptor(spine_element_count);
+
     // aligned on a 1k boundary to lower memory fragmentation, as the deleted port did
     const PING_PONG_DESCRIPTOR = BufferResourceDescriptor.from(
         round_up(element_count * Uint32Array.BYTES_PER_ELEMENT, 1024),
@@ -163,7 +166,8 @@ export function graph_radix_sort({
 
         const scanned_spine = graph_prefix_scan_csdldf({
             graph,
-            data: histogram_data.spine,
+            input: histogram_data.spine,
+            output: graph_create_buffer(graph, `radix sort/scanned spine ${pass_index}`, SCANNED_SPINE_DESCRIPTOR),
             element_max_count: spine_element_count,
         });
 

package/src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_lightmap_denoise_sh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,2CAFU,SAAS,CAkCjB;AAyHF,qDAOE;0BAvLwB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"shader_lightmap_denoise_sh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,2CAFU,SAAS,CAyCjB;AAyHF,qDAOE;0BA9LwB,oCAAoC;4BAClC,6BAA6B"}

package/src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.js

@@ -39,8 +39,15 @@ fn estimate_sh_similarity(
     // extract dominant luma direction
     // Metro encodes SH coeffcients in axis-aligned way (L11, L1_1, L10) with L00 being in forth position (w)
     
-    let a_luma_direction = a.Y.xyz / a.Y.w;
-    let b_luma_direction = b.Y.xyz / b.Y.w;
+    // Zero DC is black and has no dominant direction.
+    var a_luma_direction = vec3<f32>(0.0);
+    var b_luma_direction = vec3<f32>(0.0);
+    if (a.Y.w != 0.0) {
+        a_luma_direction = a.Y.xyz / a.Y.w;
+    }
+    if (b.Y.w != 0.0) {
+        b_luma_direction = b.Y.xyz / b.Y.w;
+    }
 
     const DIRECTION_PHI = 10.0;
 
@@ -189,4 +196,4 @@ export const shader_lightmap_denoise_sh = ImageShader.from({
         resources,
     }),
     targets: LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR
-})
+})