@woosh/meep-engine 3.15.0 → 3.17.0

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

@@ -1,27 +1,65 @@
+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_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_import_buffer } from "../shader/graph/graph_import_buffer.js";
-import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "./ParticleConstants.js";
+import {
+    PARTICLE_SIMULATE_WORKGROUP_SIZE,
+    PARTICLE_VM_REGISTER_SLOTS,
+    PARTICLE_VM_WIDE_LAUNCH_LANES,
+} from "./ParticleConstants.js";
 import { graph_particle_bucket } from "./coherence/graph_particle_bucket.js";
-import { PARTICLE_EMIT_WORKGROUP_SIZE, shader_particle_emit } from "./shaders/shader_particle_emit.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 { shader_particle_emitter_tick } from "./shaders/shader_particle_emitter_tick.js";
 import {
     shader_particle_build_indirect,
     shader_particle_reset_counters,
 } from "./shaders/shader_particle_finalize.js";
 import { shader_particle_simulate } from "./shaders/shader_particle_simulate.js";
+import {
+    PARTICLE_SIMULATE_WIDE_WORKGROUP_COUNT,
+    shader_particle_simulate_wide,
+} from "./shaders/shader_particle_simulate_wide.js";
+import {
+    PARTICLE_SPAWN_COMMAND_WORKGROUP_SIZE,
+    shader_particle_spawn_commands,
+} from "./shaders/shader_particle_spawn_commands.js";
 
 /**
- * Per-frame frame-graph contribution for the GPU particle system — the reference wiring an
- * integrator (e.g. Renderer.render) calls once the CPU {@link GPUParticleSystem#update} has produced
- * this frame's spawn requests.
+ * The simulation half of the particle system's frame, recorded into the frame graph.
+ * {@link GPUParticleSystem#execute} is what calls it, with the buffers it owns; nothing else needs
+ * to.
  *
- * The passes run in dependency order:
+ * {@link graph_particles_simulate} is everything that moves particles:
  *
- *   reset counters -> emit (spawn) -> simulate (advance + compact) -> bucket -> build indirect args
+ *   reset counters -> spawn commands -> emitter tick -> scan -> spawn args -> emit -> simulate
+ *   -> bucket -> build indirect
  *
- * with the depth sort + billboard render appended by the caller (the render pass needs the frame's
- * colour + depth attachments, which live in the caller's graph). Alive lists ping-pong by frame
- * parity: `alive_write` receives this frame's survivors + newborns.
+ * 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
+ * ({@link ParticleRenderMode}) selects only what `execute` records AFTER this: the depth sort and
+ * the billboard draw (`sort/graph_particle_sort.js`, `graph_particles_billboard.js`), or nothing at
+ * all, because the AVBOIT orchestrator will draw them later off these same handles
+ * (`graph_particles_avboit.js`).
+ *
+ * ## Spawning is decided here, on the GPU
+ *
+ * The emitter tick runs one thread per emitter row and writes each row's spawn count for the
+ * frame; a prefix scan turns the counts into offsets; a one-thread pass turns the scan's total into
+ * the emit dispatch; and the emit pass runs one thread per newborn, each locating its emitter in the
+ * scan. The host contributes two numbers to all of that: the table's element capacity, which sizes
+ * the scan, and the length of the spawn-command list it authored itself. Neither is a count of
+ * anything alive.
  *
  * ## Two orderings, kept apart
  *
@@ -31,62 +69,82 @@ import { shader_particle_simulate } from "./shaders/shader_particle_simulate.js"
  * ordering is camera-independent and changes only when emitters or their programs change.
  *
  * The RENDER ordering — back-to-front by view depth, from `sort/` — is a different list in a
- * different buffer, produced by different passes, and the billboard draw is what consumes it.
- * Reordering the render list for coherence would break premultiplied transparency; depth-sorting the
- * simulation list would destroy the coherence. They share no buffer and no counter slot.
+ * different buffer, produced by different passes, and the standalone billboard draw is the only
+ * thing that consumes it, so it is built only in that mode. Reordering the render list for
+ * coherence would break premultiplied transparency; depth-sorting the simulation list would destroy
+ * the coherence. They share no buffer and no counter slot.
+ *
+ * ## Nothing is sized from the CPU
  *
- * The simulate pass is fully GPU-driven: its workgroup count comes from `dispatch_args` (written by
- * LAST frame's build-indirect pass) via `dispatchWorkgroupsIndirect`, and its element bound comes
- * from the `ALIVE_IN` counter snapshot — never from a CPU count. Both are derived from one value,
- * the padded list length, so the thread count and the bound agree by construction. A CPU count is
- * inevitably stale and corrupts the pool (orphaned slots when the population grows, double-freed
- * slots when it shrinks). Only the spawn count is CPU-provided, because the CPU authored the
- * spawn-request list and knows its exact length. The caller renders with `drawIndirect(draw_args)`,
- * which build-indirect writes THIS frame, so the instance count is exact too.
+ * Simulate's workgroup count comes from `dispatch_args` (written by LAST frame's build-indirect
+ * pass) via `dispatchWorkgroupsIndirect`, and its element bound from the `ALIVE_IN` counter
+ * snapshot; the draw, and the sort's two per-particle passes when there is a sort, are sized the
+ * same way, from this frame's alive count. A CPU count is inevitably stale and corrupts the pool
+ * (orphaned slots when the population grows, double-freed slots when it shrinks).
  *
  * All persistent buffers are imported (owned by the feature, not the graph). Writing an imported
  * buffer marks the pass a side-effect so it always executes, and returns a renamed handle downstream
- * passes must read — exactly the ReSTIR reservoir pattern.
+ * passes must read — exactly the ReSTIR reservoir pattern. Every persistent buffer is imported
+ * exactly once: two imports of one buffer are two resource entries the graph cannot tell apart.
  *
  * On the very first frame `dispatch_args` must be zero-initialised (WebGPU zero-fills new buffers)
  * and the `ALIVE_IN` counter 0, so simulate is a no-op until the first build-indirect has run.
+ */
+
+/**
+ * @typedef {object} ParticleSimulationHandles
+ * @property {number} pool the particle pool, after this frame's INIT and UPDATE
+ * @property {number} alive this frame's compacted alive list — the render order's input
+ * @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
+ */
+
+/**
+ * Everything that moves particles, up to the indirect args a draw consumes.
  *
  * @param {object} params
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {object} params.gpu handles/objects for the persistent buffers (GPUBuffer instances)
- * @param {GPUBuffer} params.gpu.emitters
- * @param {GPUBuffer} params.gpu.program
- * @param {GPUBuffer} params.gpu.constants
- * @param {GPUBuffer} params.gpu.pool
- * @param {GPUBuffer} params.gpu.alive_read the other half of the ping-pong. These passes no longer
- *   read it — simulate's input is `sim_list` — but the caller keeps swapping the two so this frame's
- *   render is not read-after-written by next frame's emit, which would serialise them
- * @param {GPUBuffer} params.gpu.alive_write this-frame alive list: survivors + newborns
- * @param {GPUBuffer} params.gpu.dead free-list stack
- * @param {GPUBuffer} params.gpu.counters atomic counters
- * @param {GPUBuffer} params.gpu.spawn_requests
- * @param {GPUBuffer} params.gpu.dispatch_args indirect simulate dispatch (usage must include INDIRECT)
- * @param {GPUBuffer} params.gpu.draw_args indirect billboard draw (usage must include INDIRECT)
- * @param {GPUBuffer} params.gpu.sim_list program-coherent simulate input, rebuilt here for next frame
- * @param {GPUBuffer} params.gpu.sim_keys see {@link graph_particle_bucket}
- * @param {GPUBuffer} params.gpu.sim_histogram see {@link graph_particle_bucket}
- * @param {GPUBuffer} params.gpu.sim_bucket_counts see {@link graph_particle_bucket}
- * @param {GPUBuffer} params.gpu.sim_cursor see {@link graph_particle_bucket}
- * @param {GPUBuffer} params.gpu.sim_dispatch_args see {@link graph_particle_bucket} (usage must include INDIRECT)
- * @param {number} params.capacity pool capacity in particles (bounds the emit pass's free-list pops)
- * @param {number} params.bucket_count distinct compiled programs — `GPUParticleSystem#bucketCount()`
+ * @param {number} params.camera graph handle of the view's camera uniform (`CAMERA_UNIFORM_STRUCT`)
+ * @param {number} params.scene_database graph handle of the scene database — the emitters' nodes
+ * @param {object} params.gpu the persistent buffers, see {@link GPUParticleSystem}
+ * @param {object} params.emitters the emitter table's shape this frame
+ * @param {number} params.emitters.capacity the table's element capacity — the length of the count
+ *   list the scan consumes
+ * @param {number} params.emitters.group_count workgroups the tick needs to walk every page group
+ * @param {number} params.capacity pool capacity in particles
+ * @param {number} params.bucket_count simulation-order buckets, one per program id the registry
+ *   can hand out — `GPUParticleSystem#bucketCount()`
+ * @param {boolean} params.wide_registers run the VM over the wide (storage-backed) register file
+ *   because some registered effect needs more slots than the fast interpreter's file holds. A
+ *   whole-system choice, not a per-emitter one — see `runtime/ProgramHeap.js`.
  * @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.spawn_count number of spawn requests this frame (CPU-authored, exact)
+ * @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
+ * @returns {ParticleSimulationHandles}
  */
