@woosh/meep-engine 3.68.0 → 3.69.0

package/src/shade/renderer/rasterize/native/avboit/graph_avboit_unlit.js

@@ -0,0 +1,306 @@
+import { assert } from "../../../../../core/assert.js";
+import { GPUTextureUsage } from "../../../../descriptor/GPUTextureUsage.js";
+import { TextureViewDescriptor } from "../../../../descriptor/texture/TextureViewDescriptor.js";
+import { TextureResourceDescriptor } from "../../../../device/graph/TextureResourceDescriptor.js";
+import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../../../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
+import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../../../STATIC_GRAPHICS_ENGINE_ASSETS.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
+import { AVBOIT_UNLIT_DRAW_PASS_GROUP } from "./avboit_unlit_draw.js";
+import { AVBOIT_UNLIT_SPLAT_PASS_GROUP, AVBOIT_UNLIT_SPLAT_SAMPLES } from "./avboit_unlit_splat.js";
+import { AVBOIT_SPLAT_DUMMY_FORMAT, AVBOIT_SPLAT_VOLUME_GROUP } from "./shader_avboit_splat.js";
+
+/**
+ * The passes an `AVBOITSideChannel` of unlit straight-alpha geometry records for its splat and its draw,
+ * with everything but the draws themselves in one place: the attachments, the multisampled target of
+ * the splat, the pass-level bind groups and the frame-graph reads and writes. A channel supplies a
+ * pipeline built by `avboit_unlit_splat_pipeline` / `avboit_unlit_draw_pipeline`, the graph handles its
+ * own draws read, and a `record` callback that issues them; the dynamic meshes and the trails draw
+ * through the same passes this way, with different vertex stages.
+ *
+ * Order does not matter to either pass — the volume and the accumulators are sums — which is why
+ * nothing here sorts.
+ */
+
+/** The accumulators' and the splat target's view: one mip, the one the frame draws into. */
+const COLOR_VIEW = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel: 0 });
+
+/**
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} resources
+ * @param {import("../../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
+ * @returns {number} where the shader declares `group`
+ */
+function group_index(resources, group) {
+    const index = resources.groups.indexOf(group);
+
+    assert.notEqual(index, -1, "the shader does not bind this pass group");
+
+    return index;
+}
+
+/**
+ * Read every handle of `inputs` in `pass`, keeping the names.
+ *
+ * @param {object} pass the pass builder
+ * @param {Object<string, number>} inputs
+ * @returns {Object<string, number>} the handles as the pass reads them
+ */
+function read_inputs(pass, inputs) {
+    const read = {};
+
+    for (const name of Object.keys(inputs)) {
+        read[name] = pass.read(inputs[name]);
+    }
+
+    return read;
+}
+
+/**
+ * @param {Object<string, number>} handles
+ * @param {object} resources the pass's resolved resources
+ * @returns {Object<string, *>} the same names, resolved
+ */
+function resolve_inputs(handles, resources) {
+    const resolved = {};
+
+    for (const name of Object.keys(handles)) {
+        resolved[name] = resources.get(handles[name]);
+    }
+
+    return resolved;
+}
+
+/**
+ * Splat a channel's unlit geometry into the voxel volume.
+ *
+ * The raster is multisampled ({@link AVBOIT_UNLIT_SPLAT_SAMPLES}), so it cannot use the volume's
+ * single-sampled splat target: the pass makes its own at the volume's resolution, never written,
+ * cleared and discarded, and hands the volume's back untouched.
+ *
+ * @param {object} params
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {string} params.label the pass's label; its target is labelled after it
+ * @param {import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} params.pipeline
+ * from `avboit_unlit_splat_pipeline`
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the pipeline's shader resources
+ * @param {Object<string, number>} params.inputs graph handles the channel's draws read, by name
+ * @param {number} params.warp graph handle
+ * @param {number[]} params.voxel_resolution the volume's width and height, which the raster is
+ * @param {{extinction: number, overflow: number, dummy: number}} params.volume the volume, to add to
+ * @param {function(): boolean} params.is_empty asked when the pass executes; `true` records no render pass
+ * @param {function(GPURenderPassEncoder, GraphicsContext, Object<string, *>): void} params.record issues
+ * the draws into the open pass, whose pass-level groups are set, with `inputs` resolved
+ * @returns {{extinction: number, overflow: number, dummy: number}} the volume after the write
+ */
+export function graph_avboit_unlit_splat({
+                                             graph,
+                                             label,
+                                             pipeline,
+                                             resources,
+                                             inputs,
+                                             warp,
+                                             voxel_resolution,
+                                             volume,
+                                             is_empty,
+                                             record,
+                                         }) {
+    assert.isString(label, "label");
+    assert.isNonNegativeInteger(warp, "warp");
+    assert.isArrayLike(voxel_resolution, "voxel_resolution");
+    assert.defined(volume, "volume");
+    assert.isFunction(is_empty, "is_empty");
+    assert.isFunction(record, "record");
+
+    const pass_group_index = group_index(resources, AVBOIT_UNLIT_SPLAT_PASS_GROUP);
+    const volume_group_index = group_index(resources, AVBOIT_SPLAT_VOLUME_GROUP);
+
+    function execute(data, frame_resources, context) {
+        const encoder = context.encoder;
+        const graphics = context.graphics;
+
+        if (is_empty()) {
+            return;
+        }
+
+        // By name, never by position (AVBOIT ledger entry 21): the order a shader declares its
+        // bindings in is the shader's business.
+        const pass_group = AVBOIT_UNLIT_SPLAT_PASS_GROUP.generateBindings({
+            warp: frame_resources.get(data.warp),
+        }, encoder);
+
+        const volume_group = AVBOIT_SPLAT_VOLUME_GROUP.generateBindings({
+            extinction_volume: frame_resources.get(data.extinction),
+            overflow_slice: frame_resources.get(data.overflow),
+        }, encoder);
+
+        // the target is never written; it only sizes the raster and gives it its samples
+        const pass_encoder = encoder.constructRenderPass({
+            label,
+            pipeline,
+            // the pass's groups are set once, just below; the draws set their own
+            bindings: [],
+            colorAttachments: [{
+                view: frame_resources.get(data.target).obtainView(COLOR_VIEW),
+                loadOp: "clear",
+                storeOp: "discard",
+            }],
+        });
+
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, pass_group_index, pass_group);
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, volume_group_index, volume_group);
+
+        record(pass_encoder, graphics, resolve_inputs(data.inputs, frame_resources));
+
+        pass_encoder.end();
+    }
+
+    const pass_data = {};
+    const pass = graph.add(label, pass_data, execute);
+
+    pass_data.inputs = read_inputs(pass, inputs);
+    pass_data.warp = pass.read(warp);
+
+    pass.read(volume.extinction);
+    pass_data.extinction = pass.write(volume.extinction);
+    pass.read(volume.overflow);
+    pass_data.overflow = pass.write(volume.overflow);
+
+    const target = TextureResourceDescriptor.from({
+        resolution: voxel_resolution,
+        format: AVBOIT_SPLAT_DUMMY_FORMAT,
+        usage: GPUTextureUsage.RENDER_ATTACHMENT,
+    });
+
+    // `from` takes no sample count
+    target.sampleCount = AVBOIT_UNLIT_SPLAT_SAMPLES;
+
+    pass_data.target = pass.create(`${label} target`, target);
+
+    return {
+        extinction: pass_data.extinction,
+        overflow: pass_data.overflow,
+        // not this pass's to touch
+        dummy: volume.dummy,
+    };
+}
+
+/**
+ * Draw a channel's unlit geometry into the four accumulators, depth-tested against the opaque scene.
+ *
+ * @param {object} params
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
+ * @param {string} params.label
+ * @param {import("../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor} params.pipeline
+ * from `avboit_unlit_draw_pipeline`
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the pipeline's shader resources
+ * @param {Object<string, number>} params.inputs graph handles the channel's draws read, by name
+ * @param {import("../../../view/GPUViewContext.js").GPUViewContext} params.view_ctx
+ * @param {number} params.depth_texture graph handle of the opaque scene's depth — tested, 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 {function(): boolean} params.is_empty asked when the pass executes; `true` records no render pass
+ * @param {function(GPURenderPassEncoder, GraphicsContext, Object<string, *>): void} params.record issues
+ * the draws into the open pass, whose pass-level group is set, with `inputs` resolved
+ * @returns {{color: number, norm: number, extinction: number, emission: number}} the accumulators after the draw
+ */
+export function graph_avboit_unlit_draw({
+                                            graph,
+                                            label,
+                                            pipeline,
+                                            resources,
+                                            inputs,
+                                            view_ctx,
+                                            depth_texture,
+                                            warp,
+                                            integral,
+                                            volumetrics_lut,
+                                            volumetrics_metadata,
+                                            accumulators,
+                                            is_empty,
+                                            record,
+                                        }) {
+    assert.isString(label, "label");
+    assert.isNonNegativeInteger(depth_texture, "depth_texture");
+    assert.isNonNegativeInteger(warp, "warp");
+    assert.isNonNegativeInteger(integral, "integral");
+    assert.defined(accumulators, "accumulators");
+    assert.isFunction(is_empty, "is_empty");
+    assert.isFunction(record, "record");
+
+    const pass_group_index = group_index(resources, AVBOIT_UNLIT_DRAW_PASS_GROUP);
+
+    function execute(data, frame_resources, context) {
+        const encoder = context.encoder;
+        const graphics = context.graphics;
+
+        if (is_empty()) {
+            return;
+        }
+
+        // by name rather than by position, for the reason the splat gives
+        const pass_group = AVBOIT_UNLIT_DRAW_PASS_GROUP.generateBindings({
+            view: view_ctx.uniform_buffer.buffer,
+            warp: frame_resources.get(data.warp),
+            tIntegral: frame_resources.get(data.integral).obtainView(),
+            sLinear: graphics.samplers.obtain(SAMPLER_LINEAR_UPSCALE),
+            volumetrics_metadata: frame_resources.get(data.volumetrics_metadata),
+            tVolumetrics: frame_resources.get(data.volumetrics_lut).obtainView(),
+            tSTBN_vec3: graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3).obtainView(),
+        }, encoder);
+
+        const attachment = (handle) => ({
+            view: frame_resources.get(handle).obtainView(COLOR_VIEW),
+            loadOp: "load",
+            storeOp: "store",
+        });
+
+        const pass_encoder = encoder.constructRenderPass({
+            label,
+            pipeline,
+            // the pass's group is set once, just below; the draws set their own
+            bindings: [],
+            colorAttachments: [
+                attachment(data.color),
+                attachment(data.norm),
+                attachment(data.extinction),
+                attachment(data.emission),
+            ],
+            depthStencilAttachment: {
+                view: frame_resources.get(data.depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
+                depthReadOnly: true,
+            },
+        });
+
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, pass_group_index, pass_group);
+
+        record(pass_encoder, graphics, resolve_inputs(data.inputs, frame_resources));
+
+        pass_encoder.end();
+    }
+
+    const pass_data = {};
+    const pass = graph.add(label, pass_data, execute);
+
+    pass_data.inputs = read_inputs(pass, inputs);
+    pass_data.depth = pass.read(depth_texture);
+    pass_data.warp = pass.read(warp);
+    pass_data.integral = pass.read(integral);
+    pass_data.volumetrics_lut = pass.read(volumetrics_lut);
+    pass_data.volumetrics_metadata = pass.read(volumetrics_metadata);
+
+    for (const name of ["color", "norm", "extinction", "emission"]) {
+        pass.read(accumulators[name]);
+        pass_data[name] = pass.write(accumulators[name]);
+    }
+
+    return {
+        color: pass_data.color,
+        norm: pass_data.norm,
+        extinction: pass_data.extinction,
+        emission: pass_data.emission,
+    };
+}

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.d.ts

