@woosh/meep-engine 3.30.0 → 3.32.0

package/src/shade/renderer/dynamic/GPUDynamicMeshResidencyTable.js

@@ -0,0 +1,185 @@
+import { assert } from "../../../core/assert.js";
+import { StandardAttributes } from "../geometry/StandardAttributes.js";
+import {
+    DYNAMIC_MESH_VERTEX_COLOR_OFFSET,
+    DYNAMIC_MESH_VERTEX_POSITION_OFFSET,
+    DYNAMIC_MESH_VERTEX_STRIDE
+} from "./DYNAMIC_MESH_VERTEX.js";
+import { GPUDynamicMeshResidency } from "./GPUDynamicMeshResidency.js";
+
+/**
+ * The GPU buffers a set of {@link DynamicMesh}es' geometries live in, and the upload that keeps them
+ * current — owned by whatever draws the meshes: {@link GPUDynamicMeshRenderer} for a pass over the
+ * scene, {@link DynamicMeshAVBOITChannel} for the transparency pipeline.
+ *
+ * Residency is keyed on the **geometry**, not on batch membership: an effect that blinks off for a
+ * frame, or is removed and re-added, keeps its buffers. The flip side is that nothing frees them
+ * unless the owner says the geometry is gone for good ({@link release}).
+ */
+export class GPUDynamicMeshResidencyTable {
+    /**
+     * @type {Map<Geometry, GPUDynamicMeshResidency>}
+     */
+    #residency = new Map();
+
+    /**
+     * Staging for one geometry's interleaved vertices, grown as needed and reused across uploads.
+     *
+     * @type {Float32Array}
+     */
+    #staging = new Float32Array();
+
+    /**
+     * The device the buffers in {@link #residency} were made on; `null` while there are none.
+     *
+     * @type {GPUDevice|null}
+     */
+    #device = null;
+
+    /**
+     * Bring the geometry of every visible mesh up to date on the GPU, allocating for the ones that
+     * have never been seen and re-uploading the ones whose `version` has moved.
+     *
+     * Called from inside a frame-graph pass, because the device is reached through the
+     * `GraphicsContext` the frame graph hands out at execution time and no ECS system holds one.
+     * Uploads are queue writes and stay ahead of the frame's commands regardless of when in the
+     * recording they are issued.
+     *
+     * **A different device drops everything held.** `GraphicsEngine` survives a stop and a start,
+     * and so do the systems whose tables these are, but the device does not: a buffer made on the
+     * old one cannot be written or bound on the new one, and a geometry whose version has not moved
+     * says nothing about that. Everything is uploaded again, onto the device that asked.
+     *
+     * @param {GPUDevice} device
+     * @param {DynamicMesh[]} meshes
+     */
+    upload(device, meshes) {
+        if (this.#device !== device) {
+            this.destroy();
+
+            this.#device = device;
+        }
+
+        const count = meshes.length;
+
+        for (let i = 0; i < count; i++) {
+            const mesh = meshes[i];
+
+            if (!mesh.visible) {
+                continue;
+            }
+
+            this.#upload(device, mesh.geometry);
+        }
+    }
+
+    /**
+     * @param {GPUDevice} device
+     * @param {Geometry} geometry
+     */
+    #upload(device, geometry) {
+        let residency = this.#residency.get(geometry);
+
+        if (residency === undefined) {
+            residency = new GPUDynamicMeshResidency();
+
+            this.#residency.set(geometry, residency);
+        } else if (residency.version === geometry.version) {
+            return;
+        }
+
+        const position = geometry.getAttribute(StandardAttributes.Position);
+
+        assert.defined(position, 'geometry must carry a position attribute');
+        assert.notNull(geometry.index, 'geometry must carry an index');
+
+        const vertex_count = position.count;
+        const required = vertex_count * DYNAMIC_MESH_VERTEX_STRIDE;
+
+        if (this.#staging.length < required) {
+            this.#staging = new Float32Array(required);
+        }
+
+        const staging = this.#staging;
+        const positions = position.data;
+        const colors = geometry.getAttribute(StandardAttributes.Color);
+
+        for (let i = 0; i < vertex_count; i++) {
+            const target = i * DYNAMIC_MESH_VERTEX_STRIDE;
+            const source = i * 3;
+
+            staging[target + DYNAMIC_MESH_VERTEX_POSITION_OFFSET] = positions[source];
+            staging[target + DYNAMIC_MESH_VERTEX_POSITION_OFFSET + 1] = positions[source + 1];
+            staging[target + DYNAMIC_MESH_VERTEX_POSITION_OFFSET + 2] = positions[source + 2];
+
+            staging[target + DYNAMIC_MESH_VERTEX_COLOR_OFFSET] = 1;
+            staging[target + DYNAMIC_MESH_VERTEX_COLOR_OFFSET + 1] = 1;
+            staging[target + DYNAMIC_MESH_VERTEX_COLOR_OFFSET + 2] = 1;
+            staging[target + DYNAMIC_MESH_VERTEX_COLOR_OFFSET + 3] = 1;
+        }
+
+        // Per-vertex colour is what fades a trail along its length, and geometry that does not carry
+        // any keeps the white written above — so the shader has one path whether or not it was
+        // authored. This is the only place the distinction exists.
+        if (colors !== undefined) {
+            const color_data = colors.data;
+            const components = colors.spec.itemSize;
+
+            for (let i = 0; i < vertex_count; i++) {
+                const target = i * DYNAMIC_MESH_VERTEX_STRIDE + DYNAMIC_MESH_VERTEX_COLOR_OFFSET;
+                const source = i * components;
+
+                for (let c = 0; c < components; c++) {
+                    staging[target + c] = color_data[source + c];
+                }
+            }
+        }
+
+        const index_data = geometry.index.data;
+
+        residency.write(device, staging, required, index_data);
+        residency.version = geometry.version;
+    }
+
+    /**
+     * What the last {@link upload} left for `geometry`, or `undefined` if it has never been
+     * uploaded (or has been released since).
+     *
+     * @param {Geometry} geometry
+     * @returns {GPUDynamicMeshResidency|undefined}
+     */
+    get(geometry) {
+        return this.#residency.get(geometry);
+    }
+
+    /**
+     * Release the GPU buffers held for `geometry`. A dynamic mesh that is gone for good should say
+     * so — residency deliberately survives removal from the batch, so nothing else will free it.
+     *
+     * @param {Geometry} geometry
+     * @returns {boolean} whether anything was held
+     */
+    release(geometry) {
+        const residency = this.#residency.get(geometry);
+
+        if (residency === undefined) {
+            return false;
+        }
+
+        residency.destroy();
+
+        this.#residency.delete(geometry);
+
+        return true;
+    }
+
+    destroy() {
+        for (const residency of this.#residency.values()) {
+            residency.destroy();
+        }
+
+        this.#residency.clear();
+
+        this.#device = null;
+    }
+}

