@woosh/meep-engine 3.43.0 → 3.44.0

package/src/shade/renderer/particles/warmup/graph_particle_warmup.js

@@ -1,329 +1,334 @@
-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 { 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_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 { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
-import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
-import { PARTICLE_RECORD_WORD_COUNT, PARTICLE_WARMUP_WORKGROUP_SIZE } from "../ParticleConstants.js";
-import { PARTICLE_COUNTER_COUNT } from "../data/PARTICLE_COUNTERS.js";
-import { shader_particle_emit } from "../shaders/shader_particle_emit.js";
-import {
-    PARTICLE_EMIT_WIDE_WORKGROUP_COUNT,
-    shader_particle_emit_wide,
-} from "../shaders/shader_particle_emit_wide.js";
-import {
-    PARTICLE_WARMUP_WORKGROUP_COUNT,
-    shader_particle_warmup_init,
-    shader_particle_warmup_migrate,
-    shader_particle_warmup_reset,
-    shader_particle_warmup_tick,
-} from "./shader_particle_warmup.js";
-import { shader_particle_warmup_advance } from "./shader_particle_warmup_advance.js";
-import { shader_particle_warmup_advance_wide } from "./shader_particle_warmup_advance_wide.js";
-import { warmup_remaining } from "./warmup_schedule.js";
-
-/**
- * Run a batch of newly added emitters' simulations forward before they are first shown, so that a
- * continuous effect arrives at its steady state instead of growing into it in front of the player.
- *
- * ## What a warm-up is
- *
- * The ordinary loop — spawn, init, advance — run over a population of its own until every emitter
- * in the batch has been running for its `prewarm`. It is not a batch of particles dumped in one
- * tick and aged: an emitter keeps spawning throughout, the ones that die are replaced the way they
- * are in a live scene, and whatever drives the rate (a curve, `EMITTER_AGE`, the program itself)
- * drives it here, because it is the same program being run. What the loop leaves is the population
- * the emitter would have had, moved into the main pool.
- *
- * ## Why it is a pipeline of its own
- *
- * Because the main one is tuned and it must not pay for this. Emit and simulate are the passes whose
- * register pressure sets the system's occupancy, and their waves are kept program-uniform by the
- * bucketing; a warm-up folded into either would spend registers on every frame for work that
- * happens on one, and a loop inside a lane would break the uniform flow across a wave. So this
- * shares code with the main frame and integrates nothing into it: the emit pass is reused unchanged
- * over the warm-up's buffers, the advance is a pass of the warm-up's own (`./chunk_particle_warmup_step.js`
- * says why), and the main passes' compiled code is byte-identical whether this file exists or not.
- *
- * ## The population is transient
- *
- * Pool, alive lists, free list and counters are graph transients that exist for this frame's loop
- * and are then moved — record by record — into the main pool by the migrate pass. That is what keeps
- * the separation clean: the loop's free-list traffic never touches the main free list, the main
- * passes never see a half-warmed particle, and the one point of contact is a pass that pops from the
- * main pool and pushes nothing back.
- *
- * ## Bounded
- *
- * The tick count is at most `PARTICLE_WARMUP_MAX_TICKS`, with the tick length stretched to cover the
- * longest pre-warm in the batch (`./warmup_schedule.js`), so the frame that pays for a warm-up pays
- * for a known number of dispatches whatever was asked. Per tick: reset, tick, the scan, the emit
- * command, emit, advance — six or seven passes, all sized by constants or by the scan.
- *
- * ## Where it sits in the frame
- *
- * After the frame's own emit and simulate, before the bucketing. Migrate appends to the same alive
- * list they did, so the bucketing puts the warmed particles in next frame's simulate list, the bounds
- * pass measures them into their emitter's box this frame, and the draw draws them this frame. Which
- * is also what closes the culling fixed point the bounds passes describe: an emitter that arrives
- * with a warmed population is measured on its first frame, whatever the frustum thinks of its origin.
- *
- * Recorded only on a frame with something queued. The host knows: an emitter is queued when it is
- * registered with a `prewarm`, and the queue is consumed by the frame that records it.
- *
- * @param {object} params
- * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {number} params.scene_database graph handle
- * @param {number} params.emitter_database graph handle, threaded: the warm-up tick writes ages
- * @param {number} params.program graph handle of the packed program buffer
- * @param {number} params.pool main pool, threaded
- * @param {number} params.alive_out main alive list, threaded
- * @param {number} params.dead main free list, threaded
- * @param {number} params.counters main counters, threaded
- * @param {number} params.vm_registers the wide register file's handle, or -1 when the system is on
- *   the fast file
- * @param {GPUBuffer} params.queue the host's queue buffer, `PARTICLE_WARMUP_QUEUE_WORDS` per entry
- * @param {number} params.queue_count entries in the queue
- * @param {number} params.warm_capacity slots in the transient pool
- * @param {number} params.capacity main pool capacity
- * @param {number} params.emitter_capacity element capacity of the emitter table
- * @param {import("./warmup_schedule.js").WarmupSchedule} params.schedule
- * @param {boolean} params.wide_registers
- * @param {object} params.frame
- * @param {number} params.frame.time the frame's clock — the loop counts down to it
- * @param {number} params.frame.index
- * @returns {{pool: number, alive_out: number, dead: number, counters: number, emitter_database: number, vm_registers: number}}
- */
-export function graph_particle_warmup({
-                                          graph,
-                                          scene_database,
-                                          emitter_database,
-                                          program,
-                                          pool,
-                                          alive_out,
-                                          dead,
-                                          counters,
-                                          vm_registers,
-                                          queue,
-                                          queue_count,
-                                          warm_capacity,
-                                          capacity,
-                                          emitter_capacity,
-                                          schedule,
-                                          wide_registers,
-                                          frame,
-                                      }) {
-    assert.defined(graph, "graph");
-    assert.isPositiveInteger(queue_count, "queue_count");
-    assert.isPositiveInteger(warm_capacity, "warm_capacity");
-    assert.isPositiveInteger(schedule.ticks, "schedule.ticks");
-
-    const WORD = Uint32Array.BYTES_PER_ELEMENT;
-    const STORAGE = GPUBufferUsage.STORAGE;
-
-    const gr_queue = graph_import_buffer(graph, queue, "particles/warmup/queue");
-
-    // The transient population. Uncleared where the init pass writes every word that will be read
-    // (the free list), cleared where a word could be read before it is written (the counters, and
-    // the alive lists' tails are bounded by counts the passes wrote).
-    // Threaded like everything a pass writes: emit and advance both rename it, and the next reader
-    // must take the renamed handle or the graph's validator rejects the frame as reading a stale
-    // version.
-    let warm_pool = graph_create_buffer(graph, "particles/warmup/pool", BufferResourceDescriptor.from(
-        warm_capacity * PARTICLE_RECORD_WORD_COUNT * WORD, STORAGE,
-    ));
-    const warm_alive = [
-        graph_create_buffer(graph, "particles/warmup/alive_a", BufferResourceDescriptor.from(warm_capacity * WORD, STORAGE)),
-        graph_create_buffer(graph, "particles/warmup/alive_b", BufferResourceDescriptor.from(warm_capacity * WORD, STORAGE)),
-    ];
-    let warm_dead = graph_create_buffer(graph, "particles/warmup/dead", BufferResourceDescriptor.from(warm_capacity * WORD, STORAGE));
-    let warm_counters = graph_create_buffer(graph, "particles/warmup/counters", BufferResourceDescriptor.empty(
-        PARTICLE_COUNTER_COUNT * WORD, STORAGE | GPUBufferUsage.COPY_DST,
-    ));
-
-    // Every slot onto the free list.
-    {
-        const out = graph_compute_pass({
-            graph,
-            shader: shader_particle_warmup_init,
-            bindings: { dead: warm_dead, counters: warm_counters, u_capacity: warm_capacity },
-            group_count: [Math.ceil(warm_capacity / PARTICLE_WARMUP_WORKGROUP_SIZE), 1, 1],
-        });
-        warm_dead = out.dead;
-        warm_counters = out.counters;
-    }
-
-    const count_words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(Math.max(1, emitter_capacity));
-    const count_bytes = count_words * WORD;
-
-    let gr_queue_rw = gr_queue;
-
-    for (let tick = 0; tick < schedule.ticks; tick++) {
-        const remaining = warmup_remaining(schedule, tick);
-        // The clock at the start of this tick: the frame's, less what is still to run.
-        const time = frame.time - remaining;
-        // Distinct per tick, and unlike any frame index the main emit will seed with, so a warmed
-        // particle's random stream is not a later particle's in the same slot.
-        const frame_index = (frame.index ^ Math.imul(tick + 1, 0x9e3779b9)) >>> 0;
-
-        // Last tick's survivors are this tick's input; this tick appends to the other list.
-        const alive_in = warm_alive[(tick + 1) % 2];
-        let alive_this = warm_alive[tick % 2];
-
-        // 1. Roll the counters: alive -> alive_in, alive = 0, budget = dead.
-        warm_counters = graph_compute_pass({
-            graph,
-            shader: shader_particle_warmup_reset,
-            bindings: { counters: warm_counters },
-            group_count: [1, 1, 1],
-        }).counters;
-
-        // 2. The spawn decision, per queued emitter, into a count list as long as the emitter table.
-        //    Cleared whole: the tick writes only the queued rows.
-        let spawn_counts = graph_create_buffer(graph, "particles/warmup/spawn_counts", BufferResourceDescriptor.from(
-            count_bytes, STORAGE, 0, count_bytes,
-        ));
-
-        {
-            const out = graph_compute_pass({
-                graph,
-                shader: shader_particle_warmup_tick,
-                bindings: {
-                    queue: gr_queue_rw,
-                    emitter_database,
-                    counters: warm_counters,
-                    spawn_counts,
-                    settings: {
-                        u_dt: schedule.dt,
-                        u_remaining: remaining,
-                        u_capacity: warm_capacity,
-                        u_emitter_capacity: emitter_capacity,
-                        u_count: queue_count,
-                    },
-                },
-                group_count: [Math.ceil(queue_count / PARTICLE_WARMUP_WORKGROUP_SIZE), 1, 1],
-            });
-            gr_queue_rw = out.queue;
-            emitter_database = out.emitter_database;
-            warm_counters = out.counters;
-            spawn_counts = out.spawn_counts;
-        }
-
-        // 3. Scan the counts; the last sum is the tick's newborn count.
-        const spawn_prefix = graph_prefix_scan_csdldf({
-            graph,
-            data: spawn_counts,
-            element_max_count: Math.max(1, emitter_capacity),
-        });
-
-        // 4. That total as the emit dispatch — for the fast emit; the wide one reads the total as a
-        //    loop bound instead, as it does in the main frame.
-        const emit_command = graph_compute_pass({
-            graph,
-            shader: shader_prefix_sum_to_command,
-            bindings: {
-                prefix_sums: spawn_prefix,
-                command: graph_create_buffer(graph, "particles/warmup/emit_command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR),
-            },
-            group_count: [1, 1, 1],
-        }).command;
-
-        // 5. Emit — the main pass, unchanged, over the warm-up's buffers. It finds each newborn's
-        //    emitter in the scan, reads the record and the age off the main database, pops the
-        //    transient free list and appends to the transient alive list.
-        {
-            const bindings = {
-                scene_database,
-                emitter_database,
-                program,
-                spawn_prefix,
-                pool: warm_pool, alive_out: alive_this, dead: warm_dead, counters: warm_counters,
-                settings: { u_dt: schedule.dt, u_time: time, u_frame: frame_index, u_capacity: warm_capacity },
-            };
-
-            const out = wide_registers
-                ? graph_compute_pass({
-                    graph,
-                    shader: shader_particle_emit_wide,
-                    bindings: { ...bindings, vm_registers },
-                    group_count: [PARTICLE_EMIT_WIDE_WORKGROUP_COUNT, 1, 1],
-                })
-                : graph_compute_indirect_pass({
-                    graph,
-                    shader: shader_particle_emit,
-                    bindings,
-                    command: emit_command,
-                });
-
-            warm_pool = out.pool;
-            alive_this = out.alive_out;
-            warm_dead = out.dead;
-            warm_counters = out.counters;
-
-            if (wide_registers) { vm_registers = out.vm_registers; }
-        }
-
-        // 6. Advance last tick's survivors by one tick, into the same list the newborns went to.
-        {
-            const bindings = {
-                scene_database,
-                emitter_database,
-                program,
-                pool: warm_pool, alive_in, alive_out: alive_this, dead: warm_dead, counters: warm_counters,
-                settings: { u_dt: schedule.dt, u_time: time, u_frame: frame_index },
-            };
-
-            const out = wide_registers
-                ? graph_compute_pass({
-                    graph,
-                    shader: shader_particle_warmup_advance_wide,
-                    bindings: { ...bindings, vm_registers },
-                    group_count: [PARTICLE_WARMUP_WORKGROUP_COUNT, 1, 1],
-                })
-                : graph_compute_pass({
-                    graph,
-                    shader: shader_particle_warmup_advance,
-                    bindings,
-                    group_count: [PARTICLE_WARMUP_WORKGROUP_COUNT, 1, 1],
-                });
-
-            warm_pool = out.pool;
-            alive_this = out.alive_out;
-            warm_dead = out.dead;
-            warm_counters = out.counters;
-
-            if (wide_registers) { vm_registers = out.vm_registers; }
-        }
-
-        warm_alive[tick % 2] = alive_this;
-    }
-
-    // 7. The population is the scene's: every survivor into a main-pool slot, onto the main alive
-    //    list.
-    {
-        const out = graph_compute_pass({
-            graph,
-            shader: shader_particle_warmup_migrate,
-            bindings: {
-                warm_pool,
-                warm_alive: warm_alive[(schedule.ticks - 1) % 2],
-                warm_counters,
-                pool, alive_out, dead, counters,
-                u_capacity: capacity,
-            },
-            group_count: [PARTICLE_WARMUP_WORKGROUP_COUNT, 1, 1],
-        });
-
-        pool = out.pool;
-        alive_out = out.alive_out;
-        dead = out.dead;
-        counters = out.counters;
-    }
-
-    return { pool, alive_out, dead, counters, emitter_database, vm_registers };
-}
+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,
+    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_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 { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
+import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
+import { PARTICLE_RECORD_WORD_COUNT, PARTICLE_WARMUP_WORKGROUP_SIZE } from "../ParticleConstants.js";
+import { PARTICLE_COUNTER_COUNT } from "../data/PARTICLE_COUNTERS.js";
+import { shader_particle_emit } from "../shaders/shader_particle_emit.js";
+import {
+    PARTICLE_EMIT_WIDE_WORKGROUP_COUNT,
+    shader_particle_emit_wide,
+} from "../shaders/shader_particle_emit_wide.js";
+import {
+    PARTICLE_WARMUP_WORKGROUP_COUNT,
+    shader_particle_warmup_init,
+    shader_particle_warmup_migrate,
+    shader_particle_warmup_reset,
+    shader_particle_warmup_tick,
+} from "./shader_particle_warmup.js";
+import { shader_particle_warmup_advance } from "./shader_particle_warmup_advance.js";
+import { shader_particle_warmup_advance_wide } from "./shader_particle_warmup_advance_wide.js";
+import { warmup_remaining } from "./warmup_schedule.js";
+
+/**
+ * Run a batch of newly added emitters' simulations forward before they are first shown, so that a
+ * continuous effect arrives at its steady state instead of growing into it in front of the player.
+ *
+ * ## What a warm-up is
+ *
+ * The ordinary loop — spawn, init, advance — run over a population of its own until every emitter
+ * in the batch has been running for its `prewarm`. It is not a batch of particles dumped in one
+ * tick and aged: an emitter keeps spawning throughout, the ones that die are replaced the way they
+ * are in a live scene, and whatever drives the rate (a curve, `EMITTER_AGE`, the program itself)
+ * drives it here, because it is the same program being run. What the loop leaves is the population
+ * the emitter would have had, moved into the main pool.
+ *
+ * ## Why it is a pipeline of its own
+ *
+ * Because the main one is tuned and it must not pay for this. Emit and simulate are the passes whose
+ * register pressure sets the system's occupancy, and their waves are kept program-uniform by the
+ * bucketing; a warm-up folded into either would spend registers on every frame for work that
+ * happens on one, and a loop inside a lane would break the uniform flow across a wave. So this
+ * shares code with the main frame and integrates nothing into it: the emit pass is reused unchanged
+ * over the warm-up's buffers, the advance is a pass of the warm-up's own (`./chunk_particle_warmup_step.js`
+ * says why), and the main passes' compiled code is byte-identical whether this file exists or not.
+ *
+ * ## The population is transient
+ *
+ * Pool, alive lists, free list and counters are graph transients that exist for this frame's loop
+ * and are then moved — record by record — into the main pool by the migrate pass. That is what keeps
+ * the separation clean: the loop's free-list traffic never touches the main free list, the main
+ * passes never see a half-warmed particle, and the one point of contact is a pass that pops from the
+ * main pool and pushes nothing back.
+ *
+ * ## Bounded
+ *
+ * The tick count is at most `PARTICLE_WARMUP_MAX_TICKS`, with the tick length stretched to cover the
+ * longest pre-warm in the batch (`./warmup_schedule.js`), so the frame that pays for a warm-up pays
+ * for a known number of dispatches whatever was asked. Per tick: reset, tick, the scan, the emit
+ * command, emit, advance — six or seven passes, all sized by constants or by the scan.
+ *
+ * ## Where it sits in the frame
+ *
+ * After the frame's own emit and simulate, before the bucketing. Migrate appends to the same alive
+ * list they did, so the bucketing puts the warmed particles in next frame's simulate list, the bounds
+ * pass measures them into their emitter's box this frame, and the draw draws them this frame. Which
+ * is also what closes the culling fixed point the bounds passes describe: an emitter that arrives
+ * with a warmed population is measured on its first frame, whatever the frustum thinks of its origin.
+ *
+ * Recorded only on a frame with something queued. The host knows: an emitter is queued when it is
+ * registered with a `prewarm`, and the queue is consumed by the frame that records it.
+ *
+ * @param {object} params
+ * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.scene_database graph handle
+ * @param {number} params.emitter_database graph handle, threaded: the warm-up tick writes ages
+ * @param {number} params.program graph handle of the packed program buffer
+ * @param {number} params.pool main pool, threaded
+ * @param {number} params.alive_out main alive list, threaded
+ * @param {number} params.dead main free list, threaded
+ * @param {number} params.counters main counters, threaded
+ * @param {number} params.vm_registers the wide register file's handle, or -1 when the system is on
+ *   the fast file
+ * @param {GPUBuffer} params.queue the host's queue buffer, `PARTICLE_WARMUP_QUEUE_WORDS` per entry
+ * @param {number} params.queue_count entries in the queue
+ * @param {number} params.warm_capacity slots in the transient pool
+ * @param {number} params.capacity main pool capacity
+ * @param {number} params.emitter_capacity element capacity of the emitter table
+ * @param {import("./warmup_schedule.js").WarmupSchedule} params.schedule
+ * @param {boolean} params.wide_registers
+ * @param {object} params.frame
+ * @param {number} params.frame.time the frame's clock — the loop counts down to it
+ * @param {number} params.frame.index
+ * @returns {{pool: number, alive_out: number, dead: number, counters: number, emitter_database: number, vm_registers: number}}
+ */
+export function graph_particle_warmup({
+                                          graph,
+                                          scene_database,
+                                          emitter_database,
+                                          program,
+                                          pool,
+                                          alive_out,
+                                          dead,
+                                          counters,
+                                          vm_registers,
+                                          queue,
+                                          queue_count,
+                                          warm_capacity,
+                                          capacity,
+                                          emitter_capacity,
+                                          schedule,
+                                          wide_registers,
+                                          frame,
+                                      }) {
+    assert.defined(graph, "graph");
+    assert.isPositiveInteger(queue_count, "queue_count");
+    assert.isPositiveInteger(warm_capacity, "warm_capacity");
+    assert.isPositiveInteger(schedule.ticks, "schedule.ticks");
+
+    const WORD = Uint32Array.BYTES_PER_ELEMENT;
+    const STORAGE = GPUBufferUsage.STORAGE;
+
+    const gr_queue = graph_import_buffer(graph, queue, "particles/warmup/queue");
+
+    // The transient population. Uncleared where the init pass writes every word that will be read
+    // (the free list), cleared where a word could be read before it is written (the counters, and
+    // the alive lists' tails are bounded by counts the passes wrote).
+    // Threaded like everything a pass writes: emit and advance both rename it, and the next reader
+    // must take the renamed handle or the graph's validator rejects the frame as reading a stale
+    // version.
+    let warm_pool = graph_create_buffer(graph, "particles/warmup/pool", BufferResourceDescriptor.from(
+        warm_capacity * PARTICLE_RECORD_WORD_COUNT * WORD, STORAGE,
+    ));
+    const warm_alive = [
+        graph_create_buffer(graph, "particles/warmup/alive_a", BufferResourceDescriptor.from(warm_capacity * WORD, STORAGE)),
+        graph_create_buffer(graph, "particles/warmup/alive_b", BufferResourceDescriptor.from(warm_capacity * WORD, STORAGE)),
+    ];
+    let warm_dead = graph_create_buffer(graph, "particles/warmup/dead", BufferResourceDescriptor.from(warm_capacity * WORD, STORAGE));
+    let warm_counters = graph_create_buffer(graph, "particles/warmup/counters", BufferResourceDescriptor.empty(
+        PARTICLE_COUNTER_COUNT * WORD, STORAGE | GPUBufferUsage.COPY_DST,
+    ));
+
+    // Every slot onto the free list.
+    {
+        const out = graph_compute_pass({
+            graph,
+            shader: shader_particle_warmup_init,
+            bindings: { dead: warm_dead, counters: warm_counters, u_capacity: warm_capacity },
+            group_count: [Math.ceil(warm_capacity / PARTICLE_WARMUP_WORKGROUP_SIZE), 1, 1],
+        });
+        warm_dead = out.dead;
+        warm_counters = out.counters;
+    }
+
+    const count_words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(Math.max(1, emitter_capacity));
+    const count_bytes = count_words * WORD;
+
+    let gr_queue_rw = gr_queue;
+
+    for (let tick = 0; tick < schedule.ticks; tick++) {
+        const remaining = warmup_remaining(schedule, tick);
+        // The clock at the start of this tick: the frame's, less what is still to run.
+        const time = frame.time - remaining;
+        // Distinct per tick, and unlike any frame index the main emit will seed with, so a warmed
+        // particle's random stream is not a later particle's in the same slot.
+        const frame_index = (frame.index ^ Math.imul(tick + 1, 0x9e3779b9)) >>> 0;
+
+        // Last tick's survivors are this tick's input; this tick appends to the other list.
+        const alive_in = warm_alive[(tick + 1) % 2];
+        let alive_this = warm_alive[tick % 2];
+
+        // 1. Roll the counters: alive -> alive_in, alive = 0, budget = dead.
+        warm_counters = graph_compute_pass({
+            graph,
+            shader: shader_particle_warmup_reset,
+            bindings: { counters: warm_counters },
+            group_count: [1, 1, 1],
+        }).counters;
+
+        // 2. The spawn decision, per queued emitter, into a count list as long as the emitter table.
+        //    Cleared whole: the tick writes only the queued rows.
+        let spawn_counts = graph_create_buffer(graph, "particles/warmup/spawn_counts", BufferResourceDescriptor.from(
+            count_bytes, STORAGE, 0, count_bytes,
+        ));
+
+        {
+            const out = graph_compute_pass({
+                graph,
+                shader: shader_particle_warmup_tick,
+                bindings: {
+                    queue: gr_queue_rw,
+                    emitter_database,
+                    counters: warm_counters,
+                    spawn_counts,
+                    settings: {
+                        u_dt: schedule.dt,
+                        u_remaining: remaining,
+                        u_capacity: warm_capacity,
+                        u_emitter_capacity: emitter_capacity,
+                        u_count: queue_count,
+                    },
+                },
+                group_count: [Math.ceil(queue_count / PARTICLE_WARMUP_WORKGROUP_SIZE), 1, 1],
+            });
+            gr_queue_rw = out.queue;
+            emitter_database = out.emitter_database;
+            warm_counters = out.counters;
+            spawn_counts = out.spawn_counts;
+        }
+
+        // 3. Scan the counts; the last sum is the tick's newborn count.
+        const spawn_prefix = graph_prefix_scan_csdldf({
+            graph,
+            input: spawn_counts,
+            output: graph_create_buffer(graph, "particles/warmup/spawn_prefix",
+                prefix_scan_csdldf_output_descriptor(Math.max(1, emitter_capacity))),
+            element_max_count: Math.max(1, emitter_capacity),
+        });
+
+        // 4. That total as the emit dispatch — for the fast emit; the wide one reads the total as a
+        //    loop bound instead, as it does in the main frame.
+        const emit_command = graph_compute_pass({
+            graph,
+            shader: shader_prefix_sum_to_command,
+            bindings: {
+                prefix_sums: spawn_prefix,
+                command: graph_create_buffer(graph, "particles/warmup/emit_command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR),
+            },
+            group_count: [1, 1, 1],
+        }).command;
+
+        // 5. Emit — the main pass, unchanged, over the warm-up's buffers. It finds each newborn's
+        //    emitter in the scan, reads the record and the age off the main database, pops the
+        //    transient free list and appends to the transient alive list.
+        {
+            const bindings = {
+                scene_database,
+                emitter_database,
+                program,
+                spawn_prefix,
+                pool: warm_pool, alive_out: alive_this, dead: warm_dead, counters: warm_counters,
+                settings: { u_dt: schedule.dt, u_time: time, u_frame: frame_index, u_capacity: warm_capacity },
+            };
+
+            const out = wide_registers
+                ? graph_compute_pass({
+                    graph,
+                    shader: shader_particle_emit_wide,
+                    bindings: { ...bindings, vm_registers },
+                    group_count: [PARTICLE_EMIT_WIDE_WORKGROUP_COUNT, 1, 1],
+                })
+                : graph_compute_indirect_pass({
+                    graph,
+                    shader: shader_particle_emit,
+                    bindings,
+                    command: emit_command,
+                });
+
+            warm_pool = out.pool;
+            alive_this = out.alive_out;
+            warm_dead = out.dead;
+            warm_counters = out.counters;
+
+            if (wide_registers) { vm_registers = out.vm_registers; }
+        }
+
+        // 6. Advance last tick's survivors by one tick, into the same list the newborns went to.
+        {
+            const bindings = {
+                scene_database,
+                emitter_database,
+                program,
+                pool: warm_pool, alive_in, alive_out: alive_this, dead: warm_dead, counters: warm_counters,
+                settings: { u_dt: schedule.dt, u_time: time, u_frame: frame_index },
+            };
+
+            const out = wide_registers
+                ? graph_compute_pass({
+                    graph,
+                    shader: shader_particle_warmup_advance_wide,
+                    bindings: { ...bindings, vm_registers },
+                    group_count: [PARTICLE_WARMUP_WORKGROUP_COUNT, 1, 1],
+                })
+                : graph_compute_pass({
+                    graph,
+                    shader: shader_particle_warmup_advance,
+                    bindings,
+                    group_count: [PARTICLE_WARMUP_WORKGROUP_COUNT, 1, 1],
+                });
+
+            warm_pool = out.pool;
+            alive_this = out.alive_out;
+            warm_dead = out.dead;
+            warm_counters = out.counters;
+
+            if (wide_registers) { vm_registers = out.vm_registers; }
+        }
+
+        warm_alive[tick % 2] = alive_this;
+    }
+
+    // 7. The population is the scene's: every survivor into a main-pool slot, onto the main alive
+    //    list.
+    {
+        const out = graph_compute_pass({
+            graph,
+            shader: shader_particle_warmup_migrate,
+            bindings: {
+                warm_pool,
+                warm_alive: warm_alive[(schedule.ticks - 1) % 2],
+                warm_counters,
+                pool, alive_out, dead, counters,
+                u_capacity: capacity,
+            },
+            group_count: [PARTICLE_WARMUP_WORKGROUP_COUNT, 1, 1],
+        });
+
+        pool = out.pool;
+        alive_out = out.alive_out;
+        dead = out.dead;
+        counters = out.counters;
+    }
+
+    return { pool, alive_out, dead, counters, emitter_database, vm_registers };
+}