@@ -10,11 +10,20 @@ export const AVBOIT_SPLAT_BIND_GROUP_VOLUME: number;
  * @type {GPUTextureFormat}
  */
 export const AVBOIT_SPLAT_DUMMY_FORMAT: GPUTextureFormat;
+/**
+ * The voxel volume a splat adds its extinction into: the packed counts and the per-channel first
+ * overflow, both atomics, so fragment-only. Every splat that writes through `avboit_splat_slice` binds
+ * this group.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_SPLAT_VOLUME_GROUP: ShaderResourceGroupDescriptor;
 /**
  * One pipeline per template that can be drawn forward.
  *
  * @type {TemplatePassDescriptor}
  */
 export const shader_avboit_splat: TemplatePassDescriptor;
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
 import { TemplatePassDescriptor } from "../../TemplatePassDescriptor.js";
 //# sourceMappingURL=shader_avboit_splat.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yDAAmD;AA8HnD;;;;GAIG;AACH,kCAFU,sBAAsB,CA+B7B;uCApLoC,iCAAiC"}
+{"version":3,"file":"shader_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yDAAmD;AASnD;;;;;;GAMG;AACH,wCAFU,6BAA6B,CAEsC;AAqH7E;;;;GAIG;AACH,kCAFU,sBAAsB,CA+B7B;8CArM2C,2DAA2D;uCAUlE,iCAAiC"}

