@woosh/meep-engine 3.17.1 → 3.18.0

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

@@ -1,216 +1,213 @@
-import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
-import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
-import {
-    chunk_sphere_intersects_frustum
-} from "../../shader/chunk/geometry/sphere/chunk_sphere_intersects_frustum.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { PARTICLE_EMITTER_TICK_WORKGROUP_SIZE } from "../ParticleConstants.js";
-import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
-import { PARTICLE_EMITTER_DESCRIPTOR, PARTICLE_EMITTER_STATE_DESCRIPTOR } from "../data/PARTICLE_DATABASE_SPEC.js";
-import { EMITTER_FLAG } from "../data/PARTICLE_EMITTER_STRUCT.js";
-import { chunk_particle_emitter_world_sphere } from "./chunk_particle_emitter_world_sphere.js";
-
-/**
- * The emitter tick: one thread per emitter table row, deciding how many particles each emitter
- * spawns this frame. This is the pass that took spawning off the CPU — the host no longer walks the
- * emitters, and no longer knows or cares how many there are.
- *
- * Per live row it:
- *
- * 1. picks up the row's GPU-owned state (the `emitter_state` table, see
- *    {@link ../data/PARTICLE_EMITTER_STATE.js}) — or starts it over, when the state's generation is
- *    not the record's, which is how both a brand-new row and a reused one are recognised without
- *    the CPU clearing anything;
- * 2. takes whatever the spawn-command pass queued into `pending` (the CPU's bursts, and in time
- *    whatever a VM opcode asks for) into the accumulator;
- * 3. if the emitter opts into culling, tests its bounds sphere — in world space, through its scene
- *    node's `global` — against the camera frustum; a culled emitter sleeps, accruing time it pays
- *    back as a bounded burst when it is next seen;
- * 4. integrates `spawn_rate * dt`, and turns the whole part of the accumulator into this frame's
- *    count — clamped by the frame's spawn budget, which the reset pass seeded from the dead count,
- *    so an emitter is only ever debited for particles the pool can hold;
- * 5. writes that count to `spawn_counts.elements[row]`.
- *
- * `spawn_counts` is the input of a prefix scan, and the scan's inclusive sums are what the emit
- * pass expands: one thread per particle, each locating its emitter by binary search over the sums.
- * That is the same shape the rasteriser uses to expand meshes into meshlets, and it is what makes
- * the per-emitter count unbounded — no thread here loops over its particles.
- *
- * The rows are walked with the emitter table's page iterator, one page group per workgroup, so an
- * unallocated page costs one word read and a freed row costs one bit test. The state rows live in
- * the same database buffer, bound once and read-write, and are read and written whole: each row is
- * one thread's, so nothing here needs an atomic. Rows the walk skips leave their count at zero,
- * which is why the counts buffer is cleared before this runs. The scan's `count` header is written
- * by the first thread, from the table's element capacity, which is the only number the host
- * supplies.
- *
- * @type {ComputeShader}
- */
-
-const GROUP_SIZE = PARTICLE_EMITTER_TICK_WORKGROUP_SIZE;
-
-// The database is bound read-write (the state rows are written), so the iterator and the readers
-// are the `_rw` variants: WGSL does not coerce access modes at a call site.
-const PG = PARTICLE_EMITTER_DESCRIPTOR.page_iterator_symbol_prefix(GROUP_SIZE, true);
-const STATE = PARTICLE_EMITTER_STATE_DESCRIPTOR;
-
-/**
- * Per-dispatch, 16 bytes, read-only.
- *
- * @type {WebGPUStruct}
- */
-const TICK_SETTINGS = WebGPUStruct.from({
-    /** seconds */
-    u_dt: f32,
-    /** cap on how much missed time a wake-up burst covers, seconds */
-    u_max_catchup: f32,
-    /** pool capacity — the ceiling on the accumulator, and the wrap guard for the budget counter */
-    u_capacity: u32,
-    /** element capacity of the emitter table — the length of the counts list the scan consumes */
-    u_emitter_capacity: u32,
-}, 'ParticleEmitterTickSettings');
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate('settings', TICK_SETTINGS);
-
-resources.createGroup()
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addStorageBuffer("scene_database", WebGPUArray.u32, false)
-    .addStorageBuffer("emitter_database", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer("spawn_counts", COLLECTION_U32_STRUCT_READ, true);
-
-const body = CodeChunk.from(/* language=wgsl */ `
-const COUNTER_SPAWN_BUDGET : u32 = ${PARTICLE_COUNTER.SPAWN_BUDGET}u;
-const EMITTER_FLAG_CULL : u32 = ${EMITTER_FLAG.CULL}u;
-
-// Take up to \`wanted\` from the frame's spawn budget; returns what was actually granted.
-//
-// Many rows race this counter. A thread that drives it below zero sees an old value smaller than
-// its request and keeps only that much; a thread that reads while another's over-subtraction is
-// still un-undone sees a wrapped (huge) value and keeps nothing. Each adds back exactly what it did
-// not keep, so the counter converges to zero rather than to garbage — the same shape as the dead
-// list pop in the emit pass.
-fn particle_take_spawn_budget(wanted : u32, capacity : u32) -> u32 {
-    let old = atomicSub(&counters[COUNTER_SPAWN_BUDGET], wanted);
-
-    var granted = wanted;
-    if (old > capacity) {
-        granted = 0u;
-    } else if (old < wanted) {
-        granted = old;
-    }
-
-    if (granted != wanted) {
-        atomicAdd(&counters[COUNTER_SPAWN_BUDGET], wanted - granted);
-    }
-
-    return granted;
-}
-
-@compute @workgroup_size(${GROUP_SIZE}, 1, 1)
-fn main(
-    @builtin(workgroup_id) wg_id : vec3<u32>,
-    @builtin(local_invocation_index) local_id : u32,
-) {
-    // The scan reads exactly this many counts. Written before the page test so it lands even when
-    // page 0 is unallocated — an empty table still has to scan to a total of zero.
-    if (wg_id.x == 0u && local_id == 0u) {
-        spawn_counts.count = settings.u_emitter_capacity;
-    }
-
-    // page_address is uniform across the workgroup, so this branch is uniform.
-    if (!${PG}_setup(&emitter_database, wg_id.x, local_id)) {
-        return;
-    }
-
-    let slot_in_page = ${PG}_slot_in_page(local_id);
-
-    if (slot_in_page >= ${PG}_ELEMENTS_PER_PAGE || !${PG}_is_occupied(slot_in_page)) {
-        return;
-    }
-
-    let em = ${PG}_read(&emitter_database, slot_in_page);
-    let row = ${PG}_slot_to_index(slot_in_page);
-
-    var state = ${STATE.marshalling_method_read_rw}(&emitter_database, row);
-
-    // Whatever the spawn-command pass queued since last tick. Taken before the generation test so a
-    // burst issued on the frame a row was (re)assigned is not lost with the stale state.
-    let pending = state.pending;
-    state.pending = 0u;
-
-    if (state.generation != em.generation) {
-        // A row this state has not seen: new emitter, or a reused row. Start from nothing.
-        state.generation = em.generation;
-        state.accumulator = 0.0;
-        state.age = 0.0;
-        state.sleep = 0.0;
-    }
-
-    var accumulator = state.accumulator + f32(pending);
-    var sleep = state.sleep;
-
-    state.age = state.age + settings.u_dt;
-
-    var visible = true;
-
-    if ((em.flags & EMITTER_FLAG_CULL) != 0u) {
-        let node = scene_read_node(&scene_database, em.node);
-        visible = sphere_intersects_frustum(particle_emitter_world_sphere(em, node.global), camera.frustum);
-    }
-
-    var count = 0u;
-
-    if (visible) {
-        // Waking up: a bounded catch-up for the time spent culled, so a long occlusion cannot
-        // spike the pool on the frame the emitter comes back into view.
-        if (sleep > 0.0) {
-            accumulator = accumulator + em.spawn_rate * min(sleep, settings.u_max_catchup);
-            sleep = 0.0;
-        }
-
-        accumulator = accumulator + em.spawn_rate * settings.u_dt;
-
-        // A permanently over-subscribed emitter cannot grow its debt without limit.
-        accumulator = min(accumulator, f32(settings.u_capacity));
-
-        let wanted = u32(floor(accumulator));
-
-        if (wanted > 0u) {
-            count = particle_take_spawn_budget(wanted, settings.u_capacity);
-            accumulator = accumulator - f32(count);
-        }
-    } else {
-        sleep = sleep + settings.u_dt;
-    }
-
-    spawn_counts.elements[row] = count;
-
-    state.accumulator = accumulator;
-    state.sleep = sleep;
-    ${STATE.marshalling_method_write}(&emitter_database, row, state);
-}
-`, [
-    PARTICLE_EMITTER_DESCRIPTOR.chunk_iterate(GROUP_SIZE, true),
-    STATE.chunk_read_rw,
-    STATE.chunk_write,
-    chunk_scene_database_access,
-    chunk_sphere_intersects_frustum,
-    chunk_particle_emitter_world_sphere,
-]);
-
-export const shader_particle_emitter_tick = ComputeShader.from({
-    label: "Particle Emitter Tick",
-    resources,
-    body,
-});
-
-export { PARTICLE_EMITTER_TICK_WORKGROUP_SIZE };
+import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { AABB3_STRUCT } from "../../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
+import {
+    chunk_aabb3_intersects_frustum
+} from "../../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_frustum.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { PARTICLE_EMITTER_TICK_WORKGROUP_SIZE } from "../ParticleConstants.js";
+import { PARTICLE_EMITTER_DESCRIPTOR, PARTICLE_EMITTER_STATE_DESCRIPTOR } from "../data/PARTICLE_DATABASE_SPEC.js";
+import { EMITTER_FLAG } from "../data/PARTICLE_EMITTER_STRUCT.js";
+import { chunk_particle_spawn_budget } from "./chunk_particle_spawn_budget.js";
+import { chunk_particle_bounds_unknown } from "../bounds/chunk_particle_bounds_unknown.js";
+
+/**
+ * The emitter tick: one thread per emitter table row, deciding how many particles each emitter
+ * spawns this frame. This is the pass that took spawning off the CPU — the host no longer walks the
+ * emitters, and no longer knows or cares how many there are.
+ *
+ * Per live row it:
+ *
+ * 1. picks up the row's GPU-owned state (the `emitter_state` table, see
+ *    {@link ../data/PARTICLE_EMITTER_STATE.js}) — or starts it over, when the state's generation is
+ *    not the record's, which is how both a brand-new row and a reused one are recognised without
+ *    the CPU clearing anything;
+ * 2. takes whatever the spawn-command pass queued into `pending` (the CPU's bursts, and in time
+ *    whatever a VM opcode asks for) into the accumulator;
+ * 3. if the emitter opts into culling, tests the bounding box on its state row against the camera
+ *    frustum; a culled emitter sleeps, accruing time it pays back as a bounded burst when it is
+ *    next seen;
+ * 4. integrates `spawn_rate * dt`, and turns the whole part of the accumulator into this frame's
+ *    count — clamped by the frame's spawn budget, which the reset pass seeded from the dead count,
+ *    so an emitter is only ever debited for particles the pool can hold;
+ * 5. writes that count to `spawn_counts.elements[row]`.
+ *
+ * `spawn_counts` is the input of a prefix scan, and the scan's inclusive sums are what the emit
+ * pass expands: one thread per particle, each locating its emitter by binary search over the sums.
+ * That is the same shape the rasteriser uses to expand meshes into meshlets, and it is what makes
+ * the per-emitter count unbounded — no thread here loops over its particles.
+ *
+ * The rows are walked with the emitter table's page iterator, one page group per workgroup, so an
+ * unallocated page costs one word read and a freed row costs one bit test. The state rows live in
+ * the same database buffer, bound once and read-write, and are read and written whole: each row is
+ * one thread's, so nothing here needs an atomic. Rows the walk skips leave their count at zero,
+ * which is why the counts buffer is cleared before this runs. The scan's `count` header is written
+ * by the first thread, from the table's element capacity, which is the only number the host
+ * supplies.
+ *
+ * ## What it does not do
+ *
+ * It does not measure the box it culls with. An emitter has no bounds an author could declare, so
+ * they are measured from the live particles by a pass of their own at the end of the frame
+ * (`../bounds/`), which publishes into the same state row this reads. All that reaches here is the
+ * finished box and one frustum test — the emitter table is walked twice a frame rather than three
+ * times, and this pass stays about spawning.
+ *
+ * The box is therefore one frame old: it is over the particles that were alive when the last frame
+ * ended. That is the right staleness for what it decides. A wrongly culled emitter spawns nothing
+ * for a frame and is paid back by the wake-up catch-up; a wrongly woken one spawns particles it
+ * would have had a frame later anyway.
+ *
+ * A new row, and any row without measured live particles, is exempt from culling. Unknown bounds
+ * are an infinite box, recognized before the frustum math: even a sub-frame spawn rate must be able
+ * to accumulate its first particle when the emitter's origin is offscreen. Prewarm remains optional.
+ *
+ * @type {ComputeShader}
+ */
+
+const GROUP_SIZE = PARTICLE_EMITTER_TICK_WORKGROUP_SIZE;
+
+// The database is bound read-write (the state rows are written), so the iterator and the readers
+// are the `_rw` variants: WGSL does not coerce access modes at a call site.
+const PG = PARTICLE_EMITTER_DESCRIPTOR.page_iterator_symbol_prefix(GROUP_SIZE, true);
+const STATE = PARTICLE_EMITTER_STATE_DESCRIPTOR;
+
+/**
+ * Per-dispatch, 16 bytes, read-only.
+ *
+ * @type {WebGPUStruct}
+ */
+const TICK_SETTINGS = WebGPUStruct.from({
+    /** seconds */
+    u_dt: f32,
+    /** cap on how much missed time a wake-up burst covers, seconds */
+    u_max_catchup: f32,
+    /** pool capacity — the ceiling on the accumulator, and the wrap guard for the budget counter */
+    u_capacity: u32,
+    /** element capacity of the emitter table — the length of the counts list the scan consumes */
+    u_emitter_capacity: u32,
+}, 'ParticleEmitterTickSettings');
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate('settings', TICK_SETTINGS);
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addStorageBuffer("emitter_database", WebGPUArray.u32, true)
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("spawn_counts", COLLECTION_U32_STRUCT_READ, true);
+
+const body = CodeChunk.from(/* language=wgsl */ `
+const EMITTER_FLAG_CULL : u32 = ${EMITTER_FLAG.CULL}u;
+
+@compute @workgroup_size(${GROUP_SIZE}, 1, 1)
+fn main(
+    @builtin(workgroup_id) wg_id : vec3<u32>,
+    @builtin(local_invocation_index) local_id : u32,
+) {
+    // The scan reads exactly this many counts. Written before the page test so it lands even when
+    // page 0 is unallocated — an empty table still has to scan to a total of zero.
+    if (wg_id.x == 0u && local_id == 0u) {
+        spawn_counts.count = settings.u_emitter_capacity;
+    }
+
+    // page_address is uniform across the workgroup, so this branch is uniform.
+    if (!${PG}_setup(&emitter_database, wg_id.x, local_id)) {
+        return;
+    }
+
+    let slot_in_page = ${PG}_slot_in_page(local_id);
+
+    if (slot_in_page >= ${PG}_ELEMENTS_PER_PAGE || !${PG}_is_occupied(slot_in_page)) {
+        return;
+    }
+
+    let em = ${PG}_read(&emitter_database, slot_in_page);
+    let row = ${PG}_slot_to_index(slot_in_page);
+
+    var state = ${STATE.marshalling_method_read_rw}(&emitter_database, row);
+
+    // Whatever the spawn-command pass queued since last tick. Taken before the generation test so a
+    // burst issued on the frame a row was (re)assigned is not lost with the stale state.
+    let pending = state.pending;
+    state.pending = 0u;
+
+    // A row this state has not seen: new emitter, or a reused row. Start from nothing.
+    let restarted = state.generation != em.generation;
+
+    if (restarted) {
+        state.generation = em.generation;
+        state.accumulator = 0.0;
+        state.age = 0.0;
+        state.sleep = 0.0;
+    }
+
+    var accumulator = state.accumulator + f32(pending);
+    var sleep = state.sleep;
+
+    state.age = state.age + settings.u_dt;
+
+    var visible = true;
+
+    // \`restarted\` is what keeps a row's first tick out of this: nothing has measured it yet, and
+    // the box the CPU staged is not a statement about where the emitter is.
+    if (!restarted && !particle_bounds_unknown(state.bounds_min) && (em.flags & EMITTER_FLAG_CULL) != 0u) {
+        let box = ${AABB3_STRUCT.make({ min: "state.bounds_min", max: "state.bounds_max" })};
+
+        visible = aabb3_intersects_frustum(box, camera.frustum);
+    }
+
+    var count = 0u;
+
+    if (visible) {
+        // Waking up: a bounded catch-up for the time spent culled, so a long occlusion cannot
+        // spike the pool on the frame the emitter comes back into view.
+        if (sleep > 0.0) {
+            accumulator = accumulator + em.spawn_rate * min(sleep, settings.u_max_catchup);
+            sleep = 0.0;
+        }
+
+        accumulator = accumulator + em.spawn_rate * settings.u_dt;
+
+        // A permanently over-subscribed emitter cannot grow its debt without limit.
+        accumulator = min(accumulator, f32(settings.u_capacity));
+
+        let wanted = u32(floor(accumulator));
+
+        if (wanted > 0u) {
+            count = particle_take_spawn_budget(wanted, settings.u_capacity);
+            accumulator = accumulator - f32(count);
+        }
+    } else {
+        sleep = sleep + settings.u_dt;
+    }
+
+    spawn_counts.elements[row] = count;
+
+    state.accumulator = accumulator;
+    state.sleep = sleep;
+    ${STATE.marshalling_method_write}(&emitter_database, row, state);
+}
+`, [
+    PARTICLE_EMITTER_DESCRIPTOR.chunk_iterate(GROUP_SIZE, true),
+    STATE.chunk_read_rw,
+    STATE.chunk_write,
+    chunk_particle_spawn_budget,
+    chunk_particle_bounds_unknown,
+    chunk_aabb3_intersects_frustum,
+    AABB3_STRUCT.declaration_chunk,
+]);
+
+export const shader_particle_emitter_tick = ComputeShader.from({
+    label: "Particle Emitter Tick",
+    resources,
+    body,
+});
+
+export { PARTICLE_EMITTER_TICK_WORKGROUP_SIZE };

package/src/shade/renderer/particles/shaders/shader_particle_reclaim.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Return to the free list the slots the emit pass's pre-warm killed.
+ *
+ * A newborn of a pre-warming emitter runs its UPDATE program forward before it is shown
+ * ({@link ./chunk_particle_emit_step.js}), and one whose life runs out during that never belongs on
+ * the alive list. Its slot has to go back to the free list, and this pass is where that happens.
+ *
+ * ## Why it is a pass of its own
+ *
+ * Because emit is the one pass that POPS the free list, and a push racing a pop on an array stack
+ * hands one slot to two particles.
+ *
+ * The pop is `old = atomicSub(DEAD, 1)` followed by a read of `dead[old - 1]`; a push would be
+ * `d = atomicAdd(DEAD, 1)` followed by a write to `dead[d]`. Order one thread's `atomicSub` before
+ * another's `atomicAdd` and the two name the same index, with nothing between the atomic and the
+ * plain access to order them. If the write lands first, the popper takes the pushed slot AND leaves
+ * it on the stack under a count that now includes it — so the next popper takes it again, and two
+ * live particles share one record. That is precisely the failure the build-indirect pass warns about
+ * for a different reason, and it is why the emit pass writes to `dead` nowhere: even its
+ * pool-exhaustion path only ever puts the counter back.
+ *
+ * Between two dispatches there is no such race. This pass only pushes; nothing in it pops.
+ *
+ * ## Where the slots are between the two
+ *
+ * At the far end of `alive_out`, growing down from `capacity`, counted by
+ * {@link PARTICLE_COUNTER.STILLBORN}. A region of a buffer emit already binds, rather than a list of
+ * its own: emit binds exactly the eight storage buffers a compute stage gets by default, and a ninth
+ * for a list that is empty on all but a handful of frames is not what the ninth is for.
+ *
+ * The park cannot collide with the alive list growing up from zero. Every entry in either is a
+ * distinct pool slot and a parked one is by definition not alive, so the two lengths sum to at most
+ * the `capacity` entries between them.
+ *
+ * ## Sizing
+ *
+ * A bounded launch with a grid-stride loop, the shape the wide interpreter uses and for the same
+ * reason: the length it walks is a GPU-side count. Nothing about it is sized from the host, and the
+ * dispatch costs one atomic load and an exit on the frames — nearly all of them — where nothing was
+ * parked.
+ *
+ * @type {ComputeShader}
+ */
+/** Workgroups this pass dispatches. Constant: the launch does not depend on how many slots were parked. */
+export const PARTICLE_RECLAIM_WORKGROUP_COUNT: number;
+export const shader_particle_reclaim: ComputeShader;
+export { PARTICLE_RECLAIM_WORKGROUP_SIZE };
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { PARTICLE_RECLAIM_WORKGROUP_SIZE } from "../ParticleConstants.js";
+//# sourceMappingURL=shader_particle_reclaim.d.ts.map

package/src/shade/renderer/particles/shaders/shader_particle_reclaim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_particle_reclaim.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_reclaim.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,2GAA2G;AAC3G,sDAAyG;AAWzG,oDAqBG;;8BAnF2B,+BAA+B;gDAGW,yBAAyB"}

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

@@ -72,7 +72,7 @@ fn fs_main(in : ParticleVertexOut) -> @location(0) vec4<f32> {
         let A = camera.device_depth_to_view_space.y;
         let B = camera.device_depth_to_view_space.x;
         let scene_vd = select(A / (scene_dev + B), 1e9, scene_dev <= 0.0);
-        color.a = color.a * particle_soft_fade(scene_vd, in.view_depth, PARTICLE_SOFT_FADE_RANGE);
+        color = particle_fade_color(color, in.blend, particle_soft_fade(scene_vd, in.view_depth, PARTICLE_SOFT_FADE_RANGE));
     }
 
     if ((in.flags & PARTICLE_FLAG_LIGHTING) != 0u) {

package/src/shade/renderer/particles/warmup/chunk_particle_warmup_step.d.ts

@@ -0,0 +1,36 @@
+/**
+ * What a warm-up tick does to one particle: run its emitter's UPDATE program over it, by a tick
+ * jittered for it alone, and say whether it lived.
+ *
+ * Shared by `./shader_particle_warmup_advance.js` and `./shader_particle_warmup_advance_wide.js`
+ * the way the main simulate's step is shared by its two register backings.
+ *
+ * ## Why this is not `particle_simulate_one`
+ *
+ * It is the same shape — header, record, node, context, program, verdict — and it differs in two
+ * things that are each the whole point of a separate pipeline.
+ *
+ * It decodes the program section **per lane**. The main step reads the section parameters from the
+ * wave's first lane, and is correct only because the bucketing passes regrouped the list so every
+ * wave holds one program. The warm-up feeds its advance the raw alive list — spawned by emitters that
+ * may run different programs, appended in whatever order the atomics landed — and would need the
+ * bucketing's six passes per tick to earn the broadcast. Per-lane decode costs the warm-up some of
+ * its own occupancy and nothing else, and the warm-up's occupancy is its own business: nothing here
+ * is linked into the main passes, and their compiled code is unchanged by this file existing.
+ *
+ * It **jitters the tick per particle**. Every particle born in one tick would otherwise reach the
+ * end of the loop with exactly that tick's age, and a warm-up of N ticks would arrive as N cohorts.
+ * A program does not care what `DELTA_TIME` it is handed, so each particle is advanced by
+ * `dt * (1 + PARTICLE_WARMUP_DT_JITTER * (u - 0.5))` for a `u` hashed from its slot and the tick —
+ * a hash and not a draw from `random()`, so the program's own random stream is exactly what it would
+ * have been.
+ *
+ * There is no padding sentinel to recognise: the list this reads is the alive list, which holds real
+ * slots only. The generation test is kept — the host holds the queue for one frame and an emitter
+ * cannot leave mid-loop, but the header carries the generation and honouring it is one compare.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_warmup_step: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_particle_warmup_step.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_particle_warmup_step.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/chunk_particle_warmup_step.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,yCAFU,SAAS,CA0DhB;0BArGuB,oCAAoC"}