@woosh/meep-engine 3.32.0 → 3.33.0

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"}

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

@@ -28,58 +28,27 @@ import {
 /**
  * The dynamic meshes' three contributions to the AVBOIT transparency pipeline — the
  * `AVBOITSideChannel` contract, recorded into the frame graph the way the AVBOIT orchestrator records
- * its own passes. `DynamicMeshAVBOITChannel` calls these with the meshes it found live this frame and
- * the handles the orchestrator hands it.
+ * its own passes. `DynamicMeshAVBOITChannel` calls these with what it decided for the frame — the
+ * occupancy with the meshes it found live, the splat and the draw with the list the occupancy writes
+ * their draws into — and the handles the orchestrator hands it.
  *
- * One draw per mesh in the splat and in the draw, as in the pass over the scene: each mesh has its
- * own vertex and index buffers, so its own group 0. Order does not matter to any of them — the volume
- * and the accumulators are sums — which is why nothing here sorts.
+ * One draw per mesh in the splat and in the draw, as in the pass over the scene, out of one
+ * {@link GPUDynamicMeshDrawList} per frame: the occupancy writes it, the splat and the draw both draw
+ * it, so the meshes' constants go up once a frame and the two passes read the same ones. Order does
+ * not matter to any of them — the volume and the accumulators are sums — which is why nothing here
+ * sorts.
  */
 
 /** The accumulators' and the splat target's view: one mip, the one the frame draws into. */
 const COLOR_VIEW = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel: 0 });
 
 /**
- * Every live mesh's bindings for one pass: its own group 0, as its residency builds it for the pass
- * over the scene, then the pass's groups, the same for every draw.
- *
- * **Before the render pass is opened**: staging a mesh's draw uniform records a copy onto the
- * command encoder, and the encoder is locked for as long as a pass is open on it.
- *
- * @param {ShadeGPUCommandContext} encoder
- * @param {GPUDynamicMeshResidencyTable} residency
- * @param {DynamicMesh[]} meshes
- * @param {GPUBuffer} camera
- * @param {GPUBindingResource[][]} pass_groups groups 1 and up
- * @returns {{residency: GPUDynamicMeshResidency, bindings: GPUBindingResource[][]}[]}
- */
-function prepare_draws(encoder, residency, meshes, camera, pass_groups) {
-    const draws = [];
-
-    for (let i = 0; i < meshes.length; i++) {
-        const mesh = meshes[i];
-        const resident = residency.get(mesh.geometry);
-
-        if (resident === undefined || resident.index_count === 0) {
-            // not uploaded by this frame's occupancy pass, or nothing to draw
-            continue;
-        }
-
-        const [mesh_group] = resident.create_bindings(encoder, mesh, camera);
-
-        draws.push({ residency: resident, bindings: [mesh_group, ...pass_groups] });
-    }
-
-    return draws;
-}
-
-/**
- * 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
@@ -89,6 +58,8 @@ function prepare_draws(encoder, residency, meshes, camera, pass_groups) {
  * @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({
@@ -99,6 +70,7 @@ export function graph_dynamic_mesh_avboit_occupancy({
                                                         residency,
                                                         meshes,
                                                         boxes,
+                                                        draws,
                                                     }) {
     assert.isNonNegativeInteger(camera, "camera");
     assert.isNonNegativeInteger(occupancy, "occupancy");
@@ -115,6 +87,8 @@ export function graph_dynamic_mesh_avboit_occupancy({
 
         residency.upload(context.graphics.device, meshes);
 
+        draws.write(encoder, residency, meshes);
+
         shader_dynamic_mesh_avboit_occupancy.dispatch({
             encoder,
             bindings: {
@@ -157,8 +131,7 @@ export function graph_dynamic_mesh_avboit_occupancy({
  * @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({
@@ -167,8 +140,7 @@ export function graph_dynamic_mesh_avboit_splat({
                                                     warp,
                                                     voxel_resolution,
                                                     volume,
-                                                    residency,
-                                                    meshes,
+                                                    draws,
                                                 }) {
     assert.isNonNegativeInteger(camera, "camera");
     assert.isNonNegativeInteger(warp, "warp");
@@ -179,31 +151,30 @@ export function graph_dynamic_mesh_avboit_splat({
         const encoder = context.encoder;
         const graphics = context.graphics;
 
+        if (draws.count === 0) {
+            return;
+        }
+
+        const pipeline = DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE;
+
         // By name, never by position (ledger entry 21): the order a shader declares its bindings in
         // is the shader's business.
         const groups = DYNAMIC_MESH_AVBOIT_SPLAT_RESOURCES.groups;
 
-        const pass_groups = [
-            groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS].generateBindings({
-                warp: resources.get(data.warp),
-            }, encoder),
-            groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME].generateBindings({
-                extinction_volume: resources.get(data.extinction),
-                overflow_slice: resources.get(data.overflow),
-            }, encoder),
-        ];
-
-        const draws = prepare_draws(encoder, residency, meshes, resources.get(data.camera), pass_groups);
+        const pass_group = groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS].generateBindings({
+            warp: resources.get(data.warp),
+        }, encoder);
 
-        if (draws.length === 0) {
-            return;
-        }
+        const volume_group = groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME].generateBindings({
+            extinction_volume: resources.get(data.extinction),
+            overflow_slice: resources.get(data.overflow),
+        }, encoder);
 
         // the target is never written; it only sizes the raster and gives it its samples
         const pass_encoder = encoder.constructRenderPass({
             label: "Dynamic Mesh AVBOIT Splat",
-            pipeline: DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE,
-            // group 0 differs per mesh, so every group is set per draw
+            pipeline,
+            // the pass's groups are set once, just below; the draws set their own
             bindings: [],
             colorAttachments: [{
                 view: resources.get(data.target).obtainView(COLOR_VIEW),
@@ -212,11 +183,10 @@ export function graph_dynamic_mesh_avboit_splat({
             }],
         });
 
-        for (let i = 0; i < draws.length; i++) {
-            const draw = draws[i];
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS, pass_group);
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME, volume_group);
 
-            draw.residency.draw(pass_encoder, graphics, DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE, draw.bindings);
-        }
+        draws.draw(pass_encoder, graphics, pipeline, resources.get(data.camera));
 
         pass_encoder.end();
     }
@@ -264,8 +234,7 @@ export function graph_dynamic_mesh_avboit_splat({
  * @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({
@@ -278,8 +247,7 @@ export function graph_dynamic_mesh_avboit_draw({
                                                    volumetrics_lut,
                                                    volumetrics_metadata,
                                                    accumulators,
-                                                   residency,
-                                                   meshes,
+                                                   draws,
                                                }) {
     assert.isNonNegativeInteger(camera, "camera");
     assert.isNonNegativeInteger(depth_texture, "depth_texture");
@@ -291,6 +259,12 @@ export function graph_dynamic_mesh_avboit_draw({
         const encoder = context.encoder;
         const graphics = context.graphics;
 
+        if (draws.count === 0) {
+            return;
+        }
+
+        const pipeline = DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE;
+
         // by name rather than by position, for the reason the splat gives
         const pass_group = DYNAMIC_MESH_AVBOIT_DRAW_RESOURCES.groups[DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS].generateBindings({
             view: view_ctx.uniform_buffer.buffer,
@@ -302,12 +276,6 @@ export function graph_dynamic_mesh_avboit_draw({
             tSTBN_vec3: graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3).obtainView(),
         }, encoder);
 
-        const draws = prepare_draws(encoder, residency, meshes, resources.get(data.camera), [pass_group]);
-
-        if (draws.length === 0) {
-            return;
-        }
-
         const attachment = (handle) => ({
             view: resources.get(handle).obtainView(COLOR_VIEW),
             loadOp: "load",
@@ -316,8 +284,8 @@ export function graph_dynamic_mesh_avboit_draw({
 
         const pass_encoder = encoder.constructRenderPass({
             label: "Dynamic Mesh AVBOIT Draw",
-            pipeline: DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE,
-            // group 0 differs per mesh, so every group is set per draw
+            pipeline,
+            // the pass's group is set once, just below; the draws set their own
             bindings: [],
             colorAttachments: [
                 attachment(data.color),
@@ -331,11 +299,9 @@ export function graph_dynamic_mesh_avboit_draw({
             },
         });
 
-        for (let i = 0; i < draws.length; i++) {
-            const draw = draws[i];
+        graphics.setPipelineBindGroup(pass_encoder, pipeline, DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS, pass_group);
 
-            draw.residency.draw(pass_encoder, graphics, DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE, draw.bindings);
-        }
+        draws.draw(pass_encoder, graphics, pipeline, resources.get(data.camera));
 
         pass_encoder.end();
     }

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

@@ -28,12 +28,28 @@ export function create_dynamic_mesh_pipeline({ color_format, depth_format, depth
     opaque?: boolean;
 }): RenderPipelineDescriptor;
 /**
- * Per-draw constants. One dynamic mesh is one draw, so this is small and rewritten per mesh per
- * frame rather than tabled.
+ * Per-draw constants: one row of a frame's table of them, which a draw finds at its
+ * `instance_index` — its `first_instance`, since each draw is one instance.
+ *
+ * Every row is written anew every frame. A dynamic mesh's transform and colour are its to change as
+ * often as its vertices, so nothing about them is assumed to carry over from one frame to the next.
  */
 export const DYNAMIC_MESH_DRAW_STRUCT: WebGPUStruct;
 /**
- * The pipeline's resource set, for building bind groups.
+ * Bind group of the camera and one chunk of the frame's draw constants (`draws`), set once per chunk.
+ * @type {number}
+ */
+export const DYNAMIC_MESH_BIND_GROUP_DRAWS: number;
+/**
+ * Bind group of one geometry's `vertices` and `indices`, set per draw. The same group from frame to
+ * frame, for as long as the geometry's buffers keep their size.
+ * @type {number}
+ */
+export const DYNAMIC_MESH_BIND_GROUP_GEOMETRY: number;
+/**
+ * The pipeline's resource set, for building bind groups: {@link DYNAMIC_MESH_BIND_GROUP_DRAWS} and
+ * {@link DYNAMIC_MESH_BIND_GROUP_GEOMETRY}, which every pipeline that draws a dynamic mesh opens its
+ * layout with.
  *
  * @type {ShaderResourceSetDescriptor}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_dynamic_mesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh.js"],"names":[],"mappings":"AA4FA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAN4B,YAAY,GAA7B,MAAM;IACW,YAAY,GAA7B,MAAM;IACuB,aAAa;IACxB,MAAM,GAAxB,OAAO;IACL,wBAAwB,CAgCpC;AArID;;;GAGG;AACH,oDAY6B;AAuH7B;;;;GAIG;AACH,qCAFU,2BAA2B,CAEW;yCAtJP,8DAA8D;6BAO1E,gCAAgC;4CAJjB,mDAAmD"}
+{"version":3,"file":"shader_dynamic_mesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh.js"],"names":[],"mappings":"AA8GA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAN4B,YAAY,GAA7B,MAAM;IACW,YAAY,GAA7B,MAAM;IACuB,aAAa;IACxB,MAAM,GAAxB,OAAO;IACL,wBAAwB,CAgCpC;AAvJD;;;;;;GAMG;AACH,oDAY6B;AAE7B;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;GAIG;AACH,+CAFU,MAAM,CAEkC;AAyHlD;;;;;;GAMG;AACH,qCAFU,2BAA2B,CAEW;yCA1KP,8DAA8D;6BAO1E,gCAAgC;4CAJjB,mDAAmD"}

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

@@ -11,8 +11,11 @@ import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 import { chunk_dynamic_mesh_vertex } from "./chunk_dynamic_mesh_vertex.js";
 
 /**
- * Per-draw constants. One dynamic mesh is one draw, so this is small and rewritten per mesh per
- * frame rather than tabled.
+ * Per-draw constants: one row of a frame's table of them, which a draw finds at its
+ * `instance_index` — its `first_instance`, since each draw is one instance.
+ *
+ * Every row is written anew every frame. A dynamic mesh's transform and colour are its to change as
+ * often as its vertices, so nothing about them is assumed to carry over from one frame to the next.
  */
 export const DYNAMIC_MESH_DRAW_STRUCT = WebGPUStruct.from({
     /**
@@ -28,11 +31,26 @@ export const DYNAMIC_MESH_DRAW_STRUCT = WebGPUStruct.from({
     color: vec4f,
 }, "DynamicMeshDraw").pack();
 
+/**
+ * Bind group of the camera and one chunk of the frame's draw constants (`draws`), set once per chunk.
+ * @type {number}
+ */
+export const DYNAMIC_MESH_BIND_GROUP_DRAWS = 0;
+
+/**
+ * Bind group of one geometry's `vertices` and `indices`, set per draw. The same group from frame to
+ * frame, for as long as the geometry's buffers keep their size.
+ * @type {number}
+ */
+export const DYNAMIC_MESH_BIND_GROUP_GEOMETRY = 1;
+
 const resources = new ShaderResourceSetDescriptor();
 
 resources.createGroup()
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addUniform("draw", DYNAMIC_MESH_DRAW_STRUCT)
+    .addStorageBuffer("draws", WebGPUArray.from(DYNAMIC_MESH_DRAW_STRUCT), false);
+
+resources.createGroup()
     .addStorageBuffer("vertices", WebGPUArray.f32, false)
     .addStorageBuffer("indices", WebGPUArray.u32, false);
 
@@ -45,8 +63,8 @@ struct DynamicMeshVertexOut {
 }
 
 @vertex
-fn vs_main(@builtin(vertex_index) vi : u32) -> DynamicMeshVertexOut {
-    let vertex = dynamic_mesh_vertex(vi);
+fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) draw_index : u32) -> DynamicMeshVertexOut {
+    let vertex = dynamic_mesh_vertex(vi, draw_index);
 
     var out : DynamicMeshVertexOut;
 
@@ -146,7 +164,9 @@ export function create_dynamic_mesh_pipeline({
 }
 
 /**
- * The pipeline's resource set, for building bind groups.
+ * The pipeline's resource set, for building bind groups: {@link DYNAMIC_MESH_BIND_GROUP_DRAWS} and
+ * {@link DYNAMIC_MESH_BIND_GROUP_GEOMETRY}, which every pipeline that draws a dynamic mesh opens its
+ * layout with.
  *
  * @type {ShaderResourceSetDescriptor}
  */

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

@@ -1,6 +1,7 @@
 /**
  * Bind group of everything the draw reads once per pass — the view, the warp, the integral and the
- * fog. Group 0 is the dynamic-mesh group, per mesh.
+ * fog. Groups 0 and 1 are the dynamic-mesh groups: the draw constants per chunk, the geometry per
+ * mesh.
  * @type {number}
  */
 export const DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS: number;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_dynamic_mesh_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH,uDAFU,MAAM,CAE0C;AAwF1D;;;;GAIG;AACH,gDAFU,wBAAwB,CAc/B;AAEH,8EAA8E;AAC9E,6EAA4D;AAE5D,mDAAmD;AACnD,+DAA0D;yCAtIjB,8DAA8D;4CAU3D,mDAAmD;iCAC9D,+BAA+B"}
+{"version":3,"file":"shader_dynamic_mesh_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.js"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AAyF1D;;;;GAIG;AACH,gDAFU,wBAAwB,CAc/B;AAEH,8EAA8E;AAC9E,6EAA4D;AAE5D,mDAAmD;AACnD,+DAA0D;yCA5IjB,8DAA8D;4CAU3D,mDAAmD;iCAC9D,+BAA+B"}

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

@@ -15,14 +15,19 @@ import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { VIEW_UNIFORM_STRUCT } from "../view/VIEW_UNIFORM_STRUCT.js";
 import { VOLUMETRICS_METADATA_STRUCT } from "../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
 import { chunk_dynamic_mesh_avboit_vertex } from "./chunk_dynamic_mesh_avboit_vertex.js";
-import { DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
+import {
+    DYNAMIC_MESH_BIND_GROUP_DRAWS,
+    DYNAMIC_MESH_BIND_GROUP_GEOMETRY,
+    DYNAMIC_MESH_RESOURCES
+} from "./shader_dynamic_mesh.js";
 
 /**
  * Bind group of everything the draw reads once per pass — the view, the warp, the integral and the
- * fog. Group 0 is the dynamic-mesh group, per mesh.
+ * fog. Groups 0 and 1 are the dynamic-mesh groups: the draw constants per chunk, the geometry per
+ * mesh.
  * @type {number}
  */
-export const DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS = 1;
+export const DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS = 2;
 
 /**
  * The dynamic meshes' AVBOIT draw: every mesh's triangles at internal resolution, depth-tested
@@ -42,7 +47,8 @@ export const DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS = 1;
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.addGroup(DYNAMIC_MESH_RESOURCES.groups[0]);
+resources.addGroup(DYNAMIC_MESH_RESOURCES.groups[DYNAMIC_MESH_BIND_GROUP_DRAWS]);
+resources.addGroup(DYNAMIC_MESH_RESOURCES.groups[DYNAMIC_MESH_BIND_GROUP_GEOMETRY]);
 
 resources.createGroup()
     .addUniform("view", VIEW_UNIFORM_STRUCT)
@@ -66,8 +72,8 @@ struct DynamicMeshAVBOITDrawOutput {
 }
 
 @vertex
-fn vs_main(@builtin(vertex_index) vi : u32) -> DynamicMeshAVBOITVertexOut {
-    return dynamic_mesh_avboit_vertex(vi);
+fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) draw_index : u32) -> DynamicMeshAVBOITVertexOut {
+    return dynamic_mesh_avboit_vertex(vi, draw_index);
 }
 
 @fragment

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

@@ -1,10 +1,11 @@
 /**
- * Bind group of the warp, set once per pass. Group 0 is the dynamic-mesh group, per mesh.
+ * Bind group of the warp, set once per pass. Groups 0 and 1 are the dynamic-mesh groups: the draw
+ * constants per chunk, the geometry per mesh.
  * @type {number}
  */
 export const DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS: number;
 /**
- * Bind group of the volume atomics.
+ * Bind group of the volume atomics, set once per pass.
  * @type {number}
  */
 export const DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME: number;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_dynamic_mesh_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_splat.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,wDAFU,MAAM,CAE2C;AAE3D;;;GAGG;AACH,0DAFU,MAAM,CAE6C;AAE7D;;;;GAIG;AACH,gDAFU,MAAM,CAEmC;AAuGnD;;;;;;GAMG;AACH,iDAFU,wBAAwB,CAa/B;AAEH,gFAAgF;AAChF,8EAA6D;AAE7D,mDAAmD;AACnD,gEAA2D;yCAjKlB,8DAA8D;4CAU3D,mDAAmD;iCAC9D,+BAA+B"}
+{"version":3,"file":"shader_dynamic_mesh_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_splat.js"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,wDAFU,MAAM,CAE2C;AAE3D;;;GAGG;AACH,0DAFU,MAAM,CAE6C;AAE7D;;;;GAIG;AACH,gDAFU,MAAM,CAEmC;AA0GnD;;;;;;GAMG;AACH,iDAFU,wBAAwB,CAa/B;AAEH,gFAAgF;AAChF,8EAA6D;AAE7D,mDAAmD;AACnD,gEAA2D;yCAzKlB,8DAA8D;4CAU3D,mDAAmD;iCAC9D,+BAA+B"}

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

@@ -14,19 +14,24 @@ import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
 import { atomic_u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../shader/type/WebGPUArray.js";
 import { chunk_dynamic_mesh_avboit_vertex } from "./chunk_dynamic_mesh_avboit_vertex.js";
-import { DYNAMIC_MESH_RESOURCES } from "./shader_dynamic_mesh.js";
+import {
+    DYNAMIC_MESH_BIND_GROUP_DRAWS,
+    DYNAMIC_MESH_BIND_GROUP_GEOMETRY,
+    DYNAMIC_MESH_RESOURCES
+} from "./shader_dynamic_mesh.js";
 
 /**
- * Bind group of the warp, set once per pass. Group 0 is the dynamic-mesh group, per mesh.
+ * Bind group of the warp, set once per pass. Groups 0 and 1 are the dynamic-mesh groups: the draw
+ * constants per chunk, the geometry per mesh.
  * @type {number}
  */
-export const DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS = 1;
+export const DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS = 2;
 
 /**
- * Bind group of the volume atomics.
+ * Bind group of the volume atomics, set once per pass.
  * @type {number}
  */
-export const DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME = 2;
+export const DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME = 3;
 
 /**
  * Samples per pixel of the splat's raster, which is what a fragment's extinction is weighted by the
@@ -64,13 +69,15 @@ export const DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES = 4;
  * reason the meshlet splat has none: a splat behind an opaque surface lies deeper than anything the
  * draw will look it up for.
  *
- * Group 0 is `DYNAMIC_MESH_RESOURCES`' own group, the same object, so a mesh's bindings are the ones
- * its residency already builds for the pass over the scene.
+ * Groups 0 and 1 are `DYNAMIC_MESH_RESOURCES`' own groups, the same objects, so their layouts are
+ * the ones every dynamic-mesh pipeline declares and a geometry's one group serves them all. The AVBOIT
+ * draw binds the same groups this splat does, and reads the same constants: one upload a frame.
  */
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.addGroup(DYNAMIC_MESH_RESOURCES.groups[0]);
+resources.addGroup(DYNAMIC_MESH_RESOURCES.groups[DYNAMIC_MESH_BIND_GROUP_DRAWS]);
+resources.addGroup(DYNAMIC_MESH_RESOURCES.groups[DYNAMIC_MESH_BIND_GROUP_GEOMETRY]);
 
 resources.createGroup()
     .addStorageBuffer("warp", AVBOIT_WARP_STRUCT);
@@ -83,8 +90,8 @@ const body = CodeChunk.from(
     //language=WGSL
     `
 @vertex
-fn vs_main(@builtin(vertex_index) vi : u32) -> DynamicMeshAVBOITVertexOut {
-    return dynamic_mesh_avboit_vertex(vi);
+fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) draw_index : u32) -> DynamicMeshAVBOITVertexOut {
+    return dynamic_mesh_avboit_vertex(vi, draw_index);
 }
 
 @fragment
@@ -127,11 +134,12 @@ fn fs_main(in : DynamicMeshAVBOITVertexOut, @builtin(sample_mask) sample_mask :
 const descriptor = ShaderDescriptor.from({ label: "Dynamic Mesh AVBOIT Splat", body, resources });
 
 // Built group by group: the atomics are fragment-only, and WebGPU refuses a read-write storage
-// buffer that is visible to the vertex stage. The dynamic-mesh group keeps the visibility it has in
-// the pass over the scene, so the two layouts agree.
+// buffer that is visible to the vertex stage. The dynamic-mesh groups keep the visibility they have
+// in the pass over the scene, so the layouts agree and one geometry group serves every pipeline.
 const groups = resources.groups;
 const layout = PipelineLayoutDescriptor.from([
-    groups[0].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    groups[DYNAMIC_MESH_BIND_GROUP_DRAWS].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    groups[DYNAMIC_MESH_BIND_GROUP_GEOMETRY].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
     groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
     groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME].generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT),
 ], resources.immediateSize);

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#251@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#252@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#185@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#186@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */