@woosh/meep-engine 3.29.0 → 3.31.0

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

@@ -1,167 +1,185 @@
-import { round_up } from "../../../core/math/round_up.js";
-import { DYNAMIC_MESH_DRAW_STRUCT, DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
-
-/**
- * Growth factor for the vertex and index buffers.
- *
- * Dynamic geometry changes size constantly — a trail lengthens as it is emitted and shortens as it
- * expires — so buffers are grown with headroom and never shrunk. Sizing exactly would mean
- * reallocating on almost every frame for content whose whole purpose is to change.
- *
- * @type {number}
- */
-const GROWTH_FACTOR = 1.5;
-
-/**
- * Storage buffers are bound by size, and a binding's size has to be a multiple of 4 — so a grown
- * capacity is rounded up rather than taken as the growth factor leaves it. Without this, a buffer
- * whose contents happen to land on the wrong number of bytes is rejected at bind time: 36 bytes of
- * indices grown by 1.5 gives 54, which is not a legal binding size.
- *
- * @type {number}
- */
-const BUFFER_SIZE_ALIGNMENT = 4;
-
-/**
- * What one {@link Geometry} owns on the GPU while it is being drawn by the dynamic path.
- *
- * Keyed on the geometry rather than on the mesh or on batch membership, so an effect that is hidden
- * for a frame, or removed and re-added, does not pay for its buffers again.
- */
-export class GPUDynamicMeshResidency {
-    /**
-     * Interleaved vertices, laid out per {@link DYNAMIC_MESH_VERTEX_STRIDE}.
-     *
-     * @type {GPUBuffer|null}
-     */
-    #vertices = null;
-
-    /**
-     * @type {number} capacity in bytes
-     */
-    #vertices_capacity = 0;
-
-    /**
-     * @type {GPUBuffer|null}
-     */
-    #indices = null;
-
-    /**
-     * @type {number} capacity in bytes
-     */
-    #indices_capacity = 0;
-
-    /**
-     * How many indices to draw — the count from the last upload, not the buffer's capacity.
-     *
-     * @type {number}
-     */
-    index_count = 0;
-
-    /**
-     * The {@link Geometry.version} this was uploaded from.
-     *
-     * @type {number}
-     */
-    version = -1;
-
-    /**
-     * @param {GPUDevice} device
-     * @param {Float32Array} staging interleaved vertices, valid up to `vertex_float_count`
-     * @param {number} vertex_float_count
-     * @param {Uint32Array} indices
-     */
-    write(device, staging, vertex_float_count, indices) {
-        const vertex_bytes = vertex_float_count * 4;
-        const index_bytes = indices.length * 4;
-
-        if (this.#vertices_capacity < vertex_bytes) {
-            if (this.#vertices !== null) {
-                this.#vertices.destroy();
-            }
-
-            this.#vertices_capacity = round_up(Math.ceil(vertex_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
-            this.#vertices = device.createBuffer({
-                size: this.#vertices_capacity,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-                label: "DynamicMesh/vertices",
-            });
-        }
-
-        if (this.#indices_capacity < index_bytes) {
-            if (this.#indices !== null) {
-                this.#indices.destroy();
-            }
-
-            this.#indices_capacity = round_up(Math.ceil(index_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
-            this.#indices = device.createBuffer({
-                size: this.#indices_capacity,
-                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
-                label: "DynamicMesh/indices",
-            });
-        }
-
-        device.queue.writeBuffer(this.#vertices, 0, staging.buffer, staging.byteOffset, vertex_bytes);
-        device.queue.writeBuffer(this.#indices, 0, indices.buffer, indices.byteOffset, index_bytes);
-
-        this.index_count = indices.length;
-    }
-
-    /**
-     * Build this mesh's bind groups for the frame.
-     *
-     * **Must be called before the render pass is opened.** The per-draw constants are staged through
-     * a transient buffer, and staging records a copy onto the command encoder — which WebGPU locks
-     * for as long as a pass is open on it. Doing this lazily at draw time is the obvious shape and
-     * an invalid one.
-     *
-     * The constants are transient because one mesh is one draw and its transform and colour are
-     * expected to differ every frame, so there is nothing worth keeping between them.
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {DynamicMesh} mesh
-     * @param {GPUBuffer} camera
-     * @returns {Array} bind groups, for {@link draw}
-     */
-    create_bindings(encoder, mesh, camera) {
-        const draw_buffer = encoder.allocateTransientValueBuffer(DYNAMIC_MESH_DRAW_STRUCT, {
-            model: mesh.transform.matrix,
-            color: mesh.color,
-        });
-
-        return DYNAMIC_MESH_RESOURCES.generateBindings({
-            camera,
-            draw: draw_buffer,
-            vertices: this.#vertices,
-            indices: this.#indices,
-        }, encoder);
-    }
-
-    /**
-     * @param {ShadeGPURenderPassEncoder} render_pass
-     * @param {GraphicsContext} graphics
-     * @param {RenderPipelineDescriptor} pipeline
-     * @param {Array} bindings from {@link create_bindings}
-     */
-    draw(render_pass, graphics, pipeline, bindings) {
-        graphics.setPipelineBindings(render_pass, pipeline, bindings);
-
-        render_pass.draw(this.index_count);
-    }
-
-    destroy() {
-        if (this.#vertices !== null) {
-            this.#vertices.destroy();
-            this.#vertices = null;
-        }
-
-        if (this.#indices !== null) {
-            this.#indices.destroy();
-            this.#indices = null;
-        }
-
-        this.#vertices_capacity = 0;
-        this.#indices_capacity = 0;
-        this.index_count = 0;
-    }
-}
+import { round_up } from "../../../core/math/round_up.js";
+import { DYNAMIC_MESH_DRAW_STRUCT, DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
+
+/**
+ * Growth factor for the vertex and index buffers.
+ *
+ * Dynamic geometry changes size constantly — a trail lengthens as it is emitted and shortens as it
+ * expires — so buffers are grown with headroom and never shrunk. Sizing exactly would mean
+ * reallocating on almost every frame for content whose whole purpose is to change.
+ *
+ * @type {number}
+ */
+const GROWTH_FACTOR = 1.5;
+
+/**
+ * Storage buffers are bound by size, and a binding's size has to be a multiple of 4 — so a grown
+ * capacity is rounded up rather than taken as the growth factor leaves it. Without this, a buffer
+ * whose contents happen to land on the wrong number of bytes is rejected at bind time: 36 bytes of
+ * indices grown by 1.5 gives 54, which is not a legal binding size.
+ *
+ * @type {number}
+ */
+const BUFFER_SIZE_ALIGNMENT = 4;
+
+/**
+ * What one {@link Geometry} owns on the GPU while it is being drawn by the dynamic path.
+ *
+ * Keyed on the geometry rather than on the mesh or on batch membership, so an effect that is hidden
+ * for a frame, or removed and re-added, does not pay for its buffers again.
+ */
+export class GPUDynamicMeshResidency {
+    /**
+     * Interleaved vertices, laid out per {@link DYNAMIC_MESH_VERTEX_STRIDE}.
+     *
+     * @type {GPUBuffer|null}
+     */
+    #vertices = null;
+
+    /**
+     * @type {number} capacity in bytes
+     */
+    #vertices_capacity = 0;
+
+    /**
+     * @type {GPUBuffer|null}
+     */
+    #indices = null;
+
+    /**
+     * @type {number} capacity in bytes
+     */
+    #indices_capacity = 0;
+
+    /**
+     * How many indices to draw — the count from the last upload, not the buffer's capacity.
+     *
+     * @type {number}
+     */
+    index_count = 0;
+
+    /**
+     * The {@link Geometry.version} this was uploaded from.
+     *
+     * @type {number}
+     */
+    version = -1;
+
+    /**
+     * @param {GPUDevice} device
+     * @param {Float32Array} staging interleaved vertices, valid up to `vertex_float_count`
+     * @param {number} vertex_float_count
+     * @param {Uint32Array} indices
+     */
+    write(device, staging, vertex_float_count, indices) {
+        const vertex_bytes = vertex_float_count * 4;
+        const index_bytes = indices.length * 4;
+
+        if (this.#vertices_capacity < vertex_bytes) {
+            if (this.#vertices !== null) {
+                this.#vertices.destroy();
+            }
+
+            this.#vertices_capacity = round_up(Math.ceil(vertex_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
+            this.#vertices = device.createBuffer({
+                size: this.#vertices_capacity,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+                label: "DynamicMesh/vertices",
+            });
+        }
+
+        if (this.#indices_capacity < index_bytes) {
+            if (this.#indices !== null) {
+                this.#indices.destroy();
+            }
+
+            this.#indices_capacity = round_up(Math.ceil(index_bytes * GROWTH_FACTOR), BUFFER_SIZE_ALIGNMENT);
+            this.#indices = device.createBuffer({
+                size: this.#indices_capacity,
+                usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+                label: "DynamicMesh/indices",
+            });
+        }
+
+        /*
+         Nothing to write means there is no buffer to write it to.
+
+         The allocations above only run when the capacity is SHORT of what the write needs, and on
+         the first write of an empty geometry that test is 0 < 0 — so the buffer stays null and
+         these two calls used to take the frame down from inside a frame-graph pass callback. A
+         null buffer can only ever pair with a zero byte count, which is what makes this the whole
+         guard; index_count is left truthful, and the draw-time index_count === 0 test skips it.
+
+         Reachable on the first upload rather than on a shrink: a geometry that shrinks has already
+         grown its buffers, and Trail3DSystem.link and PathDisplaySystem both build a DynamicMesh
+         from a Geometry that can already be empty.
+        */
+        if (vertex_bytes > 0) {
+            device.queue.writeBuffer(this.#vertices, 0, staging.buffer, staging.byteOffset, vertex_bytes);
+        }
+
+        if (index_bytes > 0) {
+            device.queue.writeBuffer(this.#indices, 0, indices.buffer, indices.byteOffset, index_bytes);
+        }
+
+        this.index_count = indices.length;
+    }
+
+    /**
+     * Build this mesh's bind groups for the frame.
+     *
+     * **Must be called before the render pass is opened.** The per-draw constants are staged through
+     * a transient buffer, and staging records a copy onto the command encoder — which WebGPU locks
+     * for as long as a pass is open on it. Doing this lazily at draw time is the obvious shape and
+     * an invalid one.
+     *
+     * The constants are transient because one mesh is one draw and its transform and colour are
+     * expected to differ every frame, so there is nothing worth keeping between them.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {DynamicMesh} mesh
+     * @param {GPUBuffer} camera
+     * @returns {Array} bind groups, for {@link draw}
+     */
+    create_bindings(encoder, mesh, camera) {
+        const draw_buffer = encoder.allocateTransientValueBuffer(DYNAMIC_MESH_DRAW_STRUCT, {
+            model: mesh.transform.matrix,
+            color: mesh.color,
+        });
+
+        return DYNAMIC_MESH_RESOURCES.generateBindings({
+            camera,
+            draw: draw_buffer,
+            vertices: this.#vertices,
+            indices: this.#indices,
+        }, encoder);
+    }
+
+    /**
+     * @param {ShadeGPURenderPassEncoder} render_pass
+     * @param {GraphicsContext} graphics
+     * @param {RenderPipelineDescriptor} pipeline
+     * @param {Array} bindings from {@link create_bindings}
+     */
+    draw(render_pass, graphics, pipeline, bindings) {
+        graphics.setPipelineBindings(render_pass, pipeline, bindings);
+
+        render_pass.draw(this.index_count);
+    }
+
+    destroy() {
+        if (this.#vertices !== null) {
+            this.#vertices.destroy();
+            this.#vertices = null;
+        }
+
+        if (this.#indices !== null) {
+            this.#indices.destroy();
+            this.#indices = null;
+        }
+
+        this.#vertices_capacity = 0;
+        this.#indices_capacity = 0;
+        this.index_count = 0;
+    }
+}

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

@@ -0,0 +1,49 @@
+/**
+ * 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 {
+    /**
+     * 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: GPUDevice, meshes: DynamicMesh[]): void;
+    /**
+     * 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: Geometry): GPUDynamicMeshResidency | undefined;
+    /**
+     * 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: Geometry): boolean;
+    destroy(): void;
+    #private;
+}
+import { GPUDynamicMeshResidency } from "./GPUDynamicMeshResidency.js";
+//# sourceMappingURL=GPUDynamicMeshResidencyTable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GPUDynamicMeshResidencyTable.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/GPUDynamicMeshResidencyTable.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH;IAoBI;;;;;;;;;;;;;;;;OAgBG;IACH,kCAFW,aAAa,QAoBvB;IAsED;;;;;;OAMG;IACH,yBAFa,uBAAuB,GAAC,SAAS,CAI7C;IAED;;;;;;OAMG;IACH,6BAFa,OAAO,CAcnB;IAED,gBAQC;;CACJ;wCAjLuC,8BAA8B"}

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,
+    ]
+);