@woosh/meep-engine 3.43.0 → 3.44.0

package/src/shade/renderer/particles/coherence/graph_particle_bucket.js

@@ -1,194 +1,200 @@
-import { assert } from "../../../../core/assert.js";
-import { align_4 } from "../../../../core/binary/align_4.js";
-import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
-import { graph_compute_indirect_pass } from "../../shader/graph/compute/graph_compute_indirect_pass.js";
-import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
-import {
-    PREFIX_SCAN_CSDLDF_HEADER_WORDS,
-} from "../../gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.js";
-import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
-import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "../ParticleConstants.js";
-import {
-    shader_particle_bucket_fill,
-    shader_particle_bucket_histogram,
-    shader_particle_bucket_pad,
-    shader_particle_bucket_reset,
-    shader_particle_bucket_scatter,
-} from "./shader_particle_bucket.js";
-
-const WORD = Uint32Array.BYTES_PER_ELEMENT;
-
-/**
- * @typedef {{keys: number, histogram: 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
- * list into the program-coherent, workgroup-padded list NEXT frame's simulate consumes.
- *
- * Runs at the end of the frame, after emit and simulate have both finished appending to the alive
- * list and before the build-indirect pass, which reads the padded length this produces
- * ({@link PARTICLE_COUNTER.SIM_PADDED}) and turns it into next frame's dispatch args and bound.
- *
- * Six passes, the middle one being `graph_prefix_scan_csdldf` reused unchanged — the same scan the
- * engine's radix sort runs its spine through. Reusing it is deliberate: it is the one prefix scan
- * in this codebase whose only cross-workgroup wait is CSDLDF's own bounded-spin-then-fallback, so
- * the pass makes progress on a scheduler that offers no fairness guarantee. A hand-rolled scan here
- * would be a second place to get that wrong.
- *
- * Nothing on this path reads back to the CPU. The only host-supplied number is `bucket_count`, and
- * that is static topology — it changes when the emitter set does, never as particles are born and
- * die. The per-frame quantities (the alive count, the bin sizes, the padded total) are produced and
- * consumed entirely on the GPU, including the dispatch size of the two per-particle passes, which
- * the reset pass writes into `sim_dispatch_args` from the GPU's own alive count.
- *
- * ## The list is the feature's, the scratch is the graph's
- *
- * `sim_list` is the one thing here that crosses the frame boundary — this frame writes it, next
- * frame's simulate reads it — so the feature owns it and hands it in. Everything else (the keys,
- * the bins, the cursors, the dispatch args) is produced and consumed inside this call, so the pass
- * that first writes each one declares it with a {@link BufferResourceDescriptor} in place of a
- * handle, and the graph allocates and releases it around the passes that use it. `keys` is a word
- * per particle: at the renderer's default capacity, 2 MiB the feature no longer reserves.
- *
- * 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.
- *
- * @param {object} params
- * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {number} params.emitter_database graph handle of the emitter database buffer
- * @param {number} params.pool graph handle of the particle pool
- * @param {number} params.alive graph handle of this frame's compacted alive list
- * @param {number} params.counters graph handle of the atomic counters
- * @param {number} params.sim_list graph handle of the list this rewrites. Passed in rather than
- *   imported here because the simulate pass reads it earlier in the same frame: importing the same
- *   GPUBuffer twice makes two resource entries the graph cannot see are the same memory, so the read
- *   and the write end up on separate dependency chains
- * @param {number} params.capacity pool capacity in particles — the length of the key list
- * @param {number} params.bucket_count number of distinct compiled programs
- * @param {ParticleBucketScratch} [params.scratch] latest handles when bucketing again in this graph
- * @returns {{counters: number, sim_list: number, dispatch_args: number, scratch: ParticleBucketScratch}} the threaded handles downstream passes must read
- */
-export function graph_particle_bucket({ graph, emitter_database, pool, alive, counters, sim_list, capacity, bucket_count, scratch }) {
-    assert.defined(graph, "graph");
-    assert.isPositiveInteger(capacity, "capacity");
-    assert.isPositiveInteger(bucket_count, "bucket_count");
-    assert.isNonNegativeInteger(sim_list, "sim_list");
-
-    // Sized from the bucket count, which only changes when the emitter set does. Aligned up because
-    // the scan reads whole `vec4`s, so the last bin's tail is part of the buffer.
-    const bin_words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(bucket_count);
-
-    // Every buffer a pass WRITES must be THREADED: the write returns a renamed (versioned) handle
-    // and the next pass must read THAT one. Reading the original handle instead leaves the ordering
-    // between the two passes unexpressed — the graph's own validator rejects it, because both
-    // versions name one piece of memory and the stale-looking read silently returns the new
-    // contents.
-    // An edit frame buckets twice. The second run is handed the first's handles, so the transients
-    // are created once and both runs share one dependency chain.
-    let keys = scratch?.keys ?? BufferResourceDescriptor.from(capacity * WORD, GPUBufferUsage.STORAGE);
-    let histogram = scratch?.histogram ?? BufferResourceDescriptor.from(bin_words * WORD, GPUBufferUsage.STORAGE);
-    let cursor = scratch?.cursor ?? BufferResourceDescriptor.from(bucket_count * WORD, GPUBufferUsage.STORAGE);
-    let bucket_counts = scratch?.bucket_counts ?? BufferResourceDescriptor.from(bucket_count * WORD, GPUBufferUsage.STORAGE);
-    // Indirect args this pass writes and the two per-particle passes below consume, along with the
-    // bounds pass — hence INDIRECT on top of STORAGE.
-    let dispatch_args = scratch?.dispatch_args ?? BufferResourceDescriptor.from(
-        3 * WORD,
-        GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
-    );
-
-    // 0. Clear the bins and cursors, write the scan's {count} header, and size the two per-particle
-    //    passes below from the GPU's own alive count.
-    {
-        const out = graph_compute_pass({
-            graph,
-            shader: shader_particle_bucket_reset,
-            bindings: { counters, histogram, cursor, sim_dispatch_args: dispatch_args, u_bucket_count: bucket_count },
-            group_count: [reset_group_count(bucket_count), 1, 1],
-        });
-        counters = out.counters;
-        histogram = out.histogram;
-        cursor = out.cursor;
-        dispatch_args = out.sim_dispatch_args;
-    }
-
-    // 1. One bin per PROGRAM. Indirect, because the thread count is the alive count.
-    {
-        const out = graph_compute_indirect_pass({
-            graph,
-            shader: shader_particle_bucket_histogram,
-            bindings: { emitter_database, pool, alive, keys, histogram, counters },
-            command: dispatch_args,
-        });
-        keys = out.keys;
-        histogram = out.histogram;
-        counters = out.counters;
-    }
-
-    // 2. Round every bin up to a whole workgroup BEFORE the scan — that is what puts each bucket
-    //    boundary on a wave boundary rather than in the middle of one.
-    {
-        const out = graph_compute_pass({
-            graph,
-            shader: shader_particle_bucket_pad,
-            bindings: { histogram, bucket_counts, u_bucket_count: bucket_count },
-            group_count: [Math.ceil(bucket_count / PARTICLE_SIMULATE_WORKGROUP_SIZE), 1, 1],
-        });
-        histogram = out.histogram;
-        bucket_counts = out.bucket_counts;
-    }
-
-    // 3. Inclusive prefix sums of the padded bins, in place.
-    const scanned = graph_prefix_scan_csdldf({
-        graph,
-        data: histogram,
-        element_max_count: bucket_count,
-    });
-
-    // 4. Place each alive entry at its bucket's offset plus an atomic rank.
-    {
-        const out = graph_compute_indirect_pass({
-            graph,
-            shader: shader_particle_bucket_scatter,
-            bindings: { keys, alive, scanned, cursor, sim_list, counters },
-            command: dispatch_args,
-        });
-        cursor = out.cursor;
-        sim_list = out.sim_list;
-        counters = out.counters;
-    }
-
-    // 5. Stamp the padding sentinel into each bucket's tail and publish the padded total. One
-    //    workgroup per bucket: padding is at most a workgroup less one entry, and a bucket whose
-    //    particles all died has no scatter thread to ride along with.
-    {
-        const out = graph_compute_pass({
-            graph,
-            shader: shader_particle_bucket_fill,
-            bindings: { bucket_counts, scanned, sim_list, counters, u_bucket_count: bucket_count },
-            group_count: [bucket_count, 1, 1],
-        });
-        sim_list = out.sim_list;
-        counters = out.counters;
-    }
-
-    // `dispatch_args` goes back too: it holds one workgroup per live particle, written from the
-    // GPU's own alive count, which is the shape every per-particle pass after this one needs.
-    return { counters, sim_list, dispatch_args, scratch: { keys, histogram: scanned, cursor, bucket_counts, dispatch_args } };
-}
-
-/**
- * Workgroups the reset pass needs to cover its widest loop — the scan header plus the bins, rounded
- * up to the whole `vec4` the last bin lands in (the scan reads whole `vec4`s, so the tail has to be
- * cleared too or garbage joins the sums).
- *
- * @param {number} bucket_count
- * @returns {number}
- */
-function reset_group_count(bucket_count) {
-    const words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(bucket_count);
-
-    return Math.ceil(words / PARTICLE_SIMULATE_WORKGROUP_SIZE);
-}
+import { assert } from "../../../../core/assert.js";
+import { align_4 } from "../../../../core/binary/align_4.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
+import { graph_compute_indirect_pass } from "../../shader/graph/compute/graph_compute_indirect_pass.js";
+import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
+import {
+    PREFIX_SCAN_CSDLDF_HEADER_WORDS,
+} from "../../gpu_primitive/prefix_sum/v1/shader_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 { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
+import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "../ParticleConstants.js";
+import {
+    shader_particle_bucket_fill,
+    shader_particle_bucket_histogram,
+    shader_particle_bucket_pad,
+    shader_particle_bucket_reset,
+    shader_particle_bucket_scatter,
+} from "./shader_particle_bucket.js";
+
+const WORD = Uint32Array.BYTES_PER_ELEMENT;
+
+/**
+ * @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
+ * list into the program-coherent, workgroup-padded list NEXT frame's simulate consumes.
+ *
+ * Runs at the end of the frame, after emit and simulate have both finished appending to the alive
+ * list and before the build-indirect pass, which reads the padded length this produces
+ * ({@link PARTICLE_COUNTER.SIM_PADDED}) and turns it into next frame's dispatch args and bound.
+ *
+ * Six passes, the middle one being `graph_prefix_scan_csdldf` reused unchanged — the same scan the
+ * engine's radix sort runs its spine through. Reusing it is deliberate: it is the one prefix scan
+ * in this codebase whose only cross-workgroup wait is CSDLDF's own bounded-spin-then-fallback, so
+ * the pass makes progress on a scheduler that offers no fairness guarantee. A hand-rolled scan here
+ * would be a second place to get that wrong.
+ *
+ * Nothing on this path reads back to the CPU. The only host-supplied number is `bucket_count`, and
+ * that is static topology — it changes when the emitter set does, never as particles are born and
+ * die. The per-frame quantities (the alive count, the bin sizes, the padded total) are produced and
+ * consumed entirely on the GPU, including the dispatch size of the two per-particle passes, which
+ * the reset pass writes into `sim_dispatch_args` from the GPU's own alive count.
+ *
+ * ## The list is the feature's, the scratch is the graph's
+ *
+ * `sim_list` is the one thing here that crosses the frame boundary — this frame writes it, next
+ * frame's simulate reads it — so the feature owns it and hands it in. Everything else (the keys,
+ * the bins, the cursors, the dispatch args) is produced and consumed inside this call, so the pass
+ * that first writes each one declares it with a {@link BufferResourceDescriptor} in place of a
+ * handle, and the graph allocates and releases it around the passes that use it. `keys` is a word
+ * per particle: at the renderer's default capacity, 2 MiB the feature no longer reserves.
+ *
+ * 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, `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
+ * @param {number} params.emitter_database graph handle of the emitter database buffer
+ * @param {number} params.pool graph handle of the particle pool
+ * @param {number} params.alive graph handle of this frame's compacted alive list
+ * @param {number} params.counters graph handle of the atomic counters
+ * @param {number} params.sim_list graph handle of the list this rewrites. Passed in rather than
+ *   imported here because the simulate pass reads it earlier in the same frame: importing the same
+ *   GPUBuffer twice makes two resource entries the graph cannot see are the same memory, so the read
+ *   and the write end up on separate dependency chains
+ * @param {number} params.capacity pool capacity in particles — the length of the key list
+ * @param {number} params.bucket_count number of distinct compiled programs
+ * @param {ParticleBucketScratch} [params.scratch] latest handles when bucketing again in this graph
+ * @returns {{counters: number, sim_list: number, dispatch_args: number, scratch: ParticleBucketScratch}} the threaded handles downstream passes must read
+ */
+export function graph_particle_bucket({ graph, emitter_database, pool, alive, counters, sim_list, capacity, bucket_count, scratch }) {
+    assert.defined(graph, "graph");
+    assert.isPositiveInteger(capacity, "capacity");
+    assert.isPositiveInteger(bucket_count, "bucket_count");
+    assert.isNonNegativeInteger(sim_list, "sim_list");
+
+    // Sized from the bucket count, which only changes when the emitter set does. Aligned up because
+    // the scan reads whole `vec4`s, so the last bin's tail is part of the buffer.
+    const bin_words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(bucket_count);
+
+    // Every buffer a pass WRITES must be THREADED: the write returns a renamed (versioned) handle
+    // and the next pass must read THAT one. Reading the original handle instead leaves the ordering
+    // between the two passes unexpressed — the graph's own validator rejects it, because both
+    // versions name one piece of memory and the stale-looking read silently returns the new
+    // contents.
+    // An edit frame buckets twice. The second run is handed the first's handles, so the transients
+    // are created once and both runs share one dependency chain.
+    let keys = scratch?.keys ?? BufferResourceDescriptor.from(capacity * WORD, GPUBufferUsage.STORAGE);
+    let histogram = scratch?.histogram ?? BufferResourceDescriptor.from(bin_words * WORD, GPUBufferUsage.STORAGE);
+    let scanned = scratch?.scanned ?? graph_create_buffer(graph, "particles/bucket offsets", prefix_scan_csdldf_output_descriptor(bucket_count));
+    let cursor = scratch?.cursor ?? BufferResourceDescriptor.from(bucket_count * WORD, GPUBufferUsage.STORAGE);
+    let bucket_counts = scratch?.bucket_counts ?? BufferResourceDescriptor.from(bucket_count * WORD, GPUBufferUsage.STORAGE);
+    // Indirect args this pass writes and the two per-particle passes below consume, along with the
+    // bounds pass — hence INDIRECT on top of STORAGE.
+    let dispatch_args = scratch?.dispatch_args ?? BufferResourceDescriptor.from(
+        3 * WORD,
+        GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
+    );
+
+    // 0. Clear the bins and cursors, write the scan's {count} header, and size the two per-particle
+    //    passes below from the GPU's own alive count.
+    {
+        const out = graph_compute_pass({
+            graph,
+            shader: shader_particle_bucket_reset,
+            bindings: { counters, histogram, cursor, sim_dispatch_args: dispatch_args, u_bucket_count: bucket_count },
+            group_count: [reset_group_count(bucket_count), 1, 1],
+        });
+        counters = out.counters;
+        histogram = out.histogram;
+        cursor = out.cursor;
+        dispatch_args = out.sim_dispatch_args;
+    }
+
+    // 1. One bin per PROGRAM. Indirect, because the thread count is the alive count.
+    {
+        const out = graph_compute_indirect_pass({
+            graph,
+            shader: shader_particle_bucket_histogram,
+            bindings: { emitter_database, pool, alive, keys, histogram, counters },
+            command: dispatch_args,
+        });
+        keys = out.keys;
+        histogram = out.histogram;
+        counters = out.counters;
+    }
+
+    // 2. Round every bin up to a whole workgroup BEFORE the scan — that is what puts each bucket
+    //    boundary on a wave boundary rather than in the middle of one.
+    {
+        const out = graph_compute_pass({
+            graph,
+            shader: shader_particle_bucket_pad,
+            bindings: { histogram, bucket_counts, u_bucket_count: bucket_count },
+            group_count: [Math.ceil(bucket_count / PARTICLE_SIMULATE_WORKGROUP_SIZE), 1, 1],
+        });
+        histogram = out.histogram;
+        bucket_counts = out.bucket_counts;
+    }
+
+    // 3. Inclusive prefix sums of the padded bins.
+    scanned = graph_prefix_scan_csdldf({
+        graph,
+        input: histogram,
+        output: scanned,
+        element_max_count: bucket_count,
+    });
+
+    // 4. Place each alive entry at its bucket's offset plus an atomic rank.
+    {
+        const out = graph_compute_indirect_pass({
+            graph,
+            shader: shader_particle_bucket_scatter,
+            bindings: { keys, alive, scanned, cursor, sim_list, counters },
+            command: dispatch_args,
+        });
+        cursor = out.cursor;
+        sim_list = out.sim_list;
+        counters = out.counters;
+    }
+
+    // 5. Stamp the padding sentinel into each bucket's tail and publish the padded total. One
+    //    workgroup per bucket: padding is at most a workgroup less one entry, and a bucket whose
+    //    particles all died has no scatter thread to ride along with.
+    {
+        const out = graph_compute_pass({
+            graph,
+            shader: shader_particle_bucket_fill,
+            bindings: { bucket_counts, scanned, sim_list, counters, u_bucket_count: bucket_count },
+            group_count: [bucket_count, 1, 1],
+        });
+        sim_list = out.sim_list;
+        counters = out.counters;
+    }
+
+    // `dispatch_args` goes back too: it holds one workgroup per live particle, written from the
+    // GPU's own alive count, which is the shape every per-particle pass after this one needs.
+    return { counters, sim_list, dispatch_args, scratch: { keys, histogram, scanned, cursor, bucket_counts, dispatch_args } };
+}
+
+/**
+ * Workgroups the reset pass needs to cover its widest loop — the scan header plus the bins, rounded
+ * up to the whole `vec4` the last bin lands in (the scan reads whole `vec4`s, so the tail has to be
+ * cleared too or garbage joins the sums).
+ *
+ * @param {number} bucket_count
+ * @returns {number}
+ */
+function reset_group_count(bucket_count) {
+    const words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(bucket_count);
+
+    return Math.ceil(words / PARTICLE_SIMULATE_WORKGROUP_SIZE);
+}