package/src/shade/renderer/rasterize/native/avboit/shader_avboit_splat.js

@@ -49,14 +49,21 @@ view_group
     .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
 ;
 
-const volume_group = new ShaderResourceGroupDescriptor();
+/**
+ * The voxel volume a splat adds its extinction into: the packed counts and the per-channel first
+ * overflow, both atomics, so fragment-only. Every splat that writes through `avboit_splat_slice` binds
+ * this group.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_SPLAT_VOLUME_GROUP = new ShaderResourceGroupDescriptor();
 
-volume_group
+AVBOIT_SPLAT_VOLUME_GROUP
     .addStorageBuffer("extinction_volume", WebGPUArray.from(atomic_u32), true)
     .addStorageBuffer("overflow_slice", WebGPUArray.from(atomic_u32), true)
 ;
 
-const pass_groups = [view_group, volume_group];
+const pass_groups = [view_group, AVBOIT_SPLAT_VOLUME_GROUP];
 
 /*
  The layout is built group by group rather than with one visibility for every group: WebGPU refuses
@@ -67,7 +74,7 @@ const pass_groups = [view_group, volume_group];
 */
 const pass_layouts = [
     view_group.generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-    volume_group.generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT),
+    AVBOIT_SPLAT_VOLUME_GROUP.generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT),
 ];
 
 const shader_vertex = ShaderDescriptor.from({

package/src/shade/renderer/trails/GPUTrailAVBOITChannel.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The GPU trails as an `AVBOITSideChannel`: drawn inside the transparency pipeline, order-independently
+ * against the transparent meshes, the particles, the dynamic meshes and each other.
+ *
+ * - **occupancy** — the segments pass: a thread per live segment, culled by fade and by the view
+ *   frustum, marking the depth slices its capsule spans and appending itself to its draw class's list.
+ * - **splat** and **draw** — the unlit pair the dynamic meshes draw through, with the tube extruded in
+ *   the vertex stage: one indexed indirect draw per draw class, a segment an instance.
+ *
+ * The frame's simulation is recorded before this is asked (the trails' frame extension runs at
+ * AfterLighting); {@link begin_frame} hands it over with the view it was recorded for. A registered
+ * trail makes the channel non-empty: whether every trail has faded is the GPU's to know, and the CPU
+ * does not read it back.
+ */
+export class GPUTrailAVBOITChannel {
+    /**
+     * The frame's simulation, for the view it is drawn in.
+     *
+     * @param {object} graph
+     * @param {import("../view/GPUViewContext.js").GPUViewContext} view
+     * @param {import("./GPUTrailSystem.js").GPUTrailSystem} runtime
+     * @param {import("./graph_trails.js").TrailSimulationHandles} simulation
+     */
+    begin_frame(graph: object, view: import("../view/GPUViewContext.js").GPUViewContext, runtime: import("./GPUTrailSystem.js").GPUTrailSystem, simulation: import("./graph_trails.js").TrailSimulationHandles): void;
+    /**
+     * Forget the frame: the passes carry their own references to what they read.
+     */
+    end_frame(): void;
+    /**
+     * @param {import("../view/GPUViewContext.js").GPUViewContext} view
+     * @returns {boolean}
+     */
+    avboit_is_empty(view: import("../view/GPUViewContext.js").GPUViewContext): boolean;
+    avboit_occupancy({ graph, camera, cluster_parameters, occupancy }: {
+        graph: any;
+        camera: any;
+        cluster_parameters: any;
+        occupancy: any;
+    }): number;
+    avboit_splat({ graph, camera, warp, voxel_resolution, volume }: {
+        graph: any;
+        camera: any;
+        warp: any;
+        voxel_resolution: any;
+        volume: any;
+    }): {
+        extinction: number;
+        overflow: number;
+        dummy: number;
+    };
+    avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators }: {
+        graph: any;
+        view_ctx: any;
+        camera: any;
+        depth_texture: any;
+        warp: any;
+        integral: any;
+        volumetrics_lut: any;
+        volumetrics_metadata: any;
+        accumulators: any;
+    }): {
+        color: number;
+        norm: number;
+        extinction: number;
+        emission: number;
+    };
+    #private;
+}
+//# sourceMappingURL=GPUTrailAVBOITChannel.d.ts.map