package/src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The vertex stage both AVBOIT passes draw a dynamic mesh with — the splat at the volume's
+ * resolution and the draw at internal resolution — so the two see the same fragments at the same
+ * depths.
+ *
+ * `view_depth` is the vertex's own view-space depth, interpolated across the triangle: what the
+ * splat positions a fragment's extinction by and what the draw looks the volume up at. Both passes
+ * take it from here rather than reconstructing it from `@builtin(position).z`, the arrangement the
+ * particles' billboard stage has for the same reason. `color` is straight — not premultiplied — as
+ * the vertices hold it.
+ *
+ * Both are interpolated at the **centroid** of the samples the triangle covers. The splat is
+ * multisampled, and a thin triangle can cover some of a pixel's samples but not its centre; at the
+ * centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon seen
+ * nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where a
+ * fragment exists only if the centre is covered and the centroid is the centre.
+ *
+ * The enclosing shader binds the dynamic-mesh group (`DYNAMIC_MESH_RESOURCES`), `camera` included.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_dynamic_mesh_avboit_vertex: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_dynamic_mesh_avboit_vertex.d.ts.map

package/src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_dynamic_mesh_avboit_vertex.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,+CAFU,SAAS,CA0BjB;0BAhDwB,iCAAiC"}

package/src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.js

