@woosh/meep-engine 3.17.2 → 3.18.0

package/src/shade/renderer/particles/data/particle_emitter_record.js

@@ -56,9 +56,6 @@ export function write_emitter_record(record, emitter, context) {
     record.node = context.transform_row;
     record.generation = context.generation;
 
-    record.bounds_center.set(emitter.bounds_center);
-    record.bounds_radius = emitter.bounds_radius;
-
     record.render_position = emitter.render_position;
     record.render_size = emitter.render_size;
     record.render_color = emitter.render_color;
@@ -93,9 +90,6 @@ export function create_emitter_record() {
         node: 0,
         generation: 0,
 
-        bounds_center: new Float32Array(3),
-        bounds_radius: 0,
-
         render_position: 0,
         render_size: 0,
         render_color: 0,

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

@@ -6,7 +6,7 @@
  * {@link graph_particles_simulate} is everything that moves particles:
  *
  *   reset counters -> spawn commands -> emitter tick -> scan -> spawn args -> emit -> simulate
- *   -> bucket -> build indirect
+ *   -> bucket -> bounds -> build indirect
  *
  * and it leaves the frame's alive list, the pool and the indirect draw args as graph handles for
  * whoever draws. Nothing here depends on how they will be drawn, which is why the render mode
@@ -24,6 +24,15 @@
  * the scan, and the length of the spawn-command list it authored itself. Neither is a count of
  * anything alive.
  *
+ * ## Bounds are measured at the end, not carried along
+ *
+ * An emitter has no bounds an author could state — its particles are simulated in world space by
+ * arbitrary bytecode — so the box the culling and occupancy passes use is measured from the live
+ * particles, by `bounds/`, once emit and simulate have both finished appending. Measuring it there
+ * rather than inside those two passes is what makes it a box over ONE population: a merge folded
+ * into emit and simulate would union this frame's newborns with last frame's survivors, and would
+ * pay six atomics per particle inside the pass whose register pressure sets the system's occupancy.
+ *
  * ## Two orderings, kept apart
  *
  * Simulate does NOT read the alive list. It reads `sim_list`, the program-coherent indirection list
@@ -60,7 +69,8 @@
  * @property {number} counters the atomic counters, after build-indirect
  * @property {number} draw_args the billboard draw's indirect args: six vertices, one instance per live particle
  * @property {number} sim_dispatch_args one workgroup per live particle, for a per-particle pass
- * @property {number} emitter_database the emitter database, after the tick wrote its state rows
+ * @property {number} emitter_database the emitter database, after the bounds pass published the
+ *   measured box into each emitter's state row
  */
 /**
  * Everything that moves particles, up to the indirect args a draw consumes.
@@ -84,8 +94,15 @@
  * @param {number} params.frame.dt
  * @param {number} params.frame.time
  * @param {number} params.frame.index
+ * @param {boolean} [params.frame.rebucket] program assignments changed since the previous frame
  * @param {number} params.frame.max_catchup seconds of missed spawning a woken emitter makes up
  * @param {number} params.frame.spawn_command_count entries in `gpu.spawn_commands` this frame
+ * @param {number} params.frame.warmup_count entries in `gpu.warmup_queue` this frame — emitters
+ *   registered this frame with a pre-warm; zero on nearly every frame, and the warm-up is not
+ *   recorded then
+ * @param {number} params.frame.warmup_capacity slots the warm-up's transient pool needs
+ * @param {import("./warmup/warmup_schedule.js").WarmupSchedule} params.frame.warmup_schedule how
+ *   many ticks the warm-up runs and how long each is
  * @returns {ParticleSimulationHandles}
  */
 export function graph_particles_simulate({ graph, camera, scene_database, gpu, emitters, capacity, bucket_count, wide_registers, frame, }: {
@@ -104,8 +121,12 @@ export function graph_particles_simulate({ graph, camera, scene_database, gpu, e
         dt: number;
         time: number;
         index: number;
+        rebucket?: boolean;
         max_catchup: number;
         spawn_command_count: number;
+        warmup_count: number;
+        warmup_capacity: number;
+        warmup_schedule: import("./warmup/warmup_schedule.js").WarmupSchedule;
     };
 }): ParticleSimulationHandles;
 export type ParticleSimulationHandles = {
@@ -130,7 +151,8 @@ export type ParticleSimulationHandles = {
      */
     sim_dispatch_args: number;
     /**
-     * the emitter database, after the tick wrote its state rows
+     * the emitter database, after the bounds pass published the
+     * measured box into each emitter's state row
      */
     emitter_database: number;
 };

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":"AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAtBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IACS,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;QACe,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;;IACJ,yBAAyB,CA8OrC;;;;;UA9Qa,MAAM;;;;WACN,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;uBACN,MAAM;;;;sBACN,MAAM"}
+{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA7BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IACS,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,CAuTrC;;;;;UA/Va,MAAM;;;;WACN,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;uBACN,MAAM;;;;;sBACN,MAAM"}

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

@@ -1,13 +1,14 @@
 import { assert } from "../../../core/assert.js";
 import { align_4 } from "../../../core/binary/align_4.js";
-import { noop } from "../../../core/function/noop.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_particle_bounds } from "./bounds/graph_particle_bounds.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_SIMULATE_WORKGROUP_SIZE,
@@ -34,6 +35,7 @@ import {
     PARTICLE_SPAWN_COMMAND_WORKGROUP_SIZE,
     shader_particle_spawn_commands,
 } from "./shaders/shader_particle_spawn_commands.js";
+import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
 
 /**
  * The simulation half of the particle system's frame, recorded into the frame graph.
@@ -43,7 +45,7 @@ import {
  * {@link graph_particles_simulate} is everything that moves particles:
  *
  *   reset counters -> spawn commands -> emitter tick -> scan -> spawn args -> emit -> simulate
- *   -> bucket -> build indirect
+ *   -> bucket -> bounds -> build indirect
  *
  * and it leaves the frame's alive list, the pool and the indirect draw args as graph handles for
  * whoever draws. Nothing here depends on how they will be drawn, which is why the render mode
@@ -61,6 +63,15 @@ import {
  * the scan, and the length of the spawn-command list it authored itself. Neither is a count of
  * anything alive.
  *
+ * ## Bounds are measured at the end, not carried along
+ *
+ * An emitter has no bounds an author could state — its particles are simulated in world space by
+ * arbitrary bytecode — so the box the culling and occupancy passes use is measured from the live
+ * particles, by `bounds/`, once emit and simulate have both finished appending. Measuring it there
+ * rather than inside those two passes is what makes it a box over ONE population: a merge folded
+ * into emit and simulate would union this frame's newborns with last frame's survivors, and would
+ * pay six atomics per particle inside the pass whose register pressure sets the system's occupancy.
+ *
  * ## Two orderings, kept apart
  *
  * Simulate does NOT read the alive list. It reads `sim_list`, the program-coherent indirection list
@@ -98,7 +109,8 @@ import {
  * @property {number} counters the atomic counters, after build-indirect
  * @property {number} draw_args the billboard draw's indirect args: six vertices, one instance per live particle
  * @property {number} sim_dispatch_args one workgroup per live particle, for a per-particle pass
- * @property {number} emitter_database the emitter database, after the tick wrote its state rows
+ * @property {number} emitter_database the emitter database, after the bounds pass published the
+ *   measured box into each emitter's state row
  */
 
 /**
@@ -122,9 +134,16 @@ import {
  * @param {object} params.frame per-frame scalars
  * @param {number} params.frame.dt
  * @param {number} params.frame.time
- * @param {number} params.frame.index
+ * @param {number} params.frame.index
+ * @param {boolean} [params.frame.rebucket] program assignments changed since the previous frame
  * @param {number} params.frame.max_catchup seconds of missed spawning a woken emitter makes up
  * @param {number} params.frame.spawn_command_count entries in `gpu.spawn_commands` this frame
+ * @param {number} params.frame.warmup_count entries in `gpu.warmup_queue` this frame — emitters
+ *   registered this frame with a pre-warm; zero on nearly every frame, and the warm-up is not
+ *   recorded then
+ * @param {number} params.frame.warmup_capacity slots the warm-up's transient pool needs
+ * @param {import("./warmup/warmup_schedule.js").WarmupSchedule} params.frame.warmup_schedule how
+ *   many ticks the warm-up runs and how long each is
  * @returns {ParticleSimulationHandles}
  */
 export function graph_particles_simulate({
@@ -144,9 +163,9 @@ export function graph_particles_simulate({
     assert.isPositiveInteger(capacity, "capacity");
 
     const gr_program = graph_import_buffer(graph, gpu.program, "particles/program");
-    const gr_sim_list = graph_import_buffer(graph, gpu.sim_list, "particles/sim_list");
-    const gr_dispatch = graph_import_buffer(graph, gpu.dispatch_args, "particles/dispatch_args");
-    const gr_draw = graph_import_buffer(graph, gpu.draw_args, "particles/draw_args");
+    let gr_sim_list = graph_import_buffer(graph, gpu.sim_list, "particles/sim_list");
+    let gr_dispatch = graph_import_buffer(graph, gpu.dispatch_args, "particles/dispatch_args");
+    let gr_draw = graph_import_buffer(graph, gpu.draw_args, "particles/draw_args");
 
     // Buffers mutated by more than one pass must be THREADED: each compute pass writing an imported
     // buffer returns a renamed (versioned) handle, and the next pass must read THAT handle — reading
@@ -158,7 +177,32 @@ export function graph_particles_simulate({
     // Two tables in one buffer — the emitter records the CPU authors and the state the GPU
     // integrates — so the passes that write the state rename the handle every reader after them
     // takes.
-    let emitter_database = graph_import_buffer(graph, gpu.emitter_database, "particles/emitter_database");
+    let emitter_database = graph_import_buffer(graph, gpu.emitter_database, "particles/emitter_database");
+
+    /** @type {import("./coherence/graph_particle_bucket.js").ParticleBucketScratch|undefined} */
+    let bucket_scratch;
+    if (frame.rebucket) {
+        // Live program edits can split a previously uniform wave. Rebuild from the previous
+        // compact alive list BEFORE reset discards its count and before simulate broadcasts code.
+        const bucketed = graph_particle_bucket({
+            graph, gpu, emitter_database, pool, counters, bucket_count,
+            alive: graph_import_buffer(graph, gpu.alive_read, "particles/alive_read"),
+            sim_list: gr_sim_list,
+        });
+        gr_sim_list = bucketed.sim_list;
+        bucket_scratch = bucketed.scratch;
+        const indirect = graph_compute_pass({
+            graph, shader: shader_particle_build_indirect,
+            bindings: {
+                counters: bucketed.counters, dispatch_args: gr_dispatch, draw_args: gr_draw,
+                u_workgroup_size: PARTICLE_SIMULATE_WORKGROUP_SIZE,
+            },
+            group_count: [1, 1, 1],
+        });
+        counters = indirect.counters;
+        gr_dispatch = indirect.dispatch_args;
+        gr_draw = indirect.draw_args;
+    }
 
     // 1. Reset the alive/sorted/sim-padded counters (dead count + ALIVE_IN snapshot persist) and
     //    seed the frame's spawn budget from the free count.
@@ -188,7 +232,7 @@ export function graph_particles_simulate({
     const count_words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(Math.max(1, emitters.capacity));
     const count_bytes = count_words * Uint32Array.BYTES_PER_ELEMENT;
 
-    let spawn_counts = create_buffer(graph, "particles/spawn_counts", BufferResourceDescriptor.from(
+    let spawn_counts = graph_create_buffer(graph, "particles/spawn_counts", BufferResourceDescriptor.from(
         count_bytes,
         GPUBufferUsage.STORAGE,
         0, count_bytes,
@@ -203,7 +247,6 @@ export function graph_particles_simulate({
             shader: shader_particle_emitter_tick,
             bindings: {
                 camera,
-                scene_database,
                 emitter_database,
                 counters,
                 spawn_counts,
@@ -237,7 +280,7 @@ export function graph_particles_simulate({
     // Emit and simulate share it. They cannot overlap (simulate reads the alive list emit appends
     // to), and the file carries nothing between particles, let alone between passes.
     let vm_registers = wide_registers
-        ? create_buffer(graph, "particles/vm_registers", BufferResourceDescriptor.from(
+        ? graph_create_buffer(graph, "particles/vm_registers", BufferResourceDescriptor.from(
             PARTICLE_VM_WIDE_LAUNCH_LANES * PARTICLE_VM_REGISTER_SLOTS * 4,
             GPUBufferUsage.STORAGE,
         ))
@@ -249,7 +292,7 @@ export function graph_particles_simulate({
         shader: shader_prefix_sum_to_command,
         bindings: {
             prefix_sums: spawn_prefix,
-            command: create_buffer(graph, "particles/emit_command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR),
+            command: graph_create_buffer(graph, "particles/emit_command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR),
         },
         group_count: [1, 1, 1],
     }).command;
@@ -325,6 +368,36 @@ export function graph_particles_simulate({
         pool = out.pool; alive_write = out.alive_out; dead = out.dead; counters = out.counters;
     }
 
+    // 7b. Warm-up — on a frame that registered emitters with a pre-warm, and only then: run their
+    //     simulations forward over a transient population of their own and move what survives into
+    //     the main pool. A pipeline apart from the one above, sharing its emit pass and nothing else;
+    //     see `warmup/graph_particle_warmup.js`. After simulate so the frame's own work is done
+    //     first, before the bucketing so the warmed particles are in next frame's list, measured by
+    //     this frame's bounds pass and drawn by this frame's draw.
+    if (frame.warmup_count > 0) {
+        const out = graph_particle_warmup({
+            graph,
+            scene_database,
+            emitter_database,
+            program: gr_program,
+            pool, alive_out: alive_write, dead, counters,
+            vm_registers,
+            queue: gpu.warmup_queue,
+            queue_count: frame.warmup_count,
+            warm_capacity: frame.warmup_capacity,
+            capacity,
+            emitter_capacity: emitters.capacity,
+            schedule: frame.warmup_schedule,
+            wide_registers,
+            frame,
+        });
+
+        pool = out.pool; alive_write = out.alive_out; dead = out.dead; counters = out.counters;
+        emitter_database = out.emitter_database;
+
+        if (wide_registers) { vm_registers = out.vm_registers; }
+    }
+
     // 8. Bucket — regroup the frame's alive list by VM program, padded to whole workgroups, into the
     //    list NEXT frame's simulate consumes. Must follow BOTH emit and simulate, since both append
     //    to the alive list.
@@ -338,13 +411,32 @@ export function graph_particles_simulate({
         pool,
         alive: alive_write,
         counters,
-        sim_list: gr_sim_list,
-        bucket_count,
+        sim_list: gr_sim_list,
+        bucket_count,
+        scratch: bucket_scratch,
     });
     counters = bucketed.counters;
 
-    // 9. Snapshot the padded list length (next frame's simulate input length) and build the indirect
-    //    dispatch args for next frame + the indirect draw args for this frame's render.
+    // 9. Measure every emitter's bounding box from the alive list, and publish it into the state
+    //    rows the tick and the AVBOIT occupancy read. After the bucketing because the dispatch is
+    //    the one the coherence reset sized from the GPU's own alive count.
+    {
+        const out = graph_particle_bounds({
+            graph,
+            emitter_database,
+            pool,
+            alive: alive_write,
+            counters,
+            dispatch_args: bucketed.dispatch_args,
+            emitter_group_count: emitters.group_count,
+        });
+
+        counters = out.counters;
+        emitter_database = out.emitter_database;
+    }
+
+    // 10. Snapshot the padded list length (next frame's simulate input length) and build the indirect
+    //     dispatch args for next frame + the indirect draw args for this frame's render.
     const indirect = graph_compute_pass({
         graph,
         shader: shader_particle_build_indirect,
@@ -365,18 +457,3 @@ export function graph_particles_simulate({
     };
 }
 
-/**
- * A transient buffer with no producing pass of its own, for a binding a shader both reads and
- * writes — the compute pass helpers create a buffer only for write-only bindings, and a
- * read-write one wants a handle.
- *
- * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} graph
- * @param {string} label
- * @param {BufferResourceDescriptor} descriptor
- * @returns {number}
- */
-function create_buffer(graph, label, descriptor) {
-    const pass = graph.add(`${label} / create`, {}, noop);
-
-    return pass.create(label, descriptor);
-}

package/src/shade/renderer/particles/graph_particles_avboit.d.ts

@@ -1,22 +1,24 @@
 /**
- * Mark the depth slices the emitters' bounds spheres span (`shader_particle_avboit_occupancy`).
+ * Mark the depth slices the emitters' measured bounding boxes span
+ * (`shader_particle_avboit_occupancy`).
+ *
+ * The boxes are world-space and live in the emitter state table, so there is no scene database here:
+ * the tick already resolved every emitter's node when it published them.
  *
  * @param {object} params
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
  * @param {number} params.camera graph handle
  * @param {ArrayLike<number>} params.cluster_parameters the frame's depth curve
  * @param {number} params.occupancy graph handle of the occupancy bits, to add to
- * @param {number} params.scene_database graph handle
  * @param {number} params.emitter_database graph handle, as the simulation left it
  * @param {number} params.emitter_group_count workgroups that walk every page group of the emitter table
  * @returns {number} the occupancy handle after the write
  */
-export function graph_particle_avboit_occupancy({ graph, camera, cluster_parameters, occupancy, scene_database, emitter_database, emitter_group_count, }: {
+export function graph_particle_avboit_occupancy({ graph, camera, cluster_parameters, occupancy, emitter_database, emitter_group_count, }: {
     graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     camera: number;
     cluster_parameters: ArrayLike<number>;
     occupancy: number;
-    scene_database: number;
     emitter_database: number;
     emitter_group_count: number;
 }): number;

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

@@ -1 +1 @@
-{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;GAYG;AACH;IATkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CAiDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAjBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAoG/E"}
+{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAjBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAoG/E"}

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

@@ -36,14 +36,17 @@ const COLOR_VIEW = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel:
 const SAMPLER_LINEAR = SamplerDescriptor.from({ magFilter: "linear" });
 
 /**
- * Mark the depth slices the emitters' bounds spheres span (`shader_particle_avboit_occupancy`).
+ * Mark the depth slices the emitters' measured bounding boxes span
+ * (`shader_particle_avboit_occupancy`).
+ *
+ * The boxes are world-space and live in the emitter state table, so there is no scene database here:
+ * the tick already resolved every emitter's node when it published them.
  *
  * @param {object} params
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
  * @param {number} params.camera graph handle
  * @param {ArrayLike<number>} params.cluster_parameters the frame's depth curve
  * @param {number} params.occupancy graph handle of the occupancy bits, to add to
- * @param {number} params.scene_database graph handle
  * @param {number} params.emitter_database graph handle, as the simulation left it
  * @param {number} params.emitter_group_count workgroups that walk every page group of the emitter table
  * @returns {number} the occupancy handle after the write
@@ -53,7 +56,6 @@ export function graph_particle_avboit_occupancy({
                                                     camera,
                                                     cluster_parameters,
                                                     occupancy,
-                                                    scene_database,
                                                     emitter_database,
                                                     emitter_group_count,
                                                 }) {
@@ -75,7 +77,6 @@ export function graph_particle_avboit_occupancy({
             bindings: {
                 camera: resources.get(data.camera),
                 settings: encoder.allocateTransientValueBuffer(AVBOIT_OCCUPANCY_SETTINGS_STRUCT, settings, GPUBufferUsage.UNIFORM),
-                scene_database: resources.get(data.scene_database),
                 emitter_database: resources.get(data.emitter_database),
                 occupancy: resources.get(data.occupancy),
             },
@@ -89,7 +90,6 @@ export function graph_particle_avboit_occupancy({
     const pass = graph.add("Particle AVBOIT Occupancy", pass_data, execute);
 
     pass_data.camera = pass.read(camera);
-    pass_data.scene_database = pass.read(scene_database);
     pass_data.emitter_database = pass.read(emitter_database);
     pass.read(occupancy);
     pass_data.occupancy = pass.write(occupancy);

package/src/shade/renderer/particles/runtime/EmitterRegistry.d.ts

@@ -42,6 +42,11 @@ export class EmitterRegistry {
      * @type {ProgramHeap}
      */
     programs: ProgramHeap;
+    /**
+     * Changes when a live emitter moves to different bytecode; invalidates simulation grouping.
+     * @type {number}
+     */
+    program_assignment_version: number;
     /**
      * The live emitters, in no particular order — the row in {@link context} is the identity.
      * @type {ParticleEmitter[]}

package/src/shade/renderer/particles/runtime/EmitterRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EmitterRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/EmitterRegistry.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAwEI;;OAEG;IACH,+BASC;IAlFD;;OAEG;IACH,UAFU,WAAW,CAEZ;IAET;;;OAGG;IACH,UAFU,WAAW,CAEQ;IAE7B;;;OAGG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;;;;OAKG;IACH,QAFU,eAAe,EAAE,CAEf;IAEZ;;;;;;;;;;OAUG;IACH,8BAEC;IA8CD;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,iCAEC;IAED;;OAEG;IACH,oBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;OAOG;IACH,iCAEC;IAED;;;;;;;;;OASG;IACH,iBAHW,eAAe,GACb,yBAAyB,GAAC,SAAS,CAI/C;IAED;;;;;;;;OAQG;IACH,YANW,eAAe,GAAC,MAAM,kBAEtB,MAAM,GAEJ,eAAe,CA8B3B;IAED;;;;;;;;;;;;;OAaG;IACH,gBAFW,eAAe,QA4BzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAHW,eAAe,WACf,OAAO,2BAA2B,EAAE,eAAe,QAqB7D;IAED;;;;;OAKG;IACH,SAHW,MAAM,GACJ,eAAe,GAAC,SAAS,CAIrC;IAED;;;;;;OAMG;IACH,2BAHW,eAAe,iBACf,MAAM,QAehB;IAED;;;;;;;;;OASG;IACH,0BAHW,eAAe,UACf,UAAU,MAAM,CAAC,QAoB3B;IAED;;;;;;;;;;;;;OAaG;IACH,cAoBC;IAED;;;;;;;;;OASG;IACH,iBAFa,WAAW,CAMvB;;CACJ;4BApb2B,mCAAmC;4BAYnC,kBAAkB;gCADd,sBAAsB;0CADZ,gCAAgC"}
+{"version":3,"file":"EmitterRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/EmitterRegistry.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IA8EI;;OAEG;IACH,+BASC;IAxFD;;OAEG;IACH,UAFU,WAAW,CAEZ;IAET;;;OAGG;IACH,UAFU,WAAW,CAEQ;IAE7B;;;OAGG;IACH,4BAFU,MAAM,CAEe;IAE/B;;;OAGG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;;;;OAKG;IACH,QAFU,eAAe,EAAE,CAEf;IAEZ;;;;;;;;;;OAUG;IACH,8BAEC;IA8CD;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,iCAEC;IAED;;OAEG;IACH,oBAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;;;OAKG;IACH,kCAEC;IAED;;;;;;;OAOG;IACH,iCAEC;IAED;;;;;;;;;OASG;IACH,iBAHW,eAAe,GACb,yBAAyB,GAAC,SAAS,CAI/C;IAED;;;;;;;;OAQG;IACH,YANW,eAAe,GAAC,MAAM,kBAEtB,MAAM,GAEJ,eAAe,CA+B3B;IAED;;;;;;;;;;;;;OAaG;IACH,gBAFW,eAAe,QA6BzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAHW,eAAe,WACf,OAAO,2BAA2B,EAAE,eAAe,QA0B7D;IAED;;;;;OAKG;IACH,SAHW,MAAM,GACJ,eAAe,GAAC,SAAS,CAIrC;IAED;;;;;;OAMG;IACH,2BAHW,eAAe,iBACf,MAAM,QAehB;IAED;;;;;;;;;OASG;IACH,0BAHW,eAAe,UACf,UAAU,MAAM,CAAC,QAoB3B;IAED;;;;;;;;;;;;;OAaG;IACH,cA4BC;IAED;;;;;;;;;OASG;IACH,iBAFa,WAAW,CAMvB;;CACJ;4BAzc2B,mCAAmC;4BAYnC,kBAAkB;gCADd,sBAAsB;0CADZ,gCAAgC"}

package/src/shade/renderer/particles/runtime/EmitterRegistry.js

@@ -61,7 +61,13 @@ export class EmitterRegistry {
      * Packed instruction + constant buffers for every distinct program in the set.
      * @type {ProgramHeap}
      */
-    programs = new ProgramHeap();
+    programs = new ProgramHeap();
+
+    /**
+     * Changes when a live emitter moves to different bytecode; invalidates simulation grouping.
+     * @type {number}
+     */
+    program_assignment_version = 0;
 
     /**
      * The live emitters, in no particular order — the row in {@link context} is the identity.
@@ -220,7 +226,8 @@ export class EmitterRegistry {
 
         const context = new GPUParticleEmitterContext();
 
-        context.placement = this.programs.acquire(emitter.program);
+        context.placement = this.programs.acquire(emitter.program);
+        context.program = emitter.program;
 
         context.generation = this.#generation;
         this.#generation = particle_generation_next(this.#generation);
@@ -280,7 +287,8 @@ export class EmitterRegistry {
 
         this.programs.release(context.placement);
 
-        context.placement = null;
+        context.placement = null;
+        context.program = null;
 
         this.#contexts.delete(emitter);
     }
@@ -315,7 +323,12 @@ export class EmitterRegistry {
         // unpacks it nor gives it a new id
         context.placement = this.programs.acquire(program);
 
-        emitter.program = program;
+        emitter.program = program;
+        context.program = program;
+
+        if (context.placement !== previous) {
+            this.program_assignment_version++;
+        }
 
         this.programs.release(previous);
 
@@ -398,8 +411,16 @@ export class EmitterRegistry {
      * Stages through the one module-static record, so a frame's restaging allocates nothing however
      * many rows it touches.
      */
-    flush() {
-        const table = this.table;
+    flush() {
+        const table = this.table;
+
+        // Reconcile plain-field edits before checking relocation: an acquire can repack the heap
+        // and move placements of rows we would otherwise have already staged.
+        for (const [emitter, context] of this.#contexts) {
+            if (emitter.program !== context.program) {
+                this.set_program(emitter, emitter.program);
+            }
+        }
 
         const placement_version = this.programs.placement_version;
 

package/src/shade/renderer/particles/runtime/GPUParticleEmitterContext.d.ts

@@ -56,6 +56,10 @@ export class GPUParticleEmitterContext {
      * @type {import("./ProgramPlacement.js").ProgramPlacement|null}
      */
     placement: import("./ProgramPlacement.js").ProgramPlacement | null;
+    /** Author's immutable program reference, distinct from the heap's owned copy.
+     * @type {import("../isa/ParticleProgram.js").ParticleProgram|null}
+     */
+    program: import("../isa/ParticleProgram.js").ParticleProgram | null;
     /**
      * Where {@link ./ParticleEmitter.js#texture} landed in the particle system's atlas: uv offset
      * `.xy`, uv scale `.zw`. Mirrors meep's `AtlasPatch`.

package/src/shade/renderer/particles/runtime/GPUParticleEmitterContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUParticleEmitterContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/GPUParticleEmitterContext.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAEI;;;;;;;;;OASG;IACH,KAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;OAMG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;;OAOG;IACH,WAFU,OAAO,uBAAuB,EAAE,gBAAgB,GAAC,IAAI,CAE9C;IAEjB;;;;;;;;;;OAUG;IACH,cAFU,YAAY,CAEwB;IAE9C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,kBAHW,OAAO,sBAAsB,EAAE,eAAe,GAC5C,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;IAED;;;;OAIG;IACH,gBAFW,OAAO,sBAAsB,EAAE,eAAe,QAMxD;CACJ"}
+{"version":3,"file":"GPUParticleEmitterContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/GPUParticleEmitterContext.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAEI;;;;;;;;;OASG;IACH,KAFU,MAAM,CAEP;IAET;;;;;;OAMG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;OAMG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;;OAOG;IACH,WAFU,OAAO,uBAAuB,EAAE,gBAAgB,GAAC,IAAI,CAE9C;IAEjB;;OAEG;IACH,SAFU,OAAO,2BAA2B,EAAE,eAAe,GAAC,IAAI,CAEnD;IAEf;;;;;;;;;;OAUG;IACH,cAFU,YAAY,CAEwB;IAE9C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,kBAHW,OAAO,sBAAsB,EAAE,eAAe,GAC5C,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;IAED;;;;OAIG;IACH,gBAFW,OAAO,sBAAsB,EAAE,eAAe,QAMxD;CACJ"}

package/src/shade/renderer/particles/runtime/GPUParticleEmitterContext.js

@@ -61,7 +61,12 @@ export class GPUParticleEmitterContext {
      *
      * @type {import("./ProgramPlacement.js").ProgramPlacement|null}
      */
-    placement = null;
+    placement = null;
+
+    /** Author's immutable program reference, distinct from the heap's owned copy.
+     * @type {import("../isa/ParticleProgram.js").ParticleProgram|null}
+     */
+    program = null;
 
     /**
      * Where {@link ./ParticleEmitter.js#texture} landed in the particle system's atlas: uv offset