-export function graph_particles({ graph, gpu, capacity, bucket_count, frame }) {
-    const gr_emitters = graph_import_buffer(graph, gpu.emitters, "particles/emitters");
+export function graph_particles_simulate({
+                                             graph,
+                                             camera,
+                                             scene_database,
+                                             gpu,
+                                             emitters,
+                                             capacity,
+                                             bucket_count,
+                                             wide_registers = false,
+                                             frame,
+                                         }) {
+    assert.defined(graph, "graph");
+    assert.isNonNegativeInteger(camera, "camera");
+    assert.isNonNegativeInteger(scene_database, "scene_database");
+    assert.isPositiveInteger(capacity, "capacity");
+
     const gr_program = graph_import_buffer(graph, gpu.program, "particles/program");
-    const gr_constants = graph_import_buffer(graph, gpu.constants, "particles/constants");
     const gr_sim_list = graph_import_buffer(graph, gpu.sim_list, "particles/sim_list");
-    const gr_spawn = graph_import_buffer(graph, gpu.spawn_requests, "particles/spawn_requests");
     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");
 
@@ -97,8 +155,13 @@ export function graph_particles({ graph, gpu, capacity, bucket_count, frame }) {
     let pool = graph_import_buffer(graph, gpu.pool, "particles/pool");
     let alive_write = graph_import_buffer(graph, gpu.alive_write, "particles/alive_write");
     let dead = graph_import_buffer(graph, gpu.dead, "particles/dead");
+    // 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");
 
-    // 1. Reset the alive/spawn/sorted/sim-padded counters (dead count + ALIVE_IN snapshot persist).
+    // 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.
     counters = graph_compute_pass({
         graph,
         shader: shader_particle_reset_counters,
@@ -106,61 +169,181 @@ export function graph_particles({ graph, gpu, capacity, bucket_count, frame }) {
         group_count: [1, 1, 1],
     }).counters;
 
-    // 2. Emit — one thread per spawn request. Newborns join the new alive list.
-    if (frame.spawn_count > 0) {
+    // 2. Spawn commands — the CPU's bursts, added to the emitters' pending spawns. The one dispatch
+    //    the host sizes, because the host wrote the list.
+    if (frame.spawn_command_count > 0) {
+        const gr_commands = graph_import_buffer(graph, gpu.spawn_commands, "particles/spawn_commands");
+
+        emitter_database = graph_compute_pass({
+            graph,
+            shader: shader_particle_spawn_commands,
+            bindings: { commands: gr_commands, emitter_database, u_count: frame.spawn_command_count },
+            group_count: [Math.ceil(frame.spawn_command_count / PARTICLE_SPAWN_COMMAND_WORKGROUP_SIZE), 1, 1],
+        }).emitter_database;
+    }
+
+    // 3. Emitter tick — one thread per emitter row: integrate the rate, cull, take from the budget,
+    //    and write the row's spawn count. The counts list is transient and cleared whole, because
+    //    the tick writes only the rows it visits.
+    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(
+        count_bytes,
+        GPUBufferUsage.STORAGE,
+        0, count_bytes,
+    ));
+
+    // A table with no pages has no rows to visit and nothing to write: the cleared counts scan to a
+    // total of zero and the emit dispatch is empty. (A dispatch of zero workgroups is refused
+    // upstream, so this is a skip rather than a no-op dispatch.)
+    if (emitters.group_count > 0) {
         const out = graph_compute_pass({
             graph,
-            shader: shader_particle_emit,
+            shader: shader_particle_emitter_tick,
             bindings: {
-                emitters: gr_emitters, program: gr_program, vm_constants: gr_constants,
-                pool, spawn_requests: gr_spawn, alive_out: alive_write, dead, counters,
+                camera,
+                scene_database,
+                emitter_database,
+                counters,
+                spawn_counts,
                 settings: {
-                    u_dt: frame.dt, u_time: frame.time, u_frame: frame.index,
-                    u_count: frame.spawn_count, u_capacity: capacity,
+                    u_dt: frame.dt,
+                    u_max_catchup: frame.max_catchup,
+                    u_capacity: capacity,
+                    u_emitter_capacity: emitters.capacity,
                 },
             },
-            group_count: [Math.ceil(frame.spawn_count / PARTICLE_EMIT_WORKGROUP_SIZE), 1, 1],
+            group_count: [emitters.group_count, 1, 1],
         });
+        emitter_database = out.emitter_database;
+        counters = out.counters;
+        spawn_counts = out.spawn_counts;
+    }
+
+    // 4. Inclusive prefix sums of the counts: each row's batch ends at its sum, and the last sum is
+    //    the number of particles born this frame.
+    const spawn_prefix = graph_prefix_scan_csdldf({
+        graph,
+        data: spawn_counts,
+        element_max_count: Math.max(1, emitters.capacity),
+    });
+
+    // The wide interpreter's register file: one column per launched lane, slot-major, sized by the
+    // launch and NOT by the pool. Transient and deliberately uncleared — a program reads a register
+    // only after writing it, so what the last user left is unreadable by construction. See
+    // `vm/chunk_particle_vm_registers_wide.js`.
+    //
+    // 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(
+            PARTICLE_VM_WIDE_LAUNCH_LANES * PARTICLE_VM_REGISTER_SLOTS * 4,
+            GPUBufferUsage.STORAGE,
+        ))
+        : -1;
+
+    // 5. That total, as the emit dispatch — the same one-thread pass that sizes meshlet expansion.
+    const emit_command = graph_compute_pass({
+        graph,
+        shader: shader_prefix_sum_to_command,
+        bindings: {
+            prefix_sums: spawn_prefix,
+            command: create_buffer(graph, "particles/emit_command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR),
+        },
+        group_count: [1, 1, 1],
+    }).command;
+
+    // 6. Emit — one thread per newborn, its emitter found in the scan. Newborns join the new alive
+    //    list.
+    //
+    //    The wide variant does not consume `emit_command`: its launch is a constant, and it reads
+    //    the scan's total in the shader as a loop bound instead. The command is still built above —
+    //    it costs one workgroup and keeps the pass graph the same shape either way.
+    {
+        const bindings = {
+            scene_database,
+            emitter_database,
+            program: gr_program,
+            spawn_prefix,
+            pool, alive_out: alive_write, dead, counters,
+            settings: { u_dt: frame.dt, u_time: frame.time, u_frame: frame.index, u_capacity: 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,
+            });
+
         pool = out.pool; alive_write = out.alive_out; dead = out.dead; counters = out.counters;
+
+        if (wide_registers) { vm_registers = out.vm_registers; }
     }
 
-    // 3. Simulate — one indirect dispatch runs every emitter's UPDATE over the program-coherent list
+    // 7. Simulate — one indirect dispatch runs every emitter's UPDATE over the program-coherent list
     //    the bucketing pass built LAST frame, compacting survivors into the new alive list and freed
     //    slots into the dead list. The workgroup count comes from last frame's dispatch_args and the
-    //    list itself from last frame's sim_list — both read here and re-written in steps 4 and 5,
+    //    list itself from last frame's sim_list — both read here and re-written in steps 8 and 9,
     //    with insertion order keeping the read before the write.
+    //
+    //    The wide variant ignores `gr_dispatch` for the same reason emit ignores its command: a
+    //    bounded launch with a grid-stride loop, so the register file is sized by a constant rather
+    //    than by the alive count. The list and its length are unchanged, and so is every guarantee
+    //    that comes from reading the length on the GPU.
     {
-        const out = graph_compute_indirect_pass({
-            graph,
-            shader: shader_particle_simulate,
-            bindings: {
-                emitters: gr_emitters, program: gr_program, vm_constants: gr_constants,
-                pool, sim_list: gr_sim_list, alive_out: alive_write, dead, counters,
-                settings: { u_dt: frame.dt, u_time: frame.time, u_frame: frame.index },
-            },
-            command: gr_dispatch,
-        });
+        const bindings = {
+            scene_database,
+            emitter_database,
+            program: gr_program,
+            pool, sim_list: gr_sim_list, alive_out: alive_write, dead, counters,
+            settings: { u_dt: frame.dt, u_time: frame.time, u_frame: frame.index },
+        };
+
+        const out = wide_registers
+            ? graph_compute_pass({
+                graph,
+                shader: shader_particle_simulate_wide,
+                bindings: { ...bindings, vm_registers },
+                group_count: [PARTICLE_SIMULATE_WIDE_WORKGROUP_COUNT, 1, 1],
+            })
+            : graph_compute_indirect_pass({
+                graph,
+                shader: shader_particle_simulate,
+                bindings,
+                command: gr_dispatch,
+            });
+
         pool = out.pool; alive_write = out.alive_out; dead = out.dead; counters = out.counters;
     }
 
-    // 4. Bucket — regroup the frame's alive list by VM program, padded to whole workgroups, into the
+    // 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.
     //    `gr_sim_list` is handed over rather than re-imported: two imports of one GPUBuffer are two
     //    resource entries the graph cannot tell apart, which would put simulate's read of the list
     //    and this pass's rewrite of it on unrelated dependency chains.
-    counters = graph_particle_bucket({
+    const bucketed = graph_particle_bucket({
         graph,
         gpu,
-        emitters: gr_emitters,
+        emitter_database,
         pool,
         alive: alive_write,
         counters,
         sim_list: gr_sim_list,
         bucket_count,
-    }).counters;
+    });
+    counters = bucketed.counters;
 
-    // 5. Snapshot the padded list length (next frame's simulate input length) and build the indirect
+    // 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.
     const indirect = graph_compute_pass({
         graph,
@@ -172,15 +355,28 @@ export function graph_particles({ graph, gpu, capacity, bucket_count, frame }) {
         group_count: [1, 1, 1],
     });
 
-    // The depth sort (graph_prefix_scan_csdldf-based) and the billboard render pass are appended by
-    // the caller, which owns the frame's colour + depth attachments; the render must use
-    // drawIndirect(gpu.draw_args). See sort/shader_particle_sort.js and
-    // shaders/shader_particle_render.js.
     return {
-        alive: alive_write,
         pool,
+        alive: alive_write,
         counters: indirect.counters,
-        dispatch_args: indirect.dispatch_args,
         draw_args: indirect.draw_args,
+        sim_dispatch_args: bucketed.dispatch_args,
+        emitter_database,
     };
 }
+
+/**
+ * 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

@@ -0,0 +1,107 @@
+/**
+ * Mark the depth slices the emitters' bounds spheres span (`shader_particle_avboit_occupancy`).
+ *
+ * @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, }: {
+    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;
+/**
+ * Splat the live particles' extinction into the voxel volume (`shader_particle_avboit_splat`).
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {number} params.camera graph handle
+ * @param {number} params.warp graph handle
+ * @param {{extinction: number, overflow: number, dummy: number}} params.volume the volume, to add to
+ * @param {GPUTextureView} params.atlas
+ * @param {GPUSampler} params.atlas_sampler
+ * @param {number} params.pool graph handle
+ * @param {number} params.alive graph handle of this frame's alive list
+ * @param {number} params.emitter_database graph handle
+ * @param {number} params.draw_args graph handle of the indirect draw args (six vertices, alive instances)
+ * @returns {{extinction: number, overflow: number, dummy: number}} the volume after the write
+ */
+export function graph_particle_avboit_splat({ graph, camera, warp, depth_texture, volume, atlas, atlas_sampler, pool, alive, emitter_database, draw_args, }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    camera: number;
+    warp: number;
+    volume: {
+        extinction: number;
+        overflow: number;
+        dummy: number;
+    };
+    atlas: GPUTextureView;
+    atlas_sampler: GPUSampler;
+    pool: number;
+    alive: number;
+    emitter_database: number;
+    draw_args: number;
+}): {
+    extinction: number;
+    overflow: number;
+    dummy: number;
+};
+/**
+ * Draw the live particles into the four accumulators (`shader_particle_avboit_draw`).
+ *
+ * @param {object} params
+ * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {import("../view/GPUViewContext.js").GPUViewContext} params.view_ctx
+ * @param {number} params.camera graph handle
+ * @param {number} params.depth_texture graph handle of the scene depth — tested and sampled, never written
+ * @param {number} params.warp graph handle
+ * @param {number} params.integral graph handle of the integral texture
+ * @param {number} params.volumetrics_lut graph handle
+ * @param {number} params.volumetrics_metadata graph handle
+ * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators to add to
+ * @param {GPUTextureView} params.atlas
+ * @param {GPUSampler} params.atlas_sampler
+ * @param {number} params.pool graph handle
+ * @param {number} params.alive graph handle of this frame's alive list
+ * @param {number} params.emitter_database graph handle
+ * @param {number} params.draw_args graph handle of the indirect draw args
+ * @returns {{color: number, norm: number, extinction: number, emission: number}} the accumulators after the draw
+ */
+export function graph_particle_avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators, atlas, atlas_sampler, pool, alive, emitter_database, draw_args, }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    view_ctx: import("../view/GPUViewContext.js").GPUViewContext;
+    camera: number;
+    depth_texture: number;
+    warp: number;
+    integral: number;
+    volumetrics_lut: number;
+    volumetrics_metadata: number;
+    accumulators: {
+        color: number;
+        norm: number;
+        extinction: number;
+        emission: number;
+    };
+    atlas: GPUTextureView;
+    atlas_sampler: GPUSampler;
+    pool: number;
+    alive: number;
+    emitter_database: number;
+    draw_args: number;
+}): {
+    color: number;
+    norm: number;
+    extinction: number;
+    emission: number;
+};
+//# sourceMappingURL=graph_particles_avboit.d.ts.map

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

@@ -0,0 +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"}