@woosh/meep-engine 3.15.0 → 3.16.0

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

@@ -1,17 +1,27 @@
 /**
- * The particle emit (spawn) pass.
+ * The particle emit pass: one thread per particle born this frame.
  *
- * Input is a flat list of spawn requests (one packed emitter-index + batch-fraction per particle
- * to create; built by ParticleSpawnScheduler). Per request: pop a free slot from the dead
- * list, clear the record, stamp the owning emitter, run that emitter's compiled SPAWN program to
- * initialise the particle's user-defined state, then append the slot to the new alive list.
+ * Its input is the prefix scan of the emitter tick pass's per-row spawn counts. Thread `i` finds
+ * the emitter it belongs to by binary search over the inclusive sums — the first row whose sum
+ * exceeds `i` — and its place within that emitter's batch from the sum before. That is the
+ * meshes-to-meshlets expansion applied to particles: the per-emitter count is unbounded, no thread
+ * loops, and the dispatch is sized on the GPU from the scan's total.
  *
- * Runs after simulate in the frame so newly born particles join the same alive list the survivors
- * were compacted into. Shares the VM + context + emitter chunks with simulate.
+ * Then, as ever: pop a free slot from the dead list, clear the record, stamp the header with the
+ * emitter row and its generation, run the emitter's INIT program to give the particle its state,
+ * and append the slot to the new alive list. The emitter's position and axes come from its scene
+ * node, so a particle born of an emitter riding a bone starts where the bone is this frame.
+ *
+ * Runs before simulate in the frame so newborns join the same alive list survivors are compacted
+ * into. Shares the VM + context + emitter chunks with simulate.
  *
  * @type {ComputeShader}
  */
-export const PARTICLE_EMIT_WORKGROUP_SIZE: ComputeShader;
+/**
+ * Sized by `shader_prefix_sum_to_command`, which turns the scan's total into workgroups of this
+ * size — so the two must agree, and the constant it uses is the one it is.
+ */
+export const PARTICLE_EMIT_WORKGROUP_SIZE: number;
 export const shader_particle_emit: ComputeShader;
 import { ComputeShader } from "../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_particle_emit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;GAYG;AAEH,2CAHU,aAAa,CAGwB;AA+F/C,iDAIG;8BAlI2B,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;GAGG;AACH,kDAA8E;AAuH9E,iDAIG;8BAnK2B,+BAA+B"}

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

