@woosh/meep-engine 3.32.0 → 3.34.0

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

@@ -0,0 +1,257 @@
+import { assert } from "../../../core/assert.js";
+import { ceilPowerOfTwo } from "../../../core/binary/operations/ceilPowerOfTwo.js";
+import { round_up } from "../../../core/math/round_up.js";
+import {
+    DYNAMIC_MESH_BIND_GROUP_DRAWS,
+    DYNAMIC_MESH_DRAW_STRUCT,
+    DYNAMIC_MESH_RESOURCES
+} from "./shader_dynamic_mesh.js";
+
+/**
+ * The most draws one chunk of a frame's constants holds — and so the most draws one bind of the
+ * constants' group serves.
+ *
+ * Bounded rather than one table for every mesh the renderer draws: a chunk is one transient buffer
+ * and one write of at most 80 KiB of constants, whatever the frame's mesh count, so the write never
+ * grows with the scene and a chunk's buffer is the pool's ordinary business.
+ *
+ * @type {number}
+ */
+export const DYNAMIC_MESH_DRAWS_PER_CHUNK = 1024;
+
+/**
+ * The fewest draws a chunk is sized for. See {@link chunk_capacity}.
+ *
+ * @type {number}
+ */
+const DRAWS_PER_CHUNK_MIN = 64;
+
+/**
+ * Bytes from one draw's constants to the next: the array stride of {@link DYNAMIC_MESH_DRAW_STRUCT}.
+ *
+ * @type {number}
+ */
+const DRAW_STRIDE = round_up(DYNAMIC_MESH_DRAW_STRUCT.size, DYNAMIC_MESH_DRAW_STRUCT.align);
+
+const DRAW_STRIDE_FLOATS = DRAW_STRIDE / 4;
+const MODEL_OFFSET_FLOATS = DYNAMIC_MESH_DRAW_STRUCT.get("model").offset / 4;
+const COLOR_OFFSET_FLOATS = DYNAMIC_MESH_DRAW_STRUCT.get("color").offset / 4;
+
+/**
+ * Where a frame's constants are laid out on the CPU before they are sent. Only ever used for the
+ * length of one {@link GPUDynamicMeshDrawList#write} — the write copies them out before it returns —
+ * so one serves every list.
+ *
+ * @type {Float32Array}
+ */
+let scratch = new Float32Array(DRAW_STRIDE_FLOATS * DRAWS_PER_CHUNK_MIN);
+
+/**
+ * The scratch is given back once it holds more than four times what a write needs and more than this
+ * many bytes: a burst of meshes should not pin its constants' worth of memory for the rest of the
+ * process, and a count that swings within an ordinary range should not reallocate every frame.
+ *
+ * @type {number}
+ */
+const SCRATCH_RETAINED_BYTES = 1024 * 1024;
+
+/**
+ * How many draws' worth of buffer a chunk of `count` draws takes, and writes: the next power of two,
+ * between {@link DRAWS_PER_CHUNK_MIN} and {@link DYNAMIC_MESH_DRAWS_PER_CHUNK}.
+ *
+ * Sized by class rather than to the count because the count is the part of a frame most certain to
+ * change. Buffers of the exact size are a new size whenever one effect appears, and the transient
+ * pool hands out a buffer only for a request close enough to its size — so a count climbing by a
+ * mesh a frame made a new transient buffer every frame. Five sizes cover every chunk; the
+ * price is writing up to twice the bytes of the draws, rows past the last draw holding whatever the
+ * scratch held, which no draw reads.
+ *
+ * @param {number} count draws in the chunk, 1 to {@link DYNAMIC_MESH_DRAWS_PER_CHUNK}
+ * @returns {number}
+ */
+function chunk_capacity(count) {
+    return Math.min(DYNAMIC_MESH_DRAWS_PER_CHUNK, Math.max(DRAWS_PER_CHUNK_MIN, ceilPowerOfTwo(count)));
+}
+
+/**
+ * Rows of scratch that a write of up to `mesh_count` draws can send, padding included.
+ *
+ * @param {number} mesh_count
+ * @returns {number}
+ */
+function scratch_rows(mesh_count) {
+    if (mesh_count <= DYNAMIC_MESH_DRAWS_PER_CHUNK) {
+        return chunk_capacity(mesh_count);
+    }
+
+    return round_up(mesh_count, DYNAMIC_MESH_DRAWS_PER_CHUNK);
+}
+
+/**
+ * One frame's draws of a set of {@link DynamicMesh}es: which geometry each draws, and its per-draw
+ * constants ({@link DYNAMIC_MESH_DRAW_STRUCT}), written in chunks of up to
+ * {@link DYNAMIC_MESH_DRAWS_PER_CHUNK}.
+ *
+ * **The constants are all written anew every frame**, into transient buffers of the frame's own: a
+ * dynamic mesh's transform and colour are as free to change as its vertices, so nothing is kept for
+ * a mesh from one frame to the next. What the table buys is that the frame pays per *chunk* for the
+ * buffer, the copy and the bind group, where it used to pay per mesh for each. Per draw, what is
+ * left is the geometry's bind group — the same one every frame, while its buffers keep their size —
+ * and the draw, which names its row of the chunk through its `first_instance`.
+ *
+ * Draws keep the order of the meshes they came from, across chunks: the pass over the scene blends,
+ * and composites in that order.
+ *
+ * {@link write} before a render pass is opened on the encoder — the constants go up through copies,
+ * which a command encoder refuses while a pass is open on it — and then {@link draw} into as many
+ * passes of the frame as draw these meshes. The AVBOIT splat and draw read one write.
+ */
+export class GPUDynamicMeshDrawList {
+    /**
+     * What each draw draws, in draw order.
+     *
+     * @type {GPUDynamicMeshResidency[]}
+     */
+    #residencies = [];
+
+    /**
+     * One transient storage buffer per chunk, {@link DYNAMIC_MESH_DRAWS_PER_CHUNK} draws apiece and
+     * the rest in the last, each sized by {@link chunk_capacity}.
+     *
+     * @type {GPUBuffer[]}
+     */
+    #chunks = [];
+
+    /**
+     * How many draws the last {@link write} laid out.
+     *
+     * @returns {number}
+     */
+    get count() {
+        return this.#residencies.length;
+    }
+
+    /**
+     * Lay out a draw for every visible mesh of `meshes` with triangles resident in `residency`, and
+     * send their constants — as they are now — in one write per chunk. Replaces whatever the list
+     * held.
+     *
+     * The buffers are the encoder's transients, so the list is good for as long as that encoder is
+     * recording and no longer.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {GPUDynamicMeshResidencyTable} residency brought up to date for `meshes` this frame
+     * @param {DynamicMesh[]} meshes
+     */
+    write(encoder, residency, meshes) {
+        assert.defined(encoder, 'encoder');
+        assert.defined(residency, 'residency');
+        assert.isArray(meshes, 'meshes');
+
+        const residencies = this.#residencies;
+        const chunks = this.#chunks;
+
+        residencies.length = 0;
+        chunks.length = 0;
+
+        const mesh_count = meshes.length;
+        const needed = scratch_rows(mesh_count) * DRAW_STRIDE_FLOATS;
+
+        if (scratch.length < needed || (scratch.length > needed * 4 && scratch.byteLength > SCRATCH_RETAINED_BYTES)) {
+            scratch = new Float32Array(needed);
+        }
+
+        const constants = scratch;
+
+        for (let i = 0; i < mesh_count; i++) {
+            const mesh = meshes[i];
+
+            if (!mesh.visible) {
+                continue;
+            }
+
+            const resident = residency.get(mesh.geometry);
+
+            if (resident === undefined || resident.index_count === 0) {
+                // never uploaded, or nothing to draw
+                continue;
+            }
+
+            const row = residencies.length * DRAW_STRIDE_FLOATS;
+
+            // the transform is its own matrix from element 0; `matrix` would hand out a fresh view
+            const transform = mesh.transform;
+            const model = row + MODEL_OFFSET_FLOATS;
+
+            for (let k = 0; k < 16; k++) {
+                constants[model + k] = transform[k];
+            }
+
+            const color = mesh.color;
+            const tint = row + COLOR_OFFSET_FLOATS;
+
+            constants[tint] = color[0];
+            constants[tint + 1] = color[1];
+            constants[tint + 2] = color[2];
+            constants[tint + 3] = color[3];
+
+            residencies.push(resident);
+        }
+
+        const draw_count = residencies.length;
+
+        for (let first = 0; first < draw_count; first += DYNAMIC_MESH_DRAWS_PER_CHUNK) {
+            const bytes = chunk_capacity(Math.min(DYNAMIC_MESH_DRAWS_PER_CHUNK, draw_count - first)) * DRAW_STRIDE;
+
+            const chunk = encoder.allocateTransientBuffer(GPUBufferUsage.STORAGE, bytes);
+
+            encoder.writeBuffer(chunk, 0, constants.buffer, constants.byteOffset + first * DRAW_STRIDE, bytes);
+
+            chunks.push(chunk);
+        }
+    }
+
+    /**
+     * Let go of the frame: the geometries it drew and the transient buffers it wrote, which the
+     * encoder hands back when it finishes. For a list that outlives its frame, once its last pass is
+     * recorded.
+     */
+    clear() {
+        this.#residencies.length = 0;
+        this.#chunks.length = 0;
+    }
+
+    /**
+     * Record every draw into `render_pass`: the constants' group once per chunk, then per draw the
+     * geometry's group and the draw at its row. The pass's other groups are the caller's to set.
+     *
+     * @param {ShadeGPURenderPassEncoder} render_pass running `pipeline`
+     * @param {GraphicsContext} graphics
+     * @param {RenderPipelineDescriptor} pipeline one of the dynamic-mesh pipelines, whose layout opens
+     * with `DYNAMIC_MESH_RESOURCES`' groups
+     * @param {GPUBuffer} camera
+     */
+    draw(render_pass, graphics, pipeline, camera) {
+        const residencies = this.#residencies;
+        const chunks = this.#chunks;
+
+        const draw_count = residencies.length;
+        const group = DYNAMIC_MESH_RESOURCES.groups[DYNAMIC_MESH_BIND_GROUP_DRAWS];
+
+        for (let c = 0; c < chunks.length; c++) {
+            graphics.setPipelineBindGroup(
+                render_pass,
+                pipeline,
+                DYNAMIC_MESH_BIND_GROUP_DRAWS,
+                group.generateBindings({ camera, draws: chunks[c] })
+            );
+
+            const first = c * DYNAMIC_MESH_DRAWS_PER_CHUNK;
+            const end = Math.min(first + DYNAMIC_MESH_DRAWS_PER_CHUNK, draw_count);
+
+            for (let i = first; i < end; i++) {
+                residencies[i].draw(render_pass, graphics, pipeline, i - first);
+            }
+        }
+    }
+}

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;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAFU,OAAO,CAEF;IAiBf;;;;;;;;;;;;;;;;;;;;;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;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";
 
@@ -44,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}
      */
@@ -110,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 = [];
+        // 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;
 
-        for (let i = 0; i < count; i++) {
-            const mesh = meshes[i];
+        draws.write(encoder, this.#residency, batch.meshes);
 
-            if (!mesh.visible) {
-                continue;
-            }
-
-            const residency = this.#residency.get(mesh.geometry);
-
-            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;
         }
 
@@ -159,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",
@@ -184,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>(