@woosh/meep-engine 3.16.0 → 3.17.0

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

@@ -1,17 +1,19 @@
 /**
- * The particle system's frame, recorded into the frame graph. {@link GPUParticleSystem} is what
- * calls these, with the buffers it owns; nothing else needs to.
+ * 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.
  *
- * Two halves. {@link graph_particles_simulate} is everything that moves particles:
+ * {@link graph_particles_simulate} is everything that moves particles:
  *
  *   reset counters -> spawn commands -> emitter tick -> scan -> spawn args -> emit -> simulate
  *   -> bucket -> build indirect
  *
  * and it leaves the frame's alive list, the pool and the indirect draw args as graph handles for
- * whoever draws. {@link graph_particles_render} is the standalone drawing: a depth sort and one
- * billboard draw straight over a colour target. Under the renderer the drawing is AVBOIT's instead
- * (`graph_particles_avboit.js`), which reads the same handles and needs no sort.
- * {@link graph_particles} is the two together, for a page with no transparency pipeline of its own.
+ * 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
  *
@@ -30,18 +32,18 @@
  * 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 standalone 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
  *
  * 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 sort's two per-particle passes and the draw 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).
+ * 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
@@ -73,7 +75,11 @@
  *   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 distinct compiled programs — `GPUParticleSystem#bucketCount()`
+ * @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
@@ -82,7 +88,7 @@
  * @param {number} params.frame.spawn_command_count entries in `gpu.spawn_commands` this frame
  * @returns {ParticleSimulationHandles}
  */
