@woosh/meep-engine 3.31.0 → 3.33.0

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

@@ -24,17 +24,27 @@ export class GPUDynamicMeshRenderer {
      * Set before the first draw. Changing it later rebuilds the pipeline, which is cheap but not
      * free, and the whole batch moves together — this is a property of the pass, not of a mesh.
      *
+     * Solid content belongs at `FramePhase.AfterLighting`, with the depth {@link graph_draw} hands
+     * back published: transparency runs after that phase and tests against that depth, so glass in
+     * front of the batch covers it. At `AfterTransparency` the glass is already resolved, and the
+     * batch is drawn over it.
+     *
      * @type {boolean}
      */
     opaque: boolean;
     /**
      * Record the draws into `graph`, over the colour it is given.
      *
-     * When {@link opaque} is set the pass writes the depth it is given. That write lands in the
-     * same physical texture the handle names — a written handle is a renamed clone of one resource,
-     * not a second one — so a later pass reading the handle the caller still holds sees the depth
-     * this pass left. Only the colour is threaded back, because that is what an injected pass is
-     * allowed to replace.
+     * **Both handles come back, and the caller publishes both** — into `SceneColor` and
+     * `ViewTextures` from an extension. The colour is always replaced. The depth is replaced when
+     * {@link opaque} is set, since the pass writes it; otherwise it comes back as it was given.
+     *
+     * A written handle is a renamed clone of the same texture, so a pass that goes on reading the
+     * depth handle it held before this draw is reading a version this pass has superseded.
+     * `FrameGraph.validate` refuses that, and the frame fails to compile in a development build.
+     * A stripped build reads the right contents only because passes run in the order they were
+     * recorded. So every reader of the scene depth after this draw has to be handed the new handle:
+     * depth of field, motion blur, the NSS upscaler, the next extension along.
      *
      * @param {object} args
      * @param {FrameGraph} args.graph
@@ -42,7 +52,7 @@ export class GPUDynamicMeshRenderer {
      * @param {number} args.color colour resource handle to draw over
      * @param {number} args.depth scene depth, written when {@link opaque} and otherwise only tested
      * @param {GPUBuffer} args.camera
-     * @returns {number} the colour handle after the draws
+     * @returns {{color: number, depth: number}} the colour and depth handles after the draws
      */
     graph_draw({ graph, batch, color, depth, camera }: {
         graph: FrameGraph;
@@ -50,7 +60,10 @@ export class GPUDynamicMeshRenderer {
         color: number;
         depth: number;
         camera: GPUBuffer;
-    }): number;
+    }): {
+        color: number;
+        depth: number;
+    };
     /**
      * 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.

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

@@ -1 +1 @@
-{"version":3,"file":"GPUDynamicMeshRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/GPUDynamicMeshRenderer.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;GAWG;AACH;IACI;;;;;;;;;;;;;;OAcG;IACH,QAFU,OAAO,CAEF;IAiBf;;;;;;;;;;;;;;;;OAgBG;IACH;QAP4B,KAAK;QACC,KAAK;QACf,KAAK,EAAlB,MAAM;QACO,KAAK,EAAlB,MAAM;QACU,MAAM;QACpB,MAAM,CAuBlB;IAqHD;;;;;;OAMG;IACH,6BAFa,OAAO,CAInB;IAED,gBAEC;;CACJ"}
+{"version":3,"file":"GPUDynamicMeshRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/GPUDynamicMeshRenderer.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH;IACI;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAFU,OAAO,CAEF;IA0Bf;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH;QAP4B,KAAK;QACC,KAAK;QACf,KAAK,EAAlB,MAAM;QACO,KAAK,EAAlB,MAAM;QACU,MAAM;QACpB;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CA0B1C;IA4FD;;;;;;OAMG;IACH,6BAFa,OAAO,CAInB;IAED,gBAEC;;CACJ"}

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

@@ -1,6 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
 import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
+import { GPUDynamicMeshDrawList } from "./GPUDynamicMeshDrawList.js";
 import { GPUDynamicMeshResidencyTable } from "./GPUDynamicMeshResidencyTable.js";
 import { create_dynamic_mesh_pipeline } from "./shader_dynamic_mesh.js";
 
@@ -30,6 +31,11 @@ export class GPUDynamicMeshRenderer {
      * Set before the first draw. Changing it later rebuilds the pipeline, which is cheap but not
      * free, and the whole batch moves together — this is a property of the pass, not of a mesh.
      *
+     * Solid content belongs at `FramePhase.AfterLighting`, with the depth {@link graph_draw} hands
+     * back published: transparency runs after that phase and tests against that depth, so glass in
+     * front of the batch covers it. At `AfterTransparency` the glass is already resolved, and the
+     * batch is drawn over it.
+     *
      * @type {boolean}
      */
     opaque = false;
