@woosh/meep-engine 3.42.0 → 3.44.0

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#264@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#265@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/particles/DESIGN.md

@@ -791,14 +791,18 @@ it is evaluated per pixel (`chunk_particle_lighting`, the model in `chunk_partic
 a vertex need not be on screen, and one quad can span the frustum.
 
 - **Direct light comes from the froxel irradiance volume** (`volumetrics/chunk_volumetrics_irradiance_sh`),
-  which `shader_volumetrics_build_lighting` writes in the loop that lights the fog: every
-  directional, point and spot light at the froxel, shadowed, attenuated by the fog toward it, stored
-  as luma SH2 + constant chroma (Metro's L1 YCoCg, 6 coefficients in two `rgba16float` volumes, since
-  `rg16float` is not a storage format without `texture-formats-tier1`). The volume rides the
-  orchestrator to side channels as `volumetrics_irradiance`. Resolution is the fog's — 16 px tiles
-  and 64 slices — so light and shadow edges inside a particle are soft. idTech 8 builds the same
-  volume in the same pass (Sousa, SIGGRAPH 2025, p.29); Ghost of Tsushima lights particles from its
-  haze grid the same way. Chosen over per-pixel forward shading (UE's most expensive mode, and a
+  which `shader_volumetrics_build_irradiance` writes: every directional, point and spot light at a
+  point jittered through the froxel every frame, shadowed, stored as luma SH2 + constant chroma (Metro's L1 YCoCg, 6 coefficients
+  in two `rgba16float` volumes, since `rg16float` is not a storage format without
+  `texture-formats-tier1`). The volume rides the orchestrator to side channels as
+  `volumetrics_irradiance`. Resolution is the fog's froxel grid — 16 px tiles and 64 slices — so light
+  and shadow edges inside a particle are soft. idTech 8 builds the same volume (Sousa, SIGGRAPH 2025,
+  p.29); Ghost of Tsushima lights particles from its haze grid the same way. idTech 8 builds it in the
+  pass that lights its fog, and this one did too until 2026-10-09, dimming each light by the medium
+  on its way in. That tied particle lighting to the fog's whole chain (media, sun cascades, sky LUTs),
+  so the fog could not be skipped in a scene without volumes. It now has its own pass with no medium
+  in it: a lit particle is lit as the surfaces beside it are, which the deferred and forward paths
+  never dimmed either, and the fog is composited over both. Chosen over per-pixel forward shading (UE's most expensive mode, and a
   flat card lit that way goes black from behind), per-vertex/per-particle lighting (the light
   clusters are screen-space: a point off screen has no light list, the artefact that moved idTech 8
   off it) and a per-particle lighting atlas (DOOM 2016, CoD IW: best-looking, but it needs a
@@ -814,7 +818,7 @@ a vertex need not be on screen, and one quad can span the frustum.
 - **Indirect light is in the same volume**, whatever the renderer's `indirect_lighting_mode`. The
   froxel GI stage (`volumetrics/gi/`) starts the volume with one concrete module per mode — IBL,
   Brick4, LPV — each asking its source what radiance arrives at the froxel's centre, as RGB SH2,
-  and `shader_volumetrics_build_lighting` adds the lights to that. The particle knows no mode: a new
+  and `shader_volumetrics_build_irradiance` adds the lights to that. The particle knows no mode: a new
   GI system is one more module. IBL's source is `GPULightCollection.environment_sh`, the
   environment projected to radiance SH2 when it changes (`shader_project_environment_sh`); Brick4
   interpolates its probes (SH3, truncated) with a zero normal, which weighs every probe of the

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"}

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/shaders/chunk_particle_lighting.d.ts

@@ -4,7 +4,7 @@
  * returns what it reflects and transmits (`chunk_particle_lighting_model`), from the froxel
  * irradiance volume (`chunk_volumetrics_irradiance_sh`) at the fragment: the renderer's indirect
  * lighting, whichever mode it runs (the froxel GI stage, `volumetrics/gi/`), plus every directional,
- * point and spot light, shadowed, and attenuated by the fog on its way in. One trilinear read of each
+ * point and spot light, shadowed, as the surfaces around the particle receive them. One trilinear read of each
  * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
  * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
  * soft.

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.js

@@ -10,7 +10,7 @@ import { chunk_particle_lighting_model } from "./chunk_particle_lighting_model.j
  * returns what it reflects and transmits (`chunk_particle_lighting_model`), from the froxel
  * irradiance volume (`chunk_volumetrics_irradiance_sh`) at the fragment: the renderer's indirect
  * lighting, whichever mode it runs (the froxel GI stage, `volumetrics/gi/`), plus every directional,
- * point and spot light, shadowed, and attenuated by the fog on its way in. One trilinear read of each
+ * point and spot light, shadowed, as the surfaces around the particle receive them. One trilinear read of each
  * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
  * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
  * soft.

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"}