@@ -0,0 +1,49 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_dynamic_mesh_vertex } from "./chunk_dynamic_mesh_vertex.js";
+
+/**
+ * The vertex stage both AVBOIT passes draw a dynamic mesh with — the splat at the volume's
+ * resolution and the draw at internal resolution — so the two see the same fragments at the same
+ * depths.
+ *
+ * `view_depth` is the vertex's own view-space depth, interpolated across the triangle: what the
+ * splat positions a fragment's extinction by and what the draw looks the volume up at. Both passes
+ * take it from here rather than reconstructing it from `@builtin(position).z`, the arrangement the
+ * particles' billboard stage has for the same reason. `color` is straight — not premultiplied — as
+ * the vertices hold it.
+ *
+ * Both are interpolated at the **centroid** of the samples the triangle covers. The splat is
+ * multisampled, and a thin triangle can cover some of a pixel's samples but not its centre; at the
+ * centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon seen
+ * nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where a
+ * fragment exists only if the centre is covered and the centroid is the centre.
+ *
+ * The enclosing shader binds the dynamic-mesh group (`DYNAMIC_MESH_RESOURCES`), `camera` included.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_dynamic_mesh_avboit_vertex = CodeChunk.from(
+    //language=WGSL
+    `
+struct DynamicMeshAVBOITVertexOut {
+    @builtin(position) clip : vec4<f32>,
+    @location(0) @interpolate(perspective, centroid) color : vec4<f32>,
+    @location(1) @interpolate(perspective, centroid) view_depth : f32,
+}
+
+fn dynamic_mesh_avboit_vertex(vertex_index : u32) -> DynamicMeshAVBOITVertexOut {
+    let vertex = dynamic_mesh_vertex(vertex_index);
+
+    var out : DynamicMeshAVBOITVertexOut;
+
+    out.clip = camera.view_projection_matrix * vertex.world;
+    out.color = vertex.color;
+    // the camera looks down -Z, so depth is -z
+    out.view_depth = -(camera.view_matrix * vertex.world).z;
+
+    return out;
+}
+    `, [
+        chunk_dynamic_mesh_vertex,
+    ]
+);

package/src/shade/renderer/dynamic/chunk_dynamic_mesh_vertex.d.ts

@@ -0,0 +1,18 @@
+/**
+ * One vertex of a {@link DynamicMesh}, pulled from its storage buffers and carried into the world:
+ * the index at `vertex_index`, the vertex it names, its position through the draw's `model` and its
+ * colour multiplied by the draw's flat `color`.
+ *
+ * Vertices are pulled from storage rather than bound as vertex buffers, which is how the rest of the
+ * engine reads geometry: one pipeline then serves every dynamic mesh, whatever it holds.
+ *
+ * The enclosing shader binds the dynamic-mesh group (`DYNAMIC_MESH_RESOURCES`) — `draw`,
+ * `vertices` and `indices` under those names. Shared by every pipeline that draws a dynamic mesh —
+ * the blended and opaque passes over the scene, and the AVBOIT splat and draw — so the one vertex
+ * layout ({@link DYNAMIC_MESH_VERTEX_STRIDE}) is read in exactly one place.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_dynamic_mesh_vertex: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_dynamic_mesh_vertex.d.ts.map

package/src/shade/renderer/dynamic/chunk_dynamic_mesh_vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_dynamic_mesh_vertex.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/chunk_dynamic_mesh_vertex.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,wCAFU,SAAS,CAiCjB;0BArDwB,iCAAiC"}

package/src/shade/renderer/dynamic/chunk_dynamic_mesh_vertex.js

@@ -0,0 +1,54 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import {
+    DYNAMIC_MESH_VERTEX_COLOR_OFFSET,
+    DYNAMIC_MESH_VERTEX_POSITION_OFFSET,
+    DYNAMIC_MESH_VERTEX_STRIDE
+} from "./DYNAMIC_MESH_VERTEX.js";
+
+/**
+ * One vertex of a {@link DynamicMesh}, pulled from its storage buffers and carried into the world:
+ * the index at `vertex_index`, the vertex it names, its position through the draw's `model` and its
+ * colour multiplied by the draw's flat `color`.
+ *
+ * Vertices are pulled from storage rather than bound as vertex buffers, which is how the rest of the
+ * engine reads geometry: one pipeline then serves every dynamic mesh, whatever it holds.
+ *
+ * The enclosing shader binds the dynamic-mesh group (`DYNAMIC_MESH_RESOURCES`) — `draw`,
+ * `vertices` and `indices` under those names. Shared by every pipeline that draws a dynamic mesh —
+ * the blended and opaque passes over the scene, and the AVBOIT splat and draw — so the one vertex
+ * layout ({@link DYNAMIC_MESH_VERTEX_STRIDE}) is read in exactly one place.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_dynamic_mesh_vertex = CodeChunk.from(
+    //language=WGSL
+    `
+const DYNAMIC_MESH_VERTEX_STRIDE : u32 = ${DYNAMIC_MESH_VERTEX_STRIDE}u;
+const DYNAMIC_MESH_VERTEX_POSITION_OFFSET : u32 = ${DYNAMIC_MESH_VERTEX_POSITION_OFFSET}u;
+const DYNAMIC_MESH_VERTEX_COLOR_OFFSET : u32 = ${DYNAMIC_MESH_VERTEX_COLOR_OFFSET}u;
+
+struct DynamicMeshVertex {
+    world : vec4<f32>,
+    color : vec4<f32>,
+}
+
+fn dynamic_mesh_vertex(vertex_index : u32) -> DynamicMeshVertex {
+    let base = indices[vertex_index] * DYNAMIC_MESH_VERTEX_STRIDE;
+
+    let position = vec3<f32>(
+        vertices[base + DYNAMIC_MESH_VERTEX_POSITION_OFFSET],
+        vertices[base + DYNAMIC_MESH_VERTEX_POSITION_OFFSET + 1u],
+        vertices[base + DYNAMIC_MESH_VERTEX_POSITION_OFFSET + 2u],
+    );
+
+    let color = vec4<f32>(
+        vertices[base + DYNAMIC_MESH_VERTEX_COLOR_OFFSET],
+        vertices[base + DYNAMIC_MESH_VERTEX_COLOR_OFFSET + 1u],
+        vertices[base + DYNAMIC_MESH_VERTEX_COLOR_OFFSET + 2u],
+        vertices[base + DYNAMIC_MESH_VERTEX_COLOR_OFFSET + 3u],
+    );
+
+    return DynamicMeshVertex(draw.model * vec4<f32>(position, 1.0), color * draw.color);
+}
+    `
+);

package/src/shade/renderer/dynamic/dynamic_mesh_live_bounds.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The object-space bounds of the part of a dynamic mesh's geometry that can put anything on
+ * screen: every triangle with at least one vertex of positive alpha, all three of its vertices.
+ *
+ * **Per triangle, not per vertex.** A vertex that has faded to nothing still bounds the triangles
+ * it shares with ones that have not, and those triangles draw — alpha is interpolated across them —
+ * right up to the faded corner. A trail's tail is exactly that: the last live ring joined to the
+ * first one that has aged out. Bounds from the live vertices alone would stop a segment short and
+ * leave the faint end of every trail outside what the AVBOIT occupancy marked.
+ *
+ * **Faded triangles are left out entirely**, and that is the point of taking bounds this way rather
+ * than over every position: an aged-out knot keeps the position it had, so a trail that has
+ * stopped moving, or a tube still holding the path it was seeded along, would otherwise reserve
+ * depth for geometry nobody can see.
+ *
+ * Alpha is the colour attribute's fourth component; a geometry with no colour attribute, or with
+ * one of fewer than four components, is opaque white where the upload is concerned, and so is
+ * entirely live here. The mesh's own flat colour is the caller's business.
+ *
+ * @param {Float32Array|number[]} result `[min_x, min_y, min_z, max_x, max_y, max_z]`, written only
+ *        when there is something to bound
+ * @param {Geometry} geometry
+ * @returns {boolean} whether any triangle is live
+ */
+export function dynamic_mesh_live_bounds(result: Float32Array | number[], geometry: Geometry): boolean;
+//# sourceMappingURL=dynamic_mesh_live_bounds.d.ts.map