@@ -39,6 +45,15 @@ export class GPUDynamicMeshRenderer {
      */
     #residency = new GPUDynamicMeshResidencyTable();
 
+    /**
+     * The draws of the frame being executed. Written, drawn and cleared within one pass callback, so
+     * one list serves every frame and every graph this renderer draws into, and holds nothing between
+     * them.
+     *
+     * @type {GPUDynamicMeshDrawList}
+     */
+    #draws = new GPUDynamicMeshDrawList();
+
     /**
      * @type {RenderPipelineDescriptor|null}
      */
@@ -52,11 +67,16 @@ export class GPUDynamicMeshRenderer {
     /**
      * Record the draws into `graph`, over the colour it is given.
      *
-     * When {@link opaque} is set the pass writes the depth it is given. That write lands in the
-     * same physical texture the handle names — a written handle is a renamed clone of one resource,
-     * not a second one — so a later pass reading the handle the caller still holds sees the depth
-     * this pass left. Only the colour is threaded back, because that is what an injected pass is
-     * allowed to replace.
+     * **Both handles come back, and the caller publishes both** — into `SceneColor` and
+     * `ViewTextures` from an extension. The colour is always replaced. The depth is replaced when
+     * {@link opaque} is set, since the pass writes it; otherwise it comes back as it was given.
+     *
+     * A written handle is a renamed clone of the same texture, so a pass that goes on reading the
+     * depth handle it held before this draw is reading a version this pass has superseded.
+     * `FrameGraph.validate` refuses that, and the frame fails to compile in a development build.
+     * A stripped build reads the right contents only because passes run in the order they were
+     * recorded. So every reader of the scene depth after this draw has to be handed the new handle:
+     * depth of field, motion blur, the NSS upscaler, the next extension along.
      *
      * @param {object} args
      * @param {FrameGraph} args.graph
@@ -64,7 +84,7 @@ export class GPUDynamicMeshRenderer {
      * @param {number} args.color colour resource handle to draw over
      * @param {number} args.depth scene depth, written when {@link opaque} and otherwise only tested
      * @param {GPUBuffer} args.camera
-     * @returns {number} the colour handle after the draws
+     * @returns {{color: number, depth: number}} the colour and depth handles after the draws
      */
     graph_draw({ graph, batch, color, depth, camera }) {
         assert.defined(graph, 'graph');
@@ -86,7 +106,10 @@ export class GPUDynamicMeshRenderer {
         data.depth = data.opaque ? pass.write(depth) : pass.read(depth);
         data.color = pass.write(pass.read(color));
 
-        return data.color;
+        return {
+            color: data.color,
+            depth: data.depth,
+        };
     }
 
     /**
@@ -97,38 +120,16 @@ export class GPUDynamicMeshRenderer {
      * @param {GPUBuffer} camera
      */
     #execute(data, resources, context, batch, camera) {
-        const meshes = batch.meshes;
-        const count = meshes.length;
-
-        if (count === 0) {
-            return;
-        }
-
         const encoder = context.encoder;
         const graphics = context.graphics;
 
-        // Every per-draw resource is built first: staging a uniform records a copy onto the command
-        // encoder, and the encoder is locked for as long as a render pass is open on it.
-        const draws = [];
-
-        for (let i = 0; i < count; i++) {
-            const mesh = meshes[i];
-
-            if (!mesh.visible) {
-                continue;
-            }
+        // Written before the pass is opened: the constants go up through copies recorded onto the
+        // command encoder, and the encoder is locked for as long as a render pass is open on it.
+        const draws = this.#draws;
 
-            const residency = this.#residency.get(mesh.geometry);
+        draws.write(encoder, this.#residency, batch.meshes);
 
-            if (residency === undefined || residency.index_count === 0) {
-                // never uploaded, or empty
-                continue;
-            }
-
-            draws.push({ residency, bindings: residency.create_bindings(encoder, mesh, camera) });
-        }
-
-        if (draws.length === 0) {
+        if (draws.count === 0) {
             return;
         }
 
@@ -146,8 +147,7 @@ export class GPUDynamicMeshRenderer {
         const render_pass = encoder.constructRenderPass({
             label: "Dynamic Mesh",
             pipeline,
-            // Bind groups differ per mesh — each has its own vertex and index buffers — so they are
-            // set per draw rather than once for the pass.
+            // The constants' group is set per chunk and the geometry's per draw, by the draws.
             bindings: [],
             colorAttachments: [{
                 loadOp: "load",
@@ -171,13 +171,11 @@ export class GPUDynamicMeshRenderer {
                 },
         });
 
-        for (let i = 0; i < draws.length; i++) {
-            const entry = draws[i];
-
-            entry.residency.draw(render_pass, graphics, pipeline, entry.bindings);
-        }
+        draws.draw(render_pass, graphics, pipeline, camera);
 
         render_pass.end();
+
+        draws.clear();
     }
 
     /**

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

@@ -25,29 +25,15 @@ export class GPUDynamicMeshResidency {
      */
     write(device: GPUDevice, staging: Float32Array, vertex_float_count: number, indices: Uint32Array): void;
     /**
-     * Build this mesh's bind groups for the frame.
+     * Draw this geometry: bind its group and draw its indices as the one instance `slot`, which is
+     * the row of the constants the pass has bound that the draw reads (`GPUDynamicMeshDrawList`).
      *
-     * **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: ShadeGPUCommandContext, mesh: DynamicMesh, camera: GPUBuffer): any[];
-    /**
-     * @param {ShadeGPURenderPassEncoder} render_pass
+     * @param {ShadeGPURenderPassEncoder} render_pass running `pipeline`, with its constants' group set
      * @param {GraphicsContext} graphics
-     * @param {RenderPipelineDescriptor} pipeline
-     * @param {Array} bindings from {@link create_bindings}
+     * @param {RenderPipelineDescriptor} pipeline a dynamic-mesh pipeline
+     * @param {number} slot this draw's row in the bound chunk of constants
      */
-    draw(render_pass: ShadeGPURenderPassEncoder, graphics: GraphicsContext, pipeline: RenderPipelineDescriptor, bindings: any[]): void;
+    draw(render_pass: ShadeGPURenderPassEncoder, graphics: GraphicsContext, pipeline: RenderPipelineDescriptor, slot: number): void;
     destroy(): void;
     #private;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"GPUDynamicMeshResidency.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/GPUDynamicMeshResidency.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH;IAuBI;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,kCAJW,YAAY,sBACZ,MAAM,WACN,WAAW,QAsDrB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8FAYC;IAED;;;;;OAKG;IACH,mIAIC;IAED,gBAcC;;CACJ"}
+{"version":3,"file":"GPUDynamicMeshResidency.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/GPUDynamicMeshResidency.js"],"names":[],"mappings":"AAyBA;;;;;GAKG;AACH;IAgCI;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,SAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,kCAJW,YAAY,sBACZ,MAAM,WACN,WAAW,QA2DrB;IAED;;;;;;;;OAQG;IACH,kHAFW,MAAM,QAsBhB;IAED,gBAgBC;;CACJ"}

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

@@ -1,5 +1,6 @@
 import { round_up } from "../../../core/math/round_up.js";
-import { DYNAMIC_MESH_DRAW_STRUCT, DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
+import { BindGroupDescriptor } from "../binding/BindGroupDescriptor.js";
+import { DYNAMIC_MESH_BIND_GROUP_GEOMETRY, DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
 
 /**
  * Growth factor for the vertex and index buffers.
@@ -51,6 +52,15 @@ export class GPUDynamicMeshResidency {
      */
     #indices_capacity = 0;
 
+    /**
+     * The group that binds {@link #vertices} and {@link #indices}, made on the first draw after they
+     * were allocated and kept until either is replaced: the geometry's buffers change far less often
+     * than their contents, so the group costs one creation per growth rather than a lookup per draw.
+     *
+     * @type {GPUBindGroup|null}
+     */
+    #bind_group = null;
+
     /**
      * How many indices to draw — the count from the last upload, not the buffer's capacity.
      *
@@ -86,6 +96,9 @@ export class GPUDynamicMeshResidency {
                 usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
                 label: "DynamicMesh/vertices",
             });
+
+            // names the buffer just destroyed
+            this.#bind_group = null;
         }
 
         if (this.#indices_capacity < index_bytes) {
@@ -99,6 +112,8 @@ export class GPUDynamicMeshResidency {
                 usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
                 label: "DynamicMesh/indices",
             });
+
+            this.#bind_group = null;
         }
 
         /*
@@ -126,48 +141,39 @@ export class GPUDynamicMeshResidency {
     }
 
     /**
-     * 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.
+     * Draw this geometry: bind its group and draw its indices as the one instance `slot`, which is
+     * the row of the constants the pass has bound that the draw reads (`GPUDynamicMeshDrawList`).
      *
-     * @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 {ShadeGPURenderPassEncoder} render_pass running `pipeline`, with its constants' group set
      * @param {GraphicsContext} graphics
-     * @param {RenderPipelineDescriptor} pipeline
-     * @param {Array} bindings from {@link create_bindings}
+     * @param {RenderPipelineDescriptor} pipeline a dynamic-mesh pipeline
+     * @param {number} slot this draw's row in the bound chunk of constants
      */
-    draw(render_pass, graphics, pipeline, bindings) {
-        graphics.setPipelineBindings(render_pass, pipeline, bindings);
+    draw(render_pass, graphics, pipeline, slot) {
+        let group = this.#bind_group;
+
+        if (group === null) {
+            // every dynamic-mesh pipeline declares this group alike, so one made for any of them
+            // serves them all
+            group = graphics.bind_groups.create(BindGroupDescriptor.from(
+                pipeline.layout.bindGroupLayouts[DYNAMIC_MESH_BIND_GROUP_GEOMETRY],
+                DYNAMIC_MESH_RESOURCES.groups[DYNAMIC_MESH_BIND_GROUP_GEOMETRY].generateBindings({
+                    vertices: this.#vertices,
+                    indices: this.#indices,
+                })
+            ));
+
+            this.#bind_group = group;
+        }
+
+        render_pass.setBindGroup(DYNAMIC_MESH_BIND_GROUP_GEOMETRY, group);
 
-        render_pass.draw(this.index_count);
+        render_pass.draw(this.index_count, 1, 0, slot);
     }
 
     destroy() {
+        this.#bind_group = null;
+
         if (this.#vertices !== null) {
             this.#vertices.destroy();
             this.#vertices = null;

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

@@ -15,7 +15,8 @@
  * 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.
+ * The enclosing shader binds the dynamic-mesh groups (`DYNAMIC_MESH_RESOURCES`), `camera` included,
+ * and hands over `instance_index` as the draw's row, as for {@link chunk_dynamic_mesh_vertex}.
  *
  * @type {CodeChunk}
  */

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,+CAFU,SAAS,CA0BjB;0BAjDwB,iCAAiC"}

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

@@ -18,7 +18,8 @@ import { chunk_dynamic_mesh_vertex } from "./chunk_dynamic_mesh_vertex.js";
  * 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.
+ * The enclosing shader binds the dynamic-mesh groups (`DYNAMIC_MESH_RESOURCES`), `camera` included,
+ * and hands over `instance_index` as the draw's row, as for {@link chunk_dynamic_mesh_vertex}.
  *
  * @type {CodeChunk}
  */
@@ -31,8 +32,8 @@ struct DynamicMeshAVBOITVertexOut {
     @location(1) @interpolate(perspective, centroid) view_depth : f32,
 }
 
-fn dynamic_mesh_avboit_vertex(vertex_index : u32) -> DynamicMeshAVBOITVertexOut {
-    let vertex = dynamic_mesh_vertex(vertex_index);
+fn dynamic_mesh_avboit_vertex(vertex_index : u32, draw_index : u32) -> DynamicMeshAVBOITVertexOut {
+    let vertex = dynamic_mesh_vertex(vertex_index, draw_index);
 
     var out : DynamicMeshAVBOITVertexOut;
 

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

@@ -1,12 +1,13 @@
 /**
  * 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`.
+ * the index at `vertex_index`, the vertex it names, its position through its draw's `model` and its
+ * colour multiplied by its draw's flat `color`. The draw's constants are row `draw_index` of
+ * `draws`, which a draw names through its `first_instance` — pass `@builtin(instance_index)`.
  *
  * 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`,
+ * The enclosing shader binds the dynamic-mesh groups (`DYNAMIC_MESH_RESOURCES`) — `draws`,
  * `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.

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

@@ -1 +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"}
+{"version":3,"file":"chunk_dynamic_mesh_vertex.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/chunk_dynamic_mesh_vertex.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH,wCAFU,SAAS,CAmCjB;0BAxDwB,iCAAiC"}

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

@@ -7,13 +7,14 @@ import {
 
 /**
  * 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`.
+ * the index at `vertex_index`, the vertex it names, its position through its draw's `model` and its
+ * colour multiplied by its draw's flat `color`. The draw's constants are row `draw_index` of
+ * `draws`, which a draw names through its `first_instance` — pass `@builtin(instance_index)`.
  *
  * 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`,
+ * The enclosing shader binds the dynamic-mesh groups (`DYNAMIC_MESH_RESOURCES`) — `draws`,
  * `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.
@@ -32,7 +33,9 @@ struct DynamicMeshVertex {
     color : vec4<f32>,
 }
 
-fn dynamic_mesh_vertex(vertex_index : u32) -> DynamicMeshVertex {
+fn dynamic_mesh_vertex(vertex_index : u32, draw_index : u32) -> DynamicMeshVertex {
+    let draw = draws[draw_index];
+
     let base = indices[vertex_index] * DYNAMIC_MESH_VERTEX_STRIDE;
 
     let position = vec3<f32>(

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

@@ -1,10 +1,10 @@
 /**
- * Upload the live meshes, then mark the depth slices their world boxes span
+ * Upload the live meshes and write their draws, 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.
+ * **This is the pass that brings the vertices and the draws' constants up to date**, being the
+ * channel's first: the device is only reachable at execution time, and the splat and the draw that
+ * read them 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
@@ -14,9 +14,11 @@
  * @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
+ * @param {GPUDynamicMeshDrawList} params.draws the frame's draws, written here for the splat and the
+ * draw of the same frame
  * @returns {number} the occupancy handle after the write
  */
-export function graph_dynamic_mesh_avboit_occupancy({ graph, camera, cluster_parameters, occupancy, residency, meshes, boxes, }: {
+export function graph_dynamic_mesh_avboit_occupancy({ graph, camera, cluster_parameters, occupancy, residency, meshes, boxes, draws, }: {
     graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     camera: number;
     cluster_parameters: ArrayLike<number>;
@@ -24,6 +26,7 @@ export function graph_dynamic_mesh_avboit_occupancy({ graph, camera, cluster_par
     residency: GPUDynamicMeshResidencyTable;
     meshes: DynamicMesh[];
     boxes: Float32Array;
+    draws: GPUDynamicMeshDrawList;
 }): number;
 /**
  * Splat the live meshes' extinction into the voxel volume (`shader_dynamic_mesh_avboit_splat`).
@@ -38,11 +41,10 @@ export function graph_dynamic_mesh_avboit_occupancy({ graph, camera, cluster_par
  * @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
+ * @param {GPUDynamicMeshDrawList} params.draws the frame's draws, as the occupancy wrote them
  * @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, }: {
+export function graph_dynamic_mesh_avboit_splat({ graph, camera, warp, voxel_resolution, volume, draws, }: {
     graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     camera: number;
     warp: number;
@@ -52,8 +54,7 @@ export function graph_dynamic_mesh_avboit_splat({ graph, camera, warp, voxel_res
         overflow: number;
         dummy: number;
     };
-    residency: GPUDynamicMeshResidencyTable;
-    meshes: DynamicMesh[];
+    draws: GPUDynamicMeshDrawList;
 }): {
     extinction: number;
     overflow: number;
@@ -72,11 +73,10 @@ export function graph_dynamic_mesh_avboit_splat({ graph, camera, warp, voxel_res
  * @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
+ * @param {GPUDynamicMeshDrawList} params.draws the frame's draws, as the occupancy wrote them
  * @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, }: {
+export function graph_dynamic_mesh_avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators, draws, }: {
     graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     view_ctx: import("../view/GPUViewContext.js").GPUViewContext;
     camera: number;
@@ -91,8 +91,7 @@ export function graph_dynamic_mesh_avboit_draw({ graph, view_ctx, camera, depth_
         extinction: number;
         emission: number;
     };
-    residency: GPUDynamicMeshResidencyTable;
-    meshes: DynamicMesh[];
+    draws: GPUDynamicMeshDrawList;
 }): {
     color: number;
     norm: number;

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

@@ -1 +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"}
+{"version":3,"file":"graph_dynamic_mesh_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/graph_dynamic_mesh_avboit.js"],"names":[],"mappings":"AA4CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAXkG,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;IACmB,KAAK;IAElC,MAAM,CAwDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IARkG,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;IACtB,KAAK;IAClC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAuFjE;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,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;IACpC,KAAK;IAClC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA4F/E"}