@@ -1,7 +1,10 @@
 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 { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
+import { chunk_lower_bound_branchless } from "../../shader/chunk/math/chunk_lower_bound_branchless.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import {
@@ -11,35 +14,43 @@ import {
     PARTICLE_VM_INSTRUCTION_WORDS,
 } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
-import {
-    SPAWN_REQUEST_EMITTER_MASK,
-    SPAWN_REQUEST_FRACTION_MAX,
-    SPAWN_REQUEST_FRACTION_SHIFT,
-} from "../runtime/spawn_request_encoding.js";
-import { chunk_particle_context, chunk_particle_curve_disabled } from "./chunk_particle_context.js";
+import { chunk_particle_header } from "../data/particle_header.js";
+import { chunk_particle_curve_disabled } from "./chunk_particle_curve_disabled.js";
+import { chunk_particle_emitter_age } from "./chunk_particle_emitter_age.js";
+import { chunk_particle_setup_context } from "./chunk_particle_setup_context.js";
 
 /**
- * The particle emit (spawn) pass.
+ * The particle emit pass: one thread per particle born this frame.
+ *
+ * Its input is the prefix scan of the emitter tick pass's per-row spawn counts. Thread `i` finds
+ * the emitter it belongs to by binary search over the inclusive sums — the first row whose sum
+ * exceeds `i` — and its place within that emitter's batch from the sum before. That is the
+ * meshes-to-meshlets expansion applied to particles: the per-emitter count is unbounded, no thread
+ * loops, and the dispatch is sized on the GPU from the scan's total.
  *
- * Input is a flat list of spawn requests (one packed emitter-index + batch-fraction per particle
- * to create; built by ParticleSpawnScheduler). Per request: pop a free slot from the dead
- * list, clear the record, stamp the owning emitter, run that emitter's compiled SPAWN program to
- * initialise the particle's user-defined state, then append the slot to the new alive list.
+ * Then, as ever: pop a free slot from the dead list, clear the record, stamp the header with the
+ * emitter row and its generation, run the emitter's INIT program to give the particle its state,
+ * and append the slot to the new alive list. The emitter's position and axes come from its scene
+ * node, so a particle born of an emitter riding a bone starts where the bone is this frame.
  *
- * Runs after simulate in the frame so newly born particles join the same alive list the survivors
- * were compacted into. Shares the VM + context + emitter chunks with simulate.
+ * Runs before simulate in the frame so newborns join the same alive list survivors are compacted
+ * into. Shares the VM + context + emitter chunks with simulate.
  *
  * @type {ComputeShader}
  */
 
-export const PARTICLE_EMIT_WORKGROUP_SIZE = 64;
+/**
+ * Sized by `shader_prefix_sum_to_command`, which turns the scan's total into workgroups of this
+ * size — so the two must agree, and the constant it uses is the one it is.
+ */
+export const PARTICLE_EMIT_WORKGROUP_SIZE = COMPUTE_SHADER_DEFAULT_GROUP_SIZE;
 
 /**
- * Per-dispatch, 20 bytes, read-only.
+ * Per-dispatch, 16 bytes, read-only.
  *
- * These were five separate uniforms, which meant five transient buffers, five staging copies and
- * five bind group entries for twenty bytes of frame state. WGSL allows one immediate per entry
- * point, so carrying them as immediate data means carrying them together.
+ * These were separate uniforms, which meant a transient buffer, a staging copy and a bind group
+ * entry each for a few bytes of frame state. WGSL allows one immediate per entry point, so carrying
+ * them as immediate data means carrying them together.
  *
  * @type {WebGPUStruct}
  */
@@ -47,7 +58,6 @@ const EMIT_SETTINGS = WebGPUStruct.from({
     u_dt: f32,
     u_time: f32,
     u_frame: u32,
-    u_count: u32,
     u_capacity: u32,
 }, 'ParticleEmitSettings');
 
@@ -56,14 +66,15 @@ const resources = new ShaderResourceSetDescriptor();
 resources.setImmediate('settings', EMIT_SETTINGS);
 
 resources.createGroup()
-    .addStorageBuffer("emitters", WebGPUArray.u32, false)
+    .addStorageBuffer("scene_database", WebGPUArray.u32, false)
+    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
     .addStorageBuffer("program", WebGPUArray.u32, false)
-    .addStorageBuffer("vm_constants", WebGPUArray.u32, false)
+    .addStorageBuffer("spawn_prefix", COLLECTION_U32_STRUCT_READ, false)
     .addStorageBuffer("pool", WebGPUArray.u32, true)
-    .addStorageBuffer("spawn_requests", WebGPUArray.u32, false)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
     .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
+
 const body = CodeChunk.from(
     /* language=wgsl */
     `
@@ -77,14 +88,27 @@ const COUNTER_DEAD : u32 = ${PARTICLE_COUNTER.DEAD}u;
 @compute @workgroup_size(${PARTICLE_EMIT_WORKGROUP_SIZE}, 1, 1)
 fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     let i = gid.x;
-    if (i >= settings.u_count) { return; }
 
-    // Packed request: low 16 bits = emitter index, high 16 = batch fraction (see
-    // spawn_request_encoding.js). The fraction is LOCAL to this emitter's batch this frame
-    // (SPAWN_FRACTION contract: n / spawn_count), not the global request index / settings.u_count.
-    let request = spawn_requests[i];
-    let emitter_index = request & ${SPAWN_REQUEST_EMITTER_MASK}u;
-    let spawn_fraction = f32(request >> ${SPAWN_REQUEST_FRACTION_SHIFT}u) / ${SPAWN_REQUEST_FRACTION_MAX}.0;
+    // The scan's last inclusive sum is the number of particles born this frame. An empty list has
+    // no last element to read; it also has no particles.
+    let emitter_count = spawn_prefix.count;
+    if (emitter_count == 0u) { return; }
+    let total = spawn_prefix.elements[emitter_count - 1u];
+    if (i >= total) { return; }
+
+    // The emitter is the first row whose inclusive sum exceeds i; its batch starts at the sum
+    // before, which is the exclusive sum. Rows that spawned nothing this frame have equal sums and
+    // the search steps over them.
+    let emitter_row = lower_bound_branchless(&spawn_prefix.elements, i + 1u, emitter_count);
+    var batch_start = 0u;
+    if (emitter_row > 0u) {
+        batch_start = spawn_prefix.elements[emitter_row - 1u];
+    }
+    let batch_size = spawn_prefix.elements[emitter_row] - batch_start;
+
+    // SPAWN_FRACTION contract: this particle's place in its emitter's batch this frame, n / count,
+    // for spreading a batch along a spawn curve.
+    let spawn_fraction = f32(i - batch_start) / f32(batch_size);
 
     // Pop a free slot off the dead-list stack; drop the spawn if the pool is exhausted.
     //
@@ -102,21 +126,26 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     let slot = dead[old_dead - 1u];
     let record_base = slot * PARTICLE_RECORD_WORDS;
 
+    let em = particle_emitter_read(&emitter_database, emitter_row);
+    let node = scene_read_node(&scene_database, em.node);
+
     // Clear stale user state from a recycled slot (each write targets a distinct word).
     for (var w = PARTICLE_USER_WORD_START; w < PARTICLE_RECORD_WORDS; w = w + 1u) {
         pool[record_base + w] = 0u;
     }
-    pool[record_base + PARTICLE_HEADER_EMITTER] = emitter_index;
-
-    let em = particle_emitter_read(&emitters, emitter_index);
+    pool[record_base + PARTICLE_HEADER_EMITTER] = particle_header_pack(emitter_row, em.generation);
 
     particle_vm_reset();
-    particle_setup_context(em, slot, settings.u_dt, settings.u_time, 0.0, spawn_fraction, settings.u_frame);
+    particle_setup_context(
+        em, node, slot,
+        settings.u_dt, settings.u_time,
+        particle_emitter_age(&emitter_database, emitter_row),
+        spawn_fraction, settings.u_frame,
+    );
     particle_vm_execute(
         &program,
-        em.spawn_offset * PARTICLE_INSTRUCTION_WORDS,
-        em.spawn_count,
-        &vm_constants,
+        em.init_offset * PARTICLE_INSTRUCTION_WORDS,
+        em.init_count,
         em.constant_offset,
         &pool,
         record_base,
@@ -125,7 +154,13 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
     alive_out[a] = slot;
 }
-`, [chunk_particle_context, chunk_particle_curve_disabled]);
+`, [
+    chunk_particle_setup_context,
+    chunk_particle_emitter_age,
+    chunk_particle_curve_disabled,
+    chunk_particle_header,
+    chunk_lower_bound_branchless,
+]);
 
 export const shader_particle_emit = ComputeShader.from({
     label: "Particle Emit",

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

@@ -0,0 +1,5 @@
+export const shader_particle_emitter_tick: ComputeShader;
+export { PARTICLE_EMITTER_TICK_WORKGROUP_SIZE };
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { PARTICLE_EMITTER_TICK_WORKGROUP_SIZE } from "../ParticleConstants.js";
+//# sourceMappingURL=shader_particle_emitter_tick.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_particle_emitter_tick.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emitter_tick.js"],"names":[],"mappings":"AAiNA,yDAIG;;8BA5M2B,+BAA+B;qDAGR,yBAAyB"}

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

@@ -0,0 +1,216 @@
+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 };

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_finalize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_finalize.js"],"names":[],"mappings":"AAoCA,2DAaG;AAaH,2DAmCG;;8BA/F2B,+BAA+B;iDAIZ,+BAA+B"}
+{"version":3,"file":"shader_particle_finalize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_finalize.js"],"names":[],"mappings":"AAqCA,2DAgBG;AAaH,2DAmCG;;8BAnG2B,+BAA+B;iDAIZ,+BAA+B"}

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

@@ -9,8 +9,9 @@ import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "./shader_particle_simulate.js"
 /**
  * Small housekeeping passes that keep the pipeline GPU-driven:
  *
- * - {@link shader_particle_reset_counters} — zero the alive / spawn / sorted / sim-padded counters
- *   at the top of the frame (the dead count and the ALIVE_IN snapshot persist across frames).
+ * - {@link shader_particle_reset_counters} — zero the alive / sorted / sim-padded counters at the
+ *   top of the frame (the dead count and the ALIVE_IN snapshot persist across frames), and seed the
+ *   frame's spawn budget from the dead count.
  * - {@link shader_particle_build_indirect} — turn the frame's two final counts into next frame's
  *   input contract: (a) snapshot the coherence pass's padded list length into
  *   {@link PARTICLE_COUNTER.ALIVE_IN} — the exact input length for NEXT frame's simulate, (b) write
@@ -42,9 +43,12 @@ export const shader_particle_reset_counters = ComputeShader.from({
 @compute @workgroup_size(1, 1, 1)
 fn main() {
     atomicStore(&counters[${PARTICLE_COUNTER.ALIVE}u], 0u);
-    atomicStore(&counters[${PARTICLE_COUNTER.SPAWN}u], 0u);
     atomicStore(&counters[${PARTICLE_COUNTER.SORTED}u], 0u);
     atomicStore(&counters[${PARTICLE_COUNTER.SIM_PADDED}u], 0u);
+
+    // This frame's spawn budget is the free list as it stands: the emitter tick pass takes from it
+    // per emitter, so nobody is debited for a particle the pool cannot hold.
+    atomicStore(&counters[${PARTICLE_COUNTER.SPAWN_BUDGET}u], atomicLoad(&counters[${PARTICLE_COUNTER.DEAD}u]));
 }
 `),
 });

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_render.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_render.js"],"names":[],"mappings":"AA8JA;;;;;;;;;GASG;AACH;IAP4B,YAAY,GAA7B,MAAM;IACgB,YAAY,GAAlC,MAAM,GAAC,IAAI;IAEkB,aAAa;IAExC,wBAAwB,CA2BpC;;;;;;;;;;;;;;;;AAED,yFAAyF;AACzF,uEAAsD;yCApMb,iEAAiE;4CAO9D,sDAAsD"}
+{"version":3,"file":"shader_particle_render.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_render.js"],"names":[],"mappings":"AA6FA;;;;;;;;;GASG;AACH;IAP4B,YAAY,GAA7B,MAAM;IACgB,YAAY,GAAlC,MAAM,GAAC,IAAI;IAEkB,aAAa;IAExC,wBAAwB,CA2BpC;;;;;;;;;;;;;;;;AAED,yFAAyF;AACzF,uEAAsD;yCAnIb,iEAAiE;4CAO9D,sDAAsD"}