@woosh/meep-engine 3.43.0 → 3.45.0

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/particles/GPUParticleSystem.js

@@ -56,7 +56,7 @@ const STORAGE_GROWABLE = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUB
  */
 const INDIRECT = GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_SRC;
 
-const DEFAULT_CAPACITY = 524288;
+const DEFAULT_CAPACITY = 131072;
 
 /**
  * What {@link GPUParticleSystem#read_stats} decodes: the counts the GPU keeps between frames, named.

package/src/shade/renderer/particles/coherence/graph_particle_bucket.d.ts

@@ -1,5 +1,5 @@
 /**
- * @typedef {{keys: number, histogram: number, cursor: number, bucket_counts: number, dispatch_args: number}} ParticleBucketScratch
+ * @typedef {{keys: number, histogram: number, scanned: number, cursor: number, bucket_counts: number, dispatch_args: number}} ParticleBucketScratch
  */
 /**
  * Frame-graph wiring for the simulation-order bucketing: turns the frame's freshly compacted alive
@@ -32,8 +32,8 @@
  *
  * None of them asks for a clear. The reset pass covers the histogram (header, padding and the bins
  * up to the whole `vec4` the last one lands in), the cursors and all three dispatch words; `keys`
- * is written by the same indirect dispatch that later reads it, and `bucket_counts` by the same
- * `bucket_count` threads.
+ * is written by the same indirect dispatch that later reads it, `bucket_counts` by the same
+ * `bucket_count` threads, and the scanned bins, header included, by the scan.
  *
  * @param {object} params
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
@@ -69,6 +69,7 @@ export function graph_particle_bucket({ graph, emitter_database, pool, alive, co
 export type ParticleBucketScratch = {
     keys: number;
     histogram: number;
+    scanned: number;
     cursor: number;
     bucket_counts: number;
     dispatch_args: number;

package/src/shade/renderer/particles/coherence/graph_particle_bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particle_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/coherence/graph_particle_bucket.js"],"names":[],"mappings":"AAoBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAdqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,gBAAgB,EAA/B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,QAAQ,EAAvB,MAAM;IAIS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IACyB,OAAO,GAAtC,qBAAqB;IACnB;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,qBAAqB,CAAA;CAAC,CA4GvG;oCA9JY;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC"}
+{"version":3,"file":"graph_particle_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/coherence/graph_particle_bucket.js"],"names":[],"mappings":"AAwBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAdqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,gBAAgB,EAA/B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,QAAQ,EAAvB,MAAM;IAIS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IACyB,OAAO,GAAtC,qBAAqB;IACnB;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,qBAAqB,CAAA;CAAC,CA8GvG;oCAhKY;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC"}