@woosh/meep-engine 3.43.0 → 3.45.0

package/src/shade/renderer/geometry/virtual/build/level/vgeo_run_round.js

@@ -5,6 +5,7 @@ import { vgeo_build_group_step } from "./vgeo_build_group_step.js";
 import { vgeo_error_bands } from "./vgeo_error_bands.js";
 import { vgeo_partition_into_groups } from "./vgeo_partition_into_groups.js";
 import { vgeo_try_repack } from "./vgeo_try_repack.js";
+import { number_compare_ascending } from "../../../../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * The frontier's clusters ordered by error, which is what a band is a slice of.
@@ -65,7 +66,7 @@ export function vgeo_run_round(frontier, level, options) {
         for (const range of bands) {
             const band = ordered.order.slice(range.start, range.end);
 
-            band.sort((a, b) => a - b);
+            band.sort(number_compare_ascending);
 
             const groups = vgeo_partition_into_groups(frontier, band, cluster_graph, group_size);
 

package/src/shade/renderer/geometry/virtual/build/level/vgeo_try_repack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_try_repack.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_try_repack.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAPW,MAAM,EAAE,iBACR,MAAM,GACJ,eAAe,GAAC,SAAS,CAsFrC;gCA7G+B,sBAAsB"}
+{"version":3,"file":"vgeo_try_repack.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/level/vgeo_try_repack.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wEAPW,MAAM,EAAE,iBACR,MAAM,GACJ,eAAe,GAAC,SAAS,CAsFrC;gCA9G+B,sBAAsB"}

package/src/shade/renderer/geometry/virtual/build/level/vgeo_try_repack.js

@@ -6,6 +6,7 @@ import { vgeo_split_face_set_packed } from "../partition/vgeo_split_face_set_pac
 import { vgeo_extract_submesh } from "../submesh/vgeo_extract_submesh.js";
 import { vgeo_build_cluster } from "./vgeo_build_cluster.js";
 import { VGeoGroupRepack } from "./VGeoGroupRepack.js";
+import { number_compare_ascending } from "../../../../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * Leaves with room to spare between them, re-cut into fewer and fuller leaves.
@@ -53,7 +54,7 @@ export function vgeo_try_repack(frontier, group_clusters, parent_target) {
         return undefined;
     }
 
-    face_ids.sort((a, b) => a - b);
+    face_ids.sort(number_compare_ascending);
 
     const submesh = vgeo_extract_submesh(frontier.mesh, face_ids, frontier.wedges);
 
@@ -88,7 +89,7 @@ export function vgeo_try_repack(frontier, group_clusters, parent_target) {
     for (const part of parts) {
         const part_face_ids = part.map((dense) => face_graph.vertex_face_ids[dense]);
 
-        part_face_ids.sort((a, b) => a - b);
+        part_face_ids.sort(number_compare_ascending);
 
         const built = vgeo_build_cluster(submesh.mesh, part_face_ids, 0, submesh.wedges);
 

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_graph_components.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_graph_components.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_graph_components.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;GAWG;AACH,sDARW,WAAW,aACX,WAAW,WACX,MAAM,EAAE,cACR,UAAU,SAEV,MAAM,GACJ,MAAM,EAAE,EAAE,CAmEtB"}
+{"version":3,"file":"vgeo_graph_components.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_graph_components.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;GAWG;AACH,sDARW,WAAW,aACX,WAAW,WACX,MAAM,EAAE,cACR,UAAU,SAEV,MAAM,GACJ,MAAM,EAAE,EAAE,CAmEtB"}

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_graph_components.js

@@ -1,3 +1,4 @@
+import { number_compare_ascending } from "../../../../../../core/primitives/numbers/number_compare_ascending.js";
 /**
  * Connected components of the subgraph a CSR induces on a member set.
  *
@@ -112,7 +113,7 @@ export function vgeo_graph_components(
             }
         }
 
-        component.sort((a, b) => a - b);
+        component.sort(number_compare_ascending);
 
         result.push(component);
     }

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_split_face_set_packed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.js"],"names":[],"mappings":"AAmVA;;;;;;;;;;;;GAYG;AACH,+EALW,MAAM,EAAE,aACR,MAAM,gBACN,MAAM,GACJ,MAAM,EAAE,EAAE,CAoBtB"}
+{"version":3,"file":"vgeo_split_face_set_packed.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.js"],"names":[],"mappings":"AAoVA;;;;;;;;;;;;GAYG;AACH,+EALW,MAAM,EAAE,aACR,MAAM,gBACN,MAAM,GACJ,MAAM,EAAE,EAAE,CAoBtB"}

package/src/shade/renderer/geometry/virtual/build/partition/vgeo_split_face_set_packed.js

@@ -4,6 +4,7 @@ import {
     bt_face_read_triangle_vertices
 } from "../../../../../../core/geom/3d/topology/struct/binary/query/bt_face_read_triangle.js";
 import { vgeo_split_face_set } from "./vgeo_split_face_set.js";
+import { number_compare_ascending } from "../../../../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * {@link vgeo_split_face_set}, then merge the under-filled pieces it left behind.
@@ -331,7 +332,7 @@ function pack_pieces(face_graph, pieces, max_faces, max_vertices, floor) {
             }
         }
 
-        packed.sort((a, b) => a - b);
+        packed.sort(number_compare_ascending);
 
         return packed;
     });

package/src/shade/renderer/geometry/virtual/format/vgeo_write_container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_write_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_write_container.js"],"names":[],"mappings":"AAkfA;;;;;;;;GAQG;AACH,4CANW,qBAAqB,8BAGnB,QAAQ,YAAY,CAAC,CAmOjC;6BA1tB4B,4CAA4C"}
+{"version":3,"file":"vgeo_write_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_write_container.js"],"names":[],"mappings":"AAmfA;;;;;;;;GAQG;AACH,4CANW,qBAAqB,8BAGnB,QAAQ,YAAY,CAAC,CAmOjC;6BA3tB4B,4CAA4C"}

package/src/shade/renderer/geometry/virtual/format/vgeo_write_container.js

@@ -41,6 +41,7 @@ import { VGEO_PARENT_PAGE_ENTRY_SIZE } from "./page/VGEO_PARENT_PAGE_ENTRY_SIZE.
 import { VGEO_PAYLOAD_ENCODING_SHADE_MESHLET_V1 } from "./header/VGEO_PAYLOAD_ENCODING_SHADE_MESHLET_V1.js";
 import { VGEO_SAME_PAGE } from "./cluster/VGEO_SAME_PAGE.js";
 import { vgeo_scan_frames } from "./frame/vgeo_scan_frames.js";
+import { number_compare_ascending } from "../../../../../core/primitives/numbers/number_compare_ascending.js";
 
 /**
  * Serialize an assembled page list into `.vgeo` bytes.
@@ -182,7 +183,7 @@ function collect_parent_pages(page, parents) {
         }
     }
 
-    return Array.from(seen).sort((a, b) => a - b);
+    return Array.from(seen).sort(number_compare_ascending);
 }
 
 /**
@@ -206,7 +207,7 @@ function collect_child_pages(page) {
         }
     }
 
-    return Array.from(seen).sort((a, b) => a - b);
+    return Array.from(seen).sort(number_compare_ascending);
 }
 
 /**

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;