package/src/shade/renderer/particles/graph_particles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IA/BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IAGS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CAgUrC;;;;;UAxWa,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;;sBACN,MAAM"}
+{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IA/BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IAGS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CAiUrC;;;;;UAzWa,MAAM;;;;WACN,MAAM;;;;eACN,MAAM;;;;;sBACN,MAAM"}

package/src/shade/renderer/particles/graph_particles.js

@@ -2,7 +2,10 @@ import { assert } from "../../../core/assert.js";
 import { align_4 } from "../../../core/binary/align_4.js";
 import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
 import { 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 { PREFIX_SCAN_CSDLDF_HEADER_WORDS } from "../gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.js";
 import { shader_prefix_sum_to_command } from "../rasterize/expand/mesh/shader_prefix_sum_to_command.js";
 import { graph_particle_bounds } from "./bounds/graph_particle_bounds.js";
@@ -287,7 +290,8 @@ export function graph_particles_simulate({
     //    the number of particles born this frame.
     const spawn_prefix = graph_prefix_scan_csdldf({
         graph,
-        data: spawn_counts,
+        input: spawn_counts,
+        output: graph_create_buffer(graph, "particles/spawn_prefix", prefix_scan_csdldf_output_descriptor(Math.max(1, emitters.capacity))),
         element_max_count: Math.max(1, emitters.capacity),
     });
 

package/src/shade/renderer/particles/warmup/graph_particle_warmup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particle_warmup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/graph_particle_warmup.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH;IAtBqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,cAAc,EAA7B,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,OAAO,EAAtB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,SAAS,EAAxB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEY,KAAK;IACR,WAAW,EAA1B,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACgD,QAAQ,EAA9D,OAAO,sBAAsB,EAAE,cAAc;IAC7B,cAAc,EAA9B,OAAO;IACQ,KAAK;QACC,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;;IACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAqO7H"}
+{"version":3,"file":"graph_particle_warmup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/graph_particle_warmup.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH;IAtBqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,cAAc,EAA7B,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,OAAO,EAAtB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,SAAS,EAAxB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEY,KAAK;IACR,WAAW,EAA1B,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACgD,QAAQ,EAA9D,OAAO,sBAAsB,EAAE,cAAc;IAC7B,cAAc,EAA9B,OAAO;IACQ,KAAK;QACC,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;;IACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAuO7H"}