package/src/shade/renderer/dynamic/dynamic_mesh_live_bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic_mesh_live_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/dynamic_mesh_live_bounds.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iDALW,YAAY,GAAC,MAAM,EAAE,uBAGnB,OAAO,CAuEnB"}

package/src/shade/renderer/dynamic/dynamic_mesh_live_bounds.js

@@ -0,0 +1,96 @@
+import { StandardAttributes } from "../geometry/StandardAttributes.js";
+
+/**
+ * The object-space bounds of the part of a dynamic mesh's geometry that can put anything on
+ * screen: every triangle with at least one vertex of positive alpha, all three of its vertices.
+ *
+ * **Per triangle, not per vertex.** A vertex that has faded to nothing still bounds the triangles
+ * it shares with ones that have not, and those triangles draw — alpha is interpolated across them —
+ * right up to the faded corner. A trail's tail is exactly that: the last live ring joined to the
+ * first one that has aged out. Bounds from the live vertices alone would stop a segment short and
+ * leave the faint end of every trail outside what the AVBOIT occupancy marked.
+ *
+ * **Faded triangles are left out entirely**, and that is the point of taking bounds this way rather
+ * than over every position: an aged-out knot keeps the position it had, so a trail that has
+ * stopped moving, or a tube still holding the path it was seeded along, would otherwise reserve
+ * depth for geometry nobody can see.
+ *
+ * Alpha is the colour attribute's fourth component; a geometry with no colour attribute, or with
+ * one of fewer than four components, is opaque white where the upload is concerned, and so is
+ * entirely live here. The mesh's own flat colour is the caller's business.
+ *
+ * @param {Float32Array|number[]} result `[min_x, min_y, min_z, max_x, max_y, max_z]`, written only
+ *        when there is something to bound
+ * @param {Geometry} geometry
+ * @returns {boolean} whether any triangle is live
+ */
+export function dynamic_mesh_live_bounds(result, geometry) {
+    const position = geometry.getAttribute(StandardAttributes.Position);
+    const index = geometry.index;
+
+    if (position === undefined || index === null) {
+        return false;
+    }
+
+    const positions = position.data;
+    const indices = index.data;
+    const index_count = indices.length - (indices.length % 3);
+
+    const color = geometry.getAttribute(StandardAttributes.Color);
+    const alphas = color !== undefined && color.spec.itemSize >= 4 ? color.data : null;
+    const alpha_stride = alphas !== null ? color.spec.itemSize : 0;
+
+    let min_x = Infinity;
+    let min_y = Infinity;
+    let min_z = Infinity;
+    let max_x = -Infinity;
+    let max_y = -Infinity;
+    let max_z = -Infinity;
+
+    let live = false;
+
+    for (let t = 0; t < index_count; t += 3) {
+        const a = indices[t];
+        const b = indices[t + 1];
+        const c = indices[t + 2];
+
+        if (
+            alphas !== null
+            && !(alphas[a * alpha_stride + 3] > 0)
+            && !(alphas[b * alpha_stride + 3] > 0)
+            && !(alphas[c * alpha_stride + 3] > 0)
+        ) {
+            continue;
+        }
+
+        live = true;
+
+        for (let k = 0; k < 3; k++) {
+            const p = (k === 0 ? a : (k === 1 ? b : c)) * 3;
+
+            const x = positions[p];
+            const y = positions[p + 1];
+            const z = positions[p + 2];
+
+            if (x < min_x) min_x = x;
+            if (y < min_y) min_y = y;
+            if (z < min_z) min_z = z;
+            if (x > max_x) max_x = x;
+            if (y > max_y) max_y = y;
+            if (z > max_z) max_z = z;
+        }
+    }
+
+    if (!live) {
+        return false;
+    }
+
+    result[0] = min_x;
+    result[1] = min_y;
+    result[2] = min_z;
+    result[3] = max_x;
+    result[4] = max_y;
+    result[5] = max_z;
+
+    return true;
+}

