@woosh/meep-engine 3.15.0 → 3.17.0

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

@@ -1,133 +1,312 @@
 /**
- * The GPU particle system feature.
+ * The GPU particle system: a feature of a scene, in the mould of `ReSTIRDI` — construct once
+ * against a {@link GPUSceneContext}, and contribute the frame's passes through
+ * {@link execute}.
  *
- * Owns the persistent GPU state (particle pool, ping-pong alive lists, dead free-list, counters,
- * sort scratch, emitter/program/constant buffers, indirect args) and the CPU model (an
- * {@link EmitterRegistry}, a {@link ParticleSpawnScheduler} and bone attachments). Mirrors the
- * ReSTIR feature template: construct once, toggle with a flag, and contribute per-frame passes via
- * {@link encode}.
+ * ## What it owns
  *
- * ## Frame sequence (encode)
+ * Every piece of persistent GPU state: the particle pool, the ping-pong alive lists, the dead
+ * free-list, the counters, both indirect-args buffers, the simulation-order (coherence) scratch,
+ * the emitter database (the emitter table and the GPU-owned state table, one buffer), the packed
+ * program buffer, and the spawn-command ring. Buffers that depend on the emitter set — the
+ * coherence scratch on the number of distinct programs, the program buffer on the heap, the
+ * database on its own pages — are grown inside {@link execute}, the way ReSTIR's reservoirs follow
+ * the resolution. The render-order (sort) scratch is not in that list because it is not
+ * unconditional: see below.
  *
- * 1. reset counters (snapshot the previous alive count as this frame's simulate input, zero the new
- *    alive count)
- * 2. emit — run SPAWN for each scheduled spawn request (pop dead -> init -> append alive)
- * 3. simulate — one dispatch runs every emitter's UPDATE over the coherence list built last frame,
- *    compacting survivors into the new alive list and freed slots into the dead list
- * 4. bucket — regroup the new alive list by VM program, padded to whole workgroups, into the list
- *    NEXT frame's simulate consumes (`coherence/`)
- * 5. build indirect — derive next frame's simulate dispatch from the padded list length and this
- *    frame's render draw instance count from the alive count
- * 6. sort (optional) — histogram -> csdldf scan -> scatter to a back-to-front index list
- * 7. render — one instanced billboard draw over the sorted list
+ * Every pass stays within the eight storage buffers a stage gets by default: the emitter record
+ * and the GPU-owned state are two tables of one database buffer, and the VM's constants and code
+ * are one packed buffer. The one exception is the wide-register fallback (below), whose emit and
+ * simulate passes bind a ninth for the register file — inside the ten the engine already demands of
+ * an adapter, but past the default.
  *
- * Steps 4 and 6 are two different orderings of the same particles and share nothing: the
- * simulation order is program-coherent and camera-independent, the render order is back-to-front
- * and changes with the camera. Separate buffers, separate passes, separate counter slots.
+ * ## Two interpreters
  *
- * The alive lists ping-pong by frame parity, exactly like the ReSTIR reservoirs.
+ * The VM's register file normally lives in shader registers, and is therefore small — see
+ * {@link ./ParticleConstants.js PARTICLE_VM_FAST_REGISTER_SLOTS}. An effect whose compiled program
+ * needs more than it holds does not fail: the whole system swaps emit and simulate for variants
+ * that keep the file in a storage buffer, which is far slower and effectively unbounded. The choice
+ * is per-frame, whole-system, and made here — the registry reports `max_register_count` over the
+ * effects it holds and this is where that number meets the VM's; nothing about authoring a graph has
+ * a register ceiling.
  *
- * ## CPU update
+ * ## Emitters are scene nodes
  *
- * {@link update} runs before encode: it patches bone-attached emitters' transforms from their scene
- * nodes and asks the scheduler for this frame's spawn requests (respecting cull/sleep). Keeping
- * spawn *counting* on the CPU (emitters are few) keeps the GPU emit pass a trivial one-thread-per-
- * particle kernel.
+ * There is no `addEmitter`. A {@link ParticleEmitter} is a {@link Node3D}: put it in the scene —
+ * on its own or under a joint — and the next {@link execute} finds it in the scene's node list,
+ * gives it a row in the emitter table pointed at the `transforms` row the scene context gave the
+ * node, and it starts spawning. Take it out of the scene and its row is retired and its particles
+ * freed. The sweep runs only when the scene's membership version moves, which is how per-frame
+ * upkeep stays proportional to what changed rather than to how many emitters there are.
+ *
+ * ## Spawning is the GPU's decision
+ *
+ * The CPU never counts particles or walks emitters per frame. The emitter tick pass integrates
+ * every emitter's rate on the GPU, and the emit dispatch is sized by a prefix scan of what it
+ * decided. The host's one way to ask for particles is {@link spawn}: a burst queued into a small
+ * command list that a pass adds to the emitter's pending spawns, on the same path as everything
+ * else. See `graph_particles.js` for the frame.
+ *
+ * ## Drawing, and the one thing the mode changes
+ *
+ * {@link execute} is the whole per-frame call, once per frame. It always records everything that
+ * moves particles and leaves the alive list and the indirect draw args as graph handles; what it
+ * records after that is the {@link ParticleRenderMode} it was given.
+ *
+ * `BILLBOARD` sorts the alive list back-to-front and draws it over a colour target, because
+ * premultiplied over-blending is order-dependent. `AVBOIT` records neither: under the renderer the
+ * system is an `AVBOITSideChannel`, and the transparency orchestrator asks it for its occupancy, its
+ * extinction and its draw at the three points where the transparent meshes have contributed theirs
+ * ({@link avboit_occupancy}, {@link avboit_splat}, {@link avboit_draw}). Those read the same handles
+ * and composite into a volume and a set of accumulators that are sums, so an ordering would buy
+ * nothing — and the sort is four passes and a scan over every live particle, plus two lists a word
+ * per particle each, which is why the mode also decides whether those buffers exist at all.
+ *
+ * ## Allocation
+ *
+ * The per-frame path allocates the frame graph's records and nothing else: emitter rows are
+ * staged through one shared record, spawn commands go into a preallocated ring, and the
+ * per-dispatch settings are reused objects. A command context is opened only on frames that have
+ * something to upload.
  */
 export class GPUParticleSystem {
     /**
      * @param {object} graphics engine GraphicsContext (has `.device`)
+     * @param {import("../scene/GPUSceneContext.js").GPUSceneContext} scene_context
      * @param {object} [options]
      * @param {number} [options.capacity] max simultaneous particles
+     * @param {number} [options.spawn_command_capacity] most {@link spawn} calls one frame keeps
      */
-    constructor(graphics: object, { capacity }?: {
+    constructor(graphics: object, scene_context: import("../scene/GPUSceneContext.js").GPUSceneContext, { capacity, spawn_command_capacity }?: {
         capacity?: number;
+        spawn_command_capacity?: number;
     });
-    graphics: any;
+    /**
+     * Engine GraphicsContext.
+     * @type {object}
+     */
+    graphics: object;
+    /**
+     * The scene whose nodes the emitters are, and whose database their world matrices come from.
+     * @type {import("../scene/GPUSceneContext.js").GPUSceneContext}
+     */
+    scene_context: import("../scene/GPUSceneContext.js").GPUSceneContext;
+    /**
+     * Maximum number of simultaneously live particles.
+     * @type {number}
+     */
     capacity: number;
+    /**
+     * @type {EmitterRegistry}
+     */
     registry: EmitterRegistry;
-    scheduler: ParticleSpawnScheduler;
-    /** @type {Map<number, object>} emitter index -> scene Node3D */
-    attachments: Map<number, object>;
-    /** @type {number} */
+    /**
+     * Frames elapsed. Drives the alive-list ping-pong and the VM's frame builtin.
+     * @type {number}
+     */
     frame: number;
-    /** built lazily on first encode */
-    buffers: any;
-    /** CPU shadow of the packed emitter buffer (for in-place transform patching) */
-    emitter_cpu: Uint32Array;
-    emitters_dirty: boolean;
     /**
-     * Distinct compiled programs across the emitter set — the number of buckets the coherence
-     * pass sorts into. Known only after {@link buildEmitterData}; until then the emitter count
-     * is a safe upper bound (programs can be shared, never invented).
-     * @type {number|undefined}
+     * Seconds since start, the VM's `TIME` builtin. Advanced by `dt` each {@link execute}.
+     * @type {number}
      */
-    program_count: number | undefined;
+    time: number;
     /**
-     * Register an emitter.
-     * @param {object} config see {@link EmitterRegistry#add}
-     * @returns {number} emitter index
+     * Cap on how much missed time a culled emitter makes up for when it comes back into view.
+     * @type {number}
      */
-    addEmitter(config: object): number;
+    max_catchup_seconds: number;
     /**
-     * Attach an emitter to a scene node (bone). Each frame the emitter's transform is copied from
-     * `node.transform_global.matrix` so it follows the bone.
-     * @param {number} emitter_index
-     * @param {object} node a Node3D with `transform_global.matrix` (column-major 16)
+     * View-depth range the render sort quantises: particles nearer than `[0]` share the front bin,
+     * farther than `[1]` the back one. Read only by {@link ParticleRenderMode.BILLBOARD}.
+     * @type {Float32Array}
      */
-    attachToNode(emitter_index: number, node: object): void;
+    sort_depth_range: Float32Array;
     /**
-     * Per-frame CPU preparation. Returns the spawn requests for this frame.
+     * Sprite atlas the billboards sample, and the sampler they sample it with. A 1x1 white texel by
+     * default, so an emitter with no art draws as a plain quad rather than nothing.
+     * @type {GPUTextureView}
+     */
+    atlas: GPUTextureView;
+    /** @type {GPUSampler} */
+    atlas_sampler: GPUSampler;
+    /**
+     * The persistent GPU buffers, by the names the graph functions bind them under. Exposed for
+     * inspection — a harness copying the counters out to display them — never for the frame loop,
+     * which reads nothing back. Entries that grow with the emitter set are replaced in place.
      *
-     * @param {number} dt seconds
-     * @param {object} [context]
-     * @param {(emitterIndex: number) => boolean} [context.is_visible] cull predicate (sleep-culling)
-     * @returns {Uint32Array} spawn requests (emitter index per particle to create)
-     */
-    update(dt: number, { is_visible }?: {
-        is_visible?: (emitterIndex: number) => boolean;
-    }): Uint32Array;
-    /**
-     * Rebuild the packed emitter/program/constant buffers when the emitter set changes.
-     * @returns {{emitters: Uint32Array, program: Uint32Array, constants: Uint32Array}}
-     */
-    buildEmitterData(): {
-        emitters: Uint32Array;
-        program: Uint32Array;
-        constants: Uint32Array;
-    };
+     * @type {object}
+     */
+    buffers: object;
+    /**
+     * The buffer the emitter table lives in — what every emitter-reading pass binds.
+     * @returns {GPUBuffer}
+     */
+    get emitter_database(): GPUBuffer;
     /**
-     * Number of simulation-order buckets — one per distinct compiled program.
+     * The live emitters, in no particular order.
+     * @returns {import("./runtime/ParticleEmitter.js").ParticleEmitter[]}
+     */
+    get emitters(): import("./runtime/ParticleEmitter.js").ParticleEmitter[];
+    /**
+     * Number of simulation-order buckets — one per program id the registry can hand out, which is
+     * its peak number of distinct compiled programs rather than its current one.
      *
      * This is the coherence pass's only host-provided number, and it is static topology rather than
-     * per-frame state: it changes when the emitter set changes, not as particles are born and die.
-     * Everything the pass measures per frame stays on the GPU.
+     * per-frame state: it changes when an effect the set has never held is registered, not as
+     * particles are born and die. Everything the pass measures per frame stays on the GPU. Sizing it
+     * from the peak rather than the live count is what keeps it from moving every time an effect is
+     * unregistered — the bins of released ids are empty, and an empty bin rounds up to zero
+     * workgroups and shifts nothing after it.
      *
      * @returns {number}
      */
     bucketCount(): number;
     /**
-     * Sizes of the persistent buffers, in bytes. Exposed for tests and allocation.
-     * @returns {object}
+     * Index of the alive list this frame reads from / writes to (ping-pong by frame parity).
+     * @returns {number}
+     */
+    get alive_write_index(): number;
+    /**
+     * Ask for `count` particles from an emitter, on top of its rate, on the next frame. Goes
+     * through the GPU path — the tick pass folds it into the emitter's accumulator, the budget and
+     * the culling apply — so it is a request, not a guarantee.
+     *
+     * @param {import("./runtime/ParticleEmitter.js").ParticleEmitter} emitter a registered emitter
+     * @param {number} count
+     */
+    spawn(emitter: import("./runtime/ParticleEmitter.js").ParticleEmitter, count: number): void;
+    /**
+     * The system's whole contribution to the frame: the simulation, then whatever `mode` says draws
+     * it.
+     *
+     * {@link ParticleRenderMode.BILLBOARD} adds the depth sort and one billboard draw over `color`
+     * with fixed-function blending, for a page with no transparency pipeline of its own.
+     * {@link ParticleRenderMode.AVBOIT} adds nothing: the orchestrator draws the particles later in
+     * the frame through {@link avboit_occupancy}, {@link avboit_splat} and {@link avboit_draw}, off
+     * the handles this just produced, and its accumulators are order-independent — so the sort is
+     * skipped and its buffers are never allocated. `color` comes straight back either way, so a
+     * caller can assign the result unconditionally and let the mode be the only difference.
+     *
+     * Call after the scene context has built for the frame (`GPUSceneContext#update`), so every
+     * emitter node has its `transforms` row, and after the hierarchy pass has run, so the rows'
+     * `global` matrices are this frame's.
+     *
+     * **Once per frame, not once per view.** This advances the simulation by `dt` and hands out
+     * handles into the graph it recorded into; a second view of the same scene records a second
+     * graph and would step the simulation twice. The renderer has one view per `render` call today,
+     * so this holds by construction; a second view of one scene needs the step and the handles
+     * separated — record the passes for the first graph, import the same buffers into the rest.
+     *
+     * @param {object} params
+     * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+     * @param {number} params.camera graph handle of the camera uniform buffer
+     * @param {number} params.scene_database graph handle of the scene database — the one the
+     *   hierarchy pass returned, so this reads the matrices it composed
+     * @param {number} params.dt seconds since the previous frame
+     * @param {ParticleRenderMode} [params.mode] who draws, and so whether there is a sort
+     * @param {number} [params.color] graph handle of the colour target to draw over. Required by
+     *   `BILLBOARD`; returned untouched by `AVBOIT`
+     * @param {number} [params.depth] graph handle of the scene depth (tested, never written).
+     *   Required by `BILLBOARD`
+     * @returns {number|undefined} the colour handle after the particle draw, or `color` unchanged
+     */
+    execute({ graph, camera, scene_database, color, depth, dt, mode }: {
+        graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        camera: number;
+        scene_database: number;
+        dt: number;
+        mode?: ParticleRenderMode;
+        color?: number;
+        depth?: number;
+    }): number | undefined;
+    /**
+     * `AVBOITSideChannel#avboit_occupancy`: the emitters' bounds spheres, as depth slices.
+     *
+     * @param {object} args see `AVBOITSideChannel`
+     * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} args.graph
+     * @param {number} args.camera graph handle of the camera uniform buffer
+     * @param {ArrayLike<number>} args.cluster_parameters the frame's depth curve
+     * @param {number} args.occupancy graph handle of the occupancy bits
+     * @returns {number} the occupancy handle after the write
      */
-    bufferSizes(): object;
+    avboit_occupancy({ graph, camera, cluster_parameters, occupancy }: {
+        graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        camera: number;
+        cluster_parameters: ArrayLike<number>;
+        occupancy: number;
+    }): number;
     /**
-     * The initial dead-list contents (all slots free) and counter values for a fresh pool.
-     * @returns {{dead: Uint32Array, counters: Uint32Array}}
+     * `AVBOITSideChannel#avboit_splat`: the live particles' extinction, into the volume.
+     *
+     * @param {object} args see `AVBOITSideChannel`
+     * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} args.graph
+     * @param {number} args.camera graph handle of the camera uniform buffer
+     * @param {number} args.warp graph handle of the warp LUT
+     * @param {number} args.depth_texture graph handle of the scene depth
+     * @param {{extinction: number, overflow: number, dummy: number}} args.volume the voxel volume
+     * @returns {{extinction: number, overflow: number, dummy: number}} the volume after the write
      */
-    initialFreeList(): {
-        dead: Uint32Array;
-        counters: Uint32Array;
+    avboit_splat({ graph, camera, warp, depth_texture, volume }: {
+        graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+        camera: number;
+        warp: number;
+        depth_texture: number;
+        volume: {
+            extinction: number;
+            overflow: number;
+            dummy: number;
+        };
+    }): {
+        extinction: number;
+        overflow: number;
+        dummy: number;
     };
     /**
-     * Index of the alive list this frame reads from / writes to (ping-pong by frame parity).
-     * @returns {{read: number, write: number}}
+     * `AVBOITSideChannel#avboit_draw`: the live particles, into the accumulators.
+     *
+     * @param {object} args see `AVBOITSideChannel`
+     * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} args.graph
+     * @param {import("../view/GPUViewContext.js").GPUViewContext} args.view_ctx
+     * @param {number} args.camera graph handle of the camera uniform buffer
+     * @param {number} args.depth_texture graph handle of the scene depth
+     * @param {number} args.warp graph handle of the warp LUT
+     * @param {number} args.integral graph handle of the integral texture
+     * @param {number} args.volumetrics_lut graph handle
+     * @param {number} args.volumetrics_metadata graph handle
+     * @param {{color: number, norm: number, extinction: number, emission: number}} args.accumulators
+     * @returns {{color: number, norm: number, extinction: number, emission: number}} after the draw
+     */
+    avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators }: {
+        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;
+        };
+    }): {
+        color: number;
+        norm: number;
+        extinction: number;
+        emission: number;
+    };
+    /**
+     * Sizes of the persistent buffers, in bytes, as they stand. Exposed for tests.
+     * @returns {Object<string, number>}
      */
-    aliveListIndices(): {
-        read: number;
-        write: number;
+    bufferSizes(): {
+        [x: string]: number;
     };
+    destroy(): void;
+    #private;
 }
 import { EmitterRegistry } from "./runtime/EmitterRegistry.js";
-import { ParticleSpawnScheduler } from "./runtime/ParticleSpawnScheduler.js";
+import { ParticleRenderMode } from "./ParticleRenderMode.js";
 //# sourceMappingURL=GPUParticleSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IACI;;;;OAIG;IACH,sBAJW,MAAM;QAEW,QAAQ,GAAzB,MAAM;OA8BhB;IAxBG,cAAwB;IACxB,iBAAwB;IAExB,0BAAqC;IACrC,kCAA6C;IAE7C,gEAAgE;IAChE,aADW,IAAI,MAAM,EAAE,MAAM,CAAC,CACF;IAE5B,qBAAqB;IACrB,OADW,MAAM,CACH;IAEd,mCAAmC;IACnC,aAAwB;IACxB,gFAAgF;IAChF,yBAA4B;IAC5B,wBAA0B;IAC1B;;;;;OAKG;IACH,eAFU,MAAM,GAAC,SAAS,CAEI;IAGlC;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;OAKG;IACH,4BAHW,MAAM,QACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,WALW,MAAM;oCAES,MAAM,KAAK,OAAO;QAC/B,WAAW,CAiBvB;IAED;;;OAGG;IACH,oBAFa;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,WAAW,CAAA;KAAC,CAQjF;IAED;;;;;;;;OAQG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,eAFa,MAAM,CA+BlB;IAED;;;OAGG;IACH;cAFoB,WAAW;kBAAY,WAAW;MAUrD;IAED;;;OAGG;IACH;cAFoB,MAAM;eAAS,MAAM;MAKxC;CACJ;gCA3M+B,8BAA8B;uCACvB,qCAAqC"}
+{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"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"}