-export function graph_particles_simulate({ graph, camera, scene_database, gpu, emitters, capacity, bucket_count, frame, }: {
+export function graph_particles_simulate({ graph, camera, scene_database, gpu, emitters, capacity, bucket_count, wide_registers, frame, }: {
     graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     camera: number;
     scene_database: number;
@@ -93,6 +99,7 @@ export function graph_particles_simulate({ graph, camera, scene_database, gpu, e
     };
     capacity: number;
     bucket_count: number;
+    wide_registers: boolean;
     frame: {
         dt: number;
         time: number;
@@ -101,59 +108,6 @@ export function graph_particles_simulate({ graph, camera, scene_database, gpu, e
         spawn_command_count: number;
     };
 }): ParticleSimulationHandles;
-/**
- * The standalone drawing: the depth sort, then one billboard draw over a colour target with
- * fixed-function blending.
- *
- * @param {object} params
- * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {number} params.camera graph handle
- * @param {number} params.color graph handle of the colour target the billboards draw over
- * @param {number} params.depth graph handle of the scene depth, tested against and never written
- * @param {object} params.gpu the persistent buffers
- * @param {ParticleSimulationHandles} params.simulated what {@link graph_particles_simulate} returned
- * @param {number} params.sort_bucket_count depth bins the render sort quantises into
- * @param {object} params.frame
- * @param {number} params.frame.sort_near view depth the sort's first bin starts at
- * @param {number} params.frame.sort_far view depth the sort's last bin ends at
- * @param {object} params.render
- * @param {GPUTextureView} params.render.atlas sprite atlas
- * @param {GPUSampler} params.render.atlas_sampler
- * @param {(color_format: string, depth_format: string) => object} params.render.obtain_pipeline
- *   the billboard pipeline for the frame's attachment formats
- * @returns {number} the colour handle after the draw
- */
-export function graph_particles_render({ graph, camera, color, depth, gpu, simulated, sort_bucket_count, frame, render, }: {
-    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-    camera: number;
-    color: number;
-    depth: number;
-    gpu: object;
-    simulated: ParticleSimulationHandles;
-    sort_bucket_count: number;
-    frame: {
-        sort_near: number;
-        sort_far: number;
-    };
-    render: {
-        atlas: GPUTextureView;
-        atlas_sampler: GPUSampler;
-        obtain_pipeline: (color_format: string, depth_format: string) => object;
-    };
-}): number;
-/**
- * The whole standalone frame: simulate, then sort and draw.
- *
- * @param {object} params every parameter of {@link graph_particles_simulate} and
- *   {@link graph_particles_render}
- * @returns {{color: number, alive: number, pool: number, counters: number}}
- */
-export function graph_particles(params: object): {
-    color: number;
-    alive: number;
-    pool: number;
-    counters: number;
-};
 export type ParticleSimulationHandles = {
     /**
      * the particle pool, after this frame's INIT and UPDATE

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":"AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAlBkG,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;IACS,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACe,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;;IACJ,yBAAyB,CAgMrC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;WAjBW,OAAO,2DAA2D,EAAE,UAAU;YAC9E,MAAM;WACN,MAAM;WACN,MAAM;SACN,MAAM;eACN,yBAAyB;uBACzB,MAAM;;QAEe,SAAS,EAA9B,MAAM;QACe,QAAQ,EAA7B,MAAM;;;;;wCAIS,MAAM,gBAAgB,MAAM,KAAK,MAAM;;IAEpD,MAAM,CA6ClB;AAED;;;;;;GAMG;AACH,wCAJW,MAAM;WAEI,MAAM;WAAS,MAAM;UAAQ,MAAM;cAAY,MAAM;EAazE;;;;;UAnTa,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":"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"}

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

@@ -2,8 +2,6 @@ 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 { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
-import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.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";
@@ -11,41 +9,48 @@ import { shader_prefix_sum_to_command } from "../rasterize/expand/mesh/shader_pr
 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 { 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 { PARTICLE_BILLBOARD_RESOURCES } from "./shaders/shader_particle_render.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";
-import {
-    PARTICLE_SORT_WORKGROUP_SIZE,
-    shader_particle_sort_histogram,
-    shader_particle_sort_reset,
-    shader_particle_sort_scatter,
-} from "./sort/shader_particle_sort.js";
 
 /**
- * The particle system's frame, recorded into the frame graph. {@link GPUParticleSystem} is what
- * calls these, with the buffers it owns; nothing else needs to.
+ * 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.
  *
- * Two halves. {@link graph_particles_simulate} is everything that moves particles:
+ * {@link graph_particles_simulate} is everything that moves particles:
  *
  *   reset counters -> spawn commands -> emitter tick -> scan -> spawn args -> emit -> simulate
  *   -> bucket -> build indirect
  *
  * and it leaves the frame's alive list, the pool and the indirect draw args as graph handles for
- * whoever draws. {@link graph_particles_render} is the standalone drawing: a depth sort and one
- * billboard draw straight over a colour target. Under the renderer the drawing is AVBOIT's instead
- * (`graph_particles_avboit.js`), which reads the same handles and needs no sort.
- * {@link graph_particles} is the two together, for a page with no transparency pipeline of its own.
+ * 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
  *
@@ -64,18 +69,18 @@ import {
  * 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 standalone 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
  *
  * 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 sort's two per-particle passes and the draw 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).
+ * 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
@@ -109,7 +114,11 @@ import {
  *   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 distinct compiled programs — `GPUParticleSystem#bucketCount()`
+ * @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
@@ -126,6 +135,7 @@ export function graph_particles_simulate({
                                              emitters,
                                              capacity,
                                              bucket_count,
+                                             wide_registers = false,
                                              frame,
                                          }) {
     assert.defined(graph, "graph");
@@ -219,6 +229,20 @@ export function graph_particles_simulate({
         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,
@@ -232,21 +256,37 @@ export function graph_particles_simulate({
 
     // 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 out = graph_compute_indirect_pass({
-            graph,
-            shader: shader_particle_emit,
-            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 },
-            },
-            command: emit_command,
-        });
+        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; }
     }
 
     // 7. Simulate — one indirect dispatch runs every emitter's UPDATE over the program-coherent list
@@ -254,19 +294,34 @@ export function graph_particles_simulate({
     //    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 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: {
-                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 },
-            },
-            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;
     }
 
@@ -310,218 +365,6 @@ export function graph_particles_simulate({
     };
 }
 
-/**
- * The standalone drawing: the depth sort, then one billboard draw over a colour target with
- * fixed-function blending.
- *
- * @param {object} params
- * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {number} params.camera graph handle
- * @param {number} params.color graph handle of the colour target the billboards draw over
- * @param {number} params.depth graph handle of the scene depth, tested against and never written
- * @param {object} params.gpu the persistent buffers
- * @param {ParticleSimulationHandles} params.simulated what {@link graph_particles_simulate} returned
- * @param {number} params.sort_bucket_count depth bins the render sort quantises into
- * @param {object} params.frame
- * @param {number} params.frame.sort_near view depth the sort's first bin starts at
- * @param {number} params.frame.sort_far view depth the sort's last bin ends at
- * @param {object} params.render
- * @param {GPUTextureView} params.render.atlas sprite atlas
- * @param {GPUSampler} params.render.atlas_sampler
- * @param {(color_format: string, depth_format: string) => object} params.render.obtain_pipeline
- *   the billboard pipeline for the frame's attachment formats
- * @returns {number} the colour handle after the draw
- */
-export function graph_particles_render({
-                                           graph,
-                                           camera,
-                                           color,
-                                           depth,
-                                           gpu,
-                                           simulated,
-                                           sort_bucket_count,
-                                           frame,
-                                           render,
-                                       }) {
-    assert.defined(simulated, "simulated");
-
-    // 10. Sort — the render order: back-to-front by view depth, so premultiplied transparency
-    //     composites correctly. Its two per-particle passes take the dispatch the bucket reset
-    //     wrote from the alive count.
-    const sorted = graph_particle_sort({
-        graph,
-        gpu,
-        camera,
-        emitter_database: simulated.emitter_database,
-        pool: simulated.pool,
-        alive: simulated.alive,
-        counters: simulated.counters,
-        dispatch_args: simulated.sim_dispatch_args,
-        bucket_count: sort_bucket_count,
-        near: frame.sort_near,
-        far: frame.sort_far,
-    });
-
-    // 11. Render — one instanced billboard draw over the sorted list, sized by the draw args this
-    //     frame's build-indirect wrote.
-    return graph_particle_render({
-        graph,
-        camera,
-        color,
-        depth,
-        pool: simulated.pool,
-        sorted,
-        emitter_database: simulated.emitter_database,
-        draw_args: simulated.draw_args,
-        render,
-    });
-}
-
-/**
- * The whole standalone frame: simulate, then sort and draw.
- *
- * @param {object} params every parameter of {@link graph_particles_simulate} and
- *   {@link graph_particles_render}
- * @returns {{color: number, alive: number, pool: number, counters: number}}
- */
-export function graph_particles(params) {
-    const simulated = graph_particles_simulate(params);
-
-    const color = graph_particles_render({ ...params, simulated });
-
-    return {
-        color,
-        alive: simulated.alive,
-        pool: simulated.pool,
-        counters: simulated.counters,
-    };
-}
-
-/**
- * The depth sort: reset -> histogram -> csdldf scan -> scatter, into `gpu.sorted`.
- *
- * @returns {number} graph handle of the sorted slot list
- */
-function graph_particle_sort({ graph, gpu, camera, emitter_database, pool, alive, counters, dispatch_args, bucket_count, near, far }) {
-    let histogram = graph_import_buffer(graph, gpu.sort_histogram, "particles/sort_histogram");
-    let cursor = graph_import_buffer(graph, gpu.sort_cursor, "particles/sort_cursor");
-    let keys = graph_import_buffer(graph, gpu.sort_keys, "particles/sort_keys");
-    let sorted = graph_import_buffer(graph, gpu.sorted, "particles/sorted");
-
-    // The reset's widest loop is the scan header plus the bins rounded up to a whole vec4.
-    const reset_words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(bucket_count);
-
-    {
-        const out = graph_compute_pass({
-            graph,
-            shader: shader_particle_sort_reset,
-            bindings: { histogram, cursor, settings: { u_bucket_count: bucket_count } },
-            group_count: [Math.ceil(reset_words / PARTICLE_SORT_WORKGROUP_SIZE), 1, 1],
-        });
-        histogram = out.histogram;
-        cursor = out.cursor;
-    }
-
-    // The counters are only read here, but an atomic read needs a read_write binding, and the
-    // graph sees a write — so the handle is threaded through like any other.
-    {
-        const out = graph_compute_indirect_pass({
-            graph,
-            shader: shader_particle_sort_histogram,
-            bindings: {
-                camera, emitter_database, pool, alive, counters, keys, histogram,
-                settings: { u_near: near, u_far: far, u_bucket_count: bucket_count },
-            },
-            command: dispatch_args,
-        });
-        keys = out.keys;
-        histogram = out.histogram;
-        counters = out.counters;
-    }
-
-    const scanned = graph_prefix_scan_csdldf({
-        graph,
-        data: histogram,
-        element_max_count: bucket_count,
-    });
-
-    {
-        const out = graph_compute_indirect_pass({
-            graph,
-            shader: shader_particle_sort_scatter,
-            bindings: { keys, alive, scanned, counters, cursor, sorted },
-            command: dispatch_args,
-        });
-        sorted = out.sorted;
-    }
-
-    return sorted;
-}
-
-/** The colour attachment's view: one mip, the one the frame draws into. */
-const COLOR_VIEW = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel: 0 });
-
-/**
- * The billboard draw: loads the colour target, depth-tests read-only against the scene, draws
- * `drawIndirect(draw_args)` instances over the sorted list.
- *
- * @returns {number} the colour handle after the draw
- */
-function graph_particle_render({ graph, camera, color, depth, pool, sorted, emitter_database, draw_args, render }) {
-    const data = {};
-
-    const pass = graph.add("Particle Billboard", data, (data, resources, context) => {
-        const encoder = context.encoder;
-
-        const color_texture = resources.get(data.color);
-        const depth_texture = resources.get(data.depth);
-
-        const pipeline = render.obtain_pipeline(color_texture.descriptor.format, depth_texture.descriptor.format);
-
-        // Read by the soft-depth fade and tested against by the pass: the same view, read-only in
-        // both roles.
-        const depth_view = depth_texture.obtainView(DEFAULT_DEPTH_TEXTURE_VIEW);
-
-        const bindings = PARTICLE_BILLBOARD_RESOURCES.generateBindings({
-            camera: resources.get(data.camera),
-            pool: resources.get(data.pool),
-            draw_list: resources.get(data.sorted),
-            emitter_database: resources.get(data.emitter_database),
-            atlas: render.atlas,
-            atlas_sampler: render.atlas_sampler,
-            scene_depth: depth_view,
-        }, encoder);
-
-        const render_pass = encoder.constructRenderPass({
-            label: "Particle Billboard",
-            pipeline,
-            bindings,
-            colorAttachments: [{
-                view: color_texture.obtainView(COLOR_VIEW),
-                loadOp: "load",
-                storeOp: "store",
-            }],
-            depthStencilAttachment: {
-                view: depth_view,
-                depthReadOnly: true,
-            },
-        });
-
-        render_pass.drawIndirect(resources.get(data.draw_args), 0);
-        render_pass.end();
-    });
-
-    data.camera = pass.read(camera);
-    data.pool = pass.read(pool);
-    data.sorted = pass.read(sorted);
-    data.emitter_database = pass.read(emitter_database);
-    data.draw_args = pass.read(draw_args);
-    data.depth = pass.read(depth);
-    data.color = pass.write(pass.read(color));
-
-    return data.color;
-}
-
 /**
  * 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

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":"AAoCA;;;;;;;;;;;;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;;;;;;;;;;;;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"}

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

@@ -24,8 +24,9 @@ import {
  * GPU-driven: the draws are `drawIndirect` over the GPU's own alive count, and the occupancy walks
  * the emitter table's pages. Nothing here knows how many particles there are.
  *
- * Order does not matter to any of them — the volume and the accumulators are order-independent —
- * so the depth sort the standalone renderer needs is not run for this path.
+ * Order does not matter to any of them — the volume and the accumulators are order-independent — so
+ * the depth sort the standalone billboard draw needs is not run for this path, and its buffers are
+ * never made. That is what {@link ParticleRenderMode.AVBOIT} means.
  */
 
 /** The accumulators' view: one mip, the one the frame draws into. */