package/src/shade/renderer/dynamic/graph_dynamic_mesh_avboit.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Upload the live meshes, then mark the depth slices their world boxes span
+ * (`shader_dynamic_mesh_avboit_occupancy`).
+ *
+ * **This is the pass that brings the vertices up to date**, being the channel's first: the device is
+ * only reachable at execution time, and the splat and the draw that read the buffers run later in the
+ * same frame, behind the warp this pass's output feeds.
+ *
+ * @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 {GPUDynamicMeshResidencyTable} params.residency
+ * @param {DynamicMesh[]} params.meshes the live meshes, one box each
+ * @param {Float32Array} params.boxes world boxes, {@link DYNAMIC_MESH_AVBOIT_BOX_FLOATS} floats per mesh
+ * @returns {number} the occupancy handle after the write
+ */
+export function graph_dynamic_mesh_avboit_occupancy({ graph, camera, cluster_parameters, occupancy, residency, meshes, boxes, }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    camera: number;
+    cluster_parameters: ArrayLike<number>;
+    occupancy: number;
+    residency: GPUDynamicMeshResidencyTable;
+    meshes: DynamicMesh[];
+    boxes: Float32Array;
+}): number;
+/**
+ * Splat the live meshes' extinction into the voxel volume (`shader_dynamic_mesh_avboit_splat`).
+ *
+ * The raster is multisampled ({@link DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES}), so it cannot use the
+ * volume's single-sampled splat target: the pass makes its own at the volume's resolution, and hands
+ * the volume's back untouched.
+ *
+ * @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 {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 {GPUDynamicMeshResidencyTable} params.residency
+ * @param {DynamicMesh[]} params.meshes the live meshes
+ * @returns {{extinction: number, overflow: number, dummy: number}} the volume after the write
+ */
+export function graph_dynamic_mesh_avboit_splat({ graph, camera, warp, voxel_resolution, volume, residency, meshes, }: {
+    graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    camera: number;
+    warp: number;
+    voxel_resolution: number[];
+    volume: {
+        extinction: number;
+        overflow: number;
+        dummy: number;
+    };
+    residency: GPUDynamicMeshResidencyTable;
+    meshes: DynamicMesh[];
+}): {
+    extinction: number;
+    overflow: number;
+    dummy: number;
+};
+/**
+ * Draw the live meshes into the four accumulators (`shader_dynamic_mesh_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 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 {GPUDynamicMeshResidencyTable} params.residency
+ * @param {DynamicMesh[]} params.meshes the live meshes
+ * @returns {{color: number, norm: number, extinction: number, emission: number}} the accumulators after the draw
+ */
+export function graph_dynamic_mesh_avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators, residency, meshes, }: {
+    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;
+    };
+    residency: GPUDynamicMeshResidencyTable;
+    meshes: DynamicMesh[];
+}): {
+    color: number;
+    norm: number;
+    extinction: number;
+    emission: number;
+};
+//# sourceMappingURL=graph_dynamic_mesh_avboit.d.ts.map

package/src/shade/renderer/dynamic/graph_dynamic_mesh_avboit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_dynamic_mesh_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/graph_dynamic_mesh_avboit.js"],"names":[],"mappings":"AA2EA;;;;;;;;;;;;;;;;;GAiBG;AACH;IATkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IAC+B,SAAS;IACxB,MAAM,EAA5B,aAAa;IACQ,KAAK,EAA1B,YAAY;IACV,MAAM,CAqDlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH;IATkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACW,gBAAgB,EAAjC,MAAM,EAAE;IACsD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAChB,SAAS;IACxB,MAAM,EAA5B,aAAa;IACX;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA0FjE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH;IAbkG,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;IAC9B,SAAS;IACxB,MAAM,EAA5B,aAAa;IACX;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA+F/E"}