package/src/shade/renderer/trails/GPUTrailAVBOITChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GPUTrailAVBOITChannel.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/trails/GPUTrailAVBOITChannel.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;IAMI;;;;;;;OAOG;IACH,mBALW,MAAM,QACN,OAAO,2BAA2B,EAAE,cAAc,WAClD,OAAO,qBAAqB,EAAE,cAAc,cAC5C,OAAO,mBAAmB,EAAE,sBAAsB,QAI5D;IAED;;OAEG;IACH,kBAEC;IAED;;;OAGG;IACH,sBAHW,OAAO,2BAA2B,EAAE,cAAc,GAChD,OAAO,CAMnB;IAED;;;;;eAaC;IAED;;;;;;;;;;MAeC;IAED;;;;;;;;;;;;;;;MAgCC;;CAYJ"}

package/src/shade/renderer/trails/GPUTrailAVBOITChannel.js

@@ -0,0 +1,129 @@
+import { assert } from "../../../core/assert.js";
+import { graph_trails_avboit_draw, graph_trails_avboit_segments, graph_trails_avboit_splat } from "./graph_trails_avboit.js";
+
+/**
+ * The GPU trails as an `AVBOITSideChannel`: drawn inside the transparency pipeline, order-independently
+ * against the transparent meshes, the particles, the dynamic meshes and each other.
+ *
+ * - **occupancy** — the segments pass: a thread per live segment, culled by fade and by the view
+ *   frustum, marking the depth slices its capsule spans and appending itself to its draw class's list.
+ * - **splat** and **draw** — the unlit pair the dynamic meshes draw through, with the tube extruded in
+ *   the vertex stage: one indexed indirect draw per draw class, a segment an instance.
+ *
+ * The frame's simulation is recorded before this is asked (the trails' frame extension runs at
+ * AfterLighting); {@link begin_frame} hands it over with the view it was recorded for. A registered
+ * trail makes the channel non-empty: whether every trail has faded is the GPU's to know, and the CPU
+ * does not read it back.
+ */
+export class GPUTrailAVBOITChannel {
+    /**
+     * @type {{graph: object, view: object, runtime: import("./GPUTrailSystem.js").GPUTrailSystem, simulation: import("./graph_trails.js").TrailSimulationHandles, segments: import("./graph_trails_avboit.js").TrailSegmentsHandles|null}|null}
+     */
+    #frame = null;
+
+    /**
+     * The frame's simulation, for the view it is drawn in.
+     *
+     * @param {object} graph
+     * @param {import("../view/GPUViewContext.js").GPUViewContext} view
+     * @param {import("./GPUTrailSystem.js").GPUTrailSystem} runtime
+     * @param {import("./graph_trails.js").TrailSimulationHandles} simulation
+     */
+    begin_frame(graph, view, runtime, simulation) {
+        this.#frame = { graph, view, runtime, simulation, segments: null };
+    }
+
+    /**
+     * Forget the frame: the passes carry their own references to what they read.
+     */
+    end_frame() {
+        this.#frame = null;
+    }
+
+    /**
+     * @param {import("../view/GPUViewContext.js").GPUViewContext} view
+     * @returns {boolean}
+     */
+    avboit_is_empty(view) {
+        const frame = this.#frame;
+
+        return frame === null || frame.view !== view || frame.runtime.count === 0;
+    }
+
+    avboit_occupancy({ graph, camera, cluster_parameters, occupancy }) {
+        const frame = this.#frame_for(graph);
+
+        frame.segments = graph_trails_avboit_segments({
+            graph,
+            camera,
+            cluster_parameters,
+            occupancy,
+            simulation: frame.simulation,
+            runtime: frame.runtime,
+        });
+
+        return frame.segments.occupancy;
+    }
+
+    avboit_splat({ graph, camera, warp, voxel_resolution, volume }) {
+        const frame = this.#frame_for(graph);
+
+        assert.notNull(frame.segments, "the occupancy was not recorded into this graph");
+
+        return graph_trails_avboit_splat({
+            graph,
+            camera,
+            warp,
+            voxel_resolution,
+            volume,
+            simulation: frame.simulation,
+            segments: frame.segments,
+            runtime: frame.runtime,
+        });
+    }
+
+    avboit_draw({
+                    graph,
+                    view_ctx,
+                    camera,
+                    depth_texture,
+                    warp,
+                    integral,
+                    volumetrics_lut,
+                    volumetrics_metadata,
+                    accumulators
+                }) {
+        const frame = this.#frame_for(graph);
+
+        assert.notNull(frame.segments, "the occupancy was not recorded into this graph");
+
+        // the last of the three: what is left is the passes'
+        this.#frame = null;
+
+        return graph_trails_avboit_draw({
+            graph,
+            view_ctx,
+            camera,
+            depth_texture,
+            warp,
+            integral,
+            volumetrics_lut,
+            volumetrics_metadata,
+            accumulators,
+            simulation: frame.simulation,
+            segments: frame.segments,
+            runtime: frame.runtime,
+        });
+    }
+
+    /**
+     * @param {object} graph
+     */
+    #frame_for(graph) {
+        const frame = this.#frame;
+
+        assert.ok(frame !== null && frame.graph === graph, "the trails' simulation was not recorded into this graph");
+
+        return frame;
+    }
+}