@driftengine/core 4.9.0 → 4.10.0

package/dist/render/backend/webgpu/buffers.d.ts

@@ -156,18 +156,33 @@ export interface GpuMesh {
      * changed, reported at 2.8 MB a frame for one character. What the split costs is a pipeline per
      * layout, keyed by `:dynamic`, and two more buffers bound per draw of such a mesh.
      */
-    readonly update: ((device: GPUDevice, positions: Float32Array, normals?: Float32Array, previous?: GPUBuffer | null) => void) | null;
+    readonly update: ((device: GPUDevice, positions: Float32Array, normals?: Float32Array, staged?: StagedRewrite | null) => void) | null;
     /**
-     * A dynamic mesh's motion state, which the renderer owns: a buffer for last frame's positions,
-     * made the first time a reconstructing renderer rewrites the mesh, and the frame of the last
-     * rewrite. Null on a mesh created without `{ dynamic: true }`, which never moves a vertex.
+     * A dynamic mesh's motion state, which the renderer owns: a buffer for last frame's positions and
+     * one the new positions are staged in, each made the first time a reconstructing renderer
+     * rewrites the mesh, and the frame of the last rewrite. Null on a mesh created without
+     * `{ dynamic: true }`, which never moves a vertex.
      */
     readonly motion: {
         previous: GPUBuffer | null;
+        staging: GPUBuffer | null;
         changed: number;
     } | null;
     dispose(): void;
 }
+/**
+ * A rewrite a reconstructing renderer stages rather than writes, so last frame's positions can be
+ * kept with no submit of the rewrite's own: the new positions are written into `staging`, and two
+ * copies are recorded into `encoder` — the live positions into `previous` first, where the frame's
+ * first rewrite keeps them, then the staged ones in. The renderer submits that encoder at the head
+ * of the frame's next submit, which is what keeps both copies ahead of every draw that reads the
+ * mesh. A `writeBuffer` straight to the live positions would land before the copy aside could run.
+ */
+export interface StagedRewrite {
+    encoder: GPUCommandEncoder;
+    staging: GPUBuffer;
+    previous: GPUBuffer | null;
+}
 /** A mesh on its way to the device, and the iterator that gets it there. */
 export interface IncrementalGpuMesh {
     /**

package/dist/render/backend/webgpu/buffers.js

@@ -408,7 +408,9 @@ function skinOffsetsOf(supplied) {
 }
 /** The handle, made where it can see only what it hands out. */
 function gpuMeshOf(parts) {
-    const motion = parts.update === null ? null : { previous: null, changed: -1 };
+    const motion = parts.update === null
+        ? null
+        : { previous: null, staging: null, changed: -1 };
     const { vertices, constants, streams, indexBuffer, progress } = parts;
     return {
         vertexBuffers: streams === null
@@ -433,6 +435,7 @@ function gpuMeshOf(parts) {
         motion,
         dispose() {
             motion?.previous?.destroy();
+            motion?.staging?.destroy();
             streams?.positions.destroy();
             streams?.normals.destroy();
             vertices.destroy();
@@ -447,12 +450,12 @@ function isStreamed(attribute) {
 }
 /**
  * A dynamic mesh's `update`: the caller's positions, and its normals where it has them, each
- * written to its own buffer as it came. Last frame's positions, where a reconstruction wants them,
- * are copied on the device before the write — a copy submitted ahead of a `writeBuffer` runs ahead
- * of it on the queue — so no CPU copy of anything is kept.
+ * written to its own buffer as it came — or, where a reconstruction keeps last frame's positions,
+ * the positions staged and copied in on the device behind the copy aside (`StagedRewrite`), so no
+ * CPU copy of anything is kept and the rewrite submits nothing of its own.
  */
 function streamUpdate(positionsBuffer, normalsBuffer, streamBytes, bounds, vertexCount) {
-    return (target, positions, normals, previous = null) => {
+    return (target, positions, normals, staged = null) => {
         for (const [name, values] of [
             ['update', positions],
             ['normals', normals],
@@ -463,15 +466,19 @@ function streamUpdate(positionsBuffer, normalsBuffer, streamBytes, bounds, verte
                 "A mesh's vertex count is fixed at creation: the index buffer, the pipeline and " +
                 'every other attribute are sized against it.');
         }
-        if (previous !== null) {
-            const encoder = target.createCommandEncoder({ label: 'mesh.previousPositions' });
-            encoder.copyBufferToBuffer(positionsBuffer, 0, previous, 0, streamBytes);
-            target.queue.submit([encoder.finish()]);
-        }
         /* Everything that decides whether this is on screen starts from the bounds, so a cloth
            that blew sideways out of its original box would be culled while still visible. */
         boundsOfPositions(positions, bounds);
-        target.queue.writeBuffer(positionsBuffer, 0, positions);
+        if (staged === null) {
+            target.queue.writeBuffer(positionsBuffer, 0, positions);
+        }
+        else {
+            target.queue.writeBuffer(staged.staging, 0, positions);
+            if (staged.previous !== null) {
+                staged.encoder.copyBufferToBuffer(positionsBuffer, 0, staged.previous, 0, streamBytes);
+            }
+            staged.encoder.copyBufferToBuffer(staged.staging, 0, positionsBuffer, 0, streamBytes);
+        }
         if (normals !== undefined)
             target.queue.writeBuffer(normalsBuffer, 0, normals);
     };

package/dist/render/backend/webgpu/compressedUpload.d.ts

@@ -12,7 +12,6 @@
  * the level nominally has.
  */
 import type { CompressedTextureFormat, CompressedTextureSource } from '../../compressedSource.ts';
-/** Every BC format, where the device carries the feature; none where it does not. */
 export declare function gpuCompressedFormats(device: GPUDevice): CompressedTextureFormat[];
 /** A texture holding `layers` as `name`, `levels` levels of each, written as they are. */
 export declare function createCompressedTexture(device: GPUDevice, name: CompressedTextureFormat, layers: readonly CompressedTextureSource[], levels: number): GPUTexture;

package/dist/render/backend/webgpu/compressedUpload.js

@@ -1,4 +1,4 @@
-import { BLOCK_BYTES } from '../../compressedSource.js';
+import { BLOCK_SHAPES, blockFamily } from '../../compressedSource.js';
 const GPU_FORMAT = {
     bc1: 'bc1-rgba-unorm',
     'bc1-srgb': 'bc1-rgba-unorm-srgb',
@@ -10,28 +10,73 @@ const GPU_FORMAT = {
     bc5: 'bc5-rg-unorm',
     bc7: 'bc7-rgba-unorm',
     'bc7-srgb': 'bc7-rgba-unorm-srgb',
+    'etc2-rgb8': 'etc2-rgb8unorm',
+    'etc2-rgb8-srgb': 'etc2-rgb8unorm-srgb',
+    'etc2-rgb8a1': 'etc2-rgb8a1unorm',
+    'etc2-rgb8a1-srgb': 'etc2-rgb8a1unorm-srgb',
+    'etc2-rgba8': 'etc2-rgba8unorm',
+    'etc2-rgba8-srgb': 'etc2-rgba8unorm-srgb',
+    'eac-r11': 'eac-r11unorm',
+    'eac-rg11': 'eac-rg11unorm',
+    'astc-4x4': 'astc-4x4-unorm',
+    'astc-4x4-srgb': 'astc-4x4-unorm-srgb',
+    'astc-5x4': 'astc-5x4-unorm',
+    'astc-5x4-srgb': 'astc-5x4-unorm-srgb',
+    'astc-5x5': 'astc-5x5-unorm',
+    'astc-5x5-srgb': 'astc-5x5-unorm-srgb',
+    'astc-6x5': 'astc-6x5-unorm',
+    'astc-6x5-srgb': 'astc-6x5-unorm-srgb',
+    'astc-6x6': 'astc-6x6-unorm',
+    'astc-6x6-srgb': 'astc-6x6-unorm-srgb',
+    'astc-8x5': 'astc-8x5-unorm',
+    'astc-8x5-srgb': 'astc-8x5-unorm-srgb',
+    'astc-8x6': 'astc-8x6-unorm',
+    'astc-8x6-srgb': 'astc-8x6-unorm-srgb',
+    'astc-8x8': 'astc-8x8-unorm',
+    'astc-8x8-srgb': 'astc-8x8-unorm-srgb',
+    'astc-10x5': 'astc-10x5-unorm',
+    'astc-10x5-srgb': 'astc-10x5-unorm-srgb',
+    'astc-10x6': 'astc-10x6-unorm',
+    'astc-10x6-srgb': 'astc-10x6-unorm-srgb',
+    'astc-10x8': 'astc-10x8-unorm',
+    'astc-10x8-srgb': 'astc-10x8-unorm-srgb',
+    'astc-10x10': 'astc-10x10-unorm',
+    'astc-10x10-srgb': 'astc-10x10-unorm-srgb',
+    'astc-12x10': 'astc-12x10-unorm',
+    'astc-12x10-srgb': 'astc-12x10-unorm-srgb',
+    'astc-12x12': 'astc-12x12-unorm',
+    'astc-12x12-srgb': 'astc-12x12-unorm-srgb',
 };
 /** Every BC format, where the device carries the feature; none where it does not. */
+/** The feature that grants each family, which `select.ts` asks for wherever the adapter offers it. */
+const FEATURE = {
+    bc: 'texture-compression-bc',
+    etc2: 'texture-compression-etc2',
+    astc: 'texture-compression-astc',
+};
 export function gpuCompressedFormats(device) {
-    return device.features.has('texture-compression-bc')
-        ? Object.keys(GPU_FORMAT)
-        : [];
+    return Object.keys(GPU_FORMAT).filter((name) => device.features.has(FEATURE[blockFamily(baseOf(name))]));
+}
+/** The format a name is of, without its colour space. */
+function baseOf(name) {
+    return (name.endsWith('-srgb') ? name.slice(0, -'-srgb'.length) : name);
 }
 /** A texture holding `layers` as `name`, `levels` levels of each, written as they are. */
 export function createCompressedTexture(device, name, layers, levels) {
     const { format, width, height } = layers[0];
     const texture = device.createTexture({
-        label: 'surface.texture.bc',
+        label: `surface.texture.${format}`,
         size: [width, height, layers.length],
         format: GPU_FORMAT[name],
         mipLevelCount: levels,
         usage: 0x2 | 0x4, // COPY_DST | TEXTURE_BINDING
     });
+    const block = BLOCK_SHAPES[format];
     for (let level = 0; level < levels; level++) {
-        const across = Math.ceil(Math.max(1, width >> level) / 4);
-        const down = Math.ceil(Math.max(1, height >> level) / 4);
+        const across = Math.ceil(Math.max(1, width >> level) / block.width);
+        const down = Math.ceil(Math.max(1, height >> level) / block.height);
         for (let layer = 0; layer < layers.length; layer++) {
-            device.queue.writeTexture({ texture, mipLevel: level, origin: [0, 0, layer] }, layers[layer].levels[level], { bytesPerRow: across * BLOCK_BYTES[format], rowsPerImage: down }, { width: across * 4, height: down * 4, depthOrArrayLayers: 1 });
+            device.queue.writeTexture({ texture, mipLevel: level, origin: [0, 0, layer] }, layers[layer].levels[level], { bytesPerRow: across * block.bytes, rowsPerImage: down }, { width: across * block.width, height: down * block.height, depthOrArrayLayers: 1 });
         }
     }
     return texture;

package/dist/render/backend/webgpu/depthPass.d.ts

@@ -1,6 +1,7 @@
 import { DEPTH_FRAG_WGSL } from '../../shaders/generated/depth.wgsl.ts';
 import type { PipelineCache } from './pipelineCache.ts';
 import type { ClothViews } from './clothTextures.ts';
+import type { AnimationViews } from './flatPass.ts';
 /**
  * The shadow pass: the world drawn from the light, into a depth map.
  *
@@ -136,6 +137,55 @@ export declare const DEPTH_PALETTE_BINDING: {
     readonly sampler: 17;
     readonly type: "sampler2D";
 };
+export declare const DEPTH_INSTANCED_ANIMATED_VERT_FIELDS: {
+    readonly uLightViewProj: {
+        readonly offset: 0;
+        readonly size: 64;
+        readonly type: "mat4";
+    };
+    readonly uSceneTime: {
+        readonly offset: 64;
+        readonly size: 4;
+        readonly type: "float";
+    };
+    readonly uBoneClip: {
+        readonly offset: 72;
+        readonly size: 8;
+        readonly type: "vec2";
+    };
+};
+export declare const DEPTH_INSTANCED_ANIMATED_CUTOUT_VERT_FIELDS: {
+    readonly uLightViewProj: {
+        readonly offset: 0;
+        readonly size: 64;
+        readonly type: "mat4";
+    };
+    readonly uUvScale: {
+        readonly offset: 64;
+        readonly size: 8;
+        readonly type: "vec2";
+    };
+    readonly uUvOffset: {
+        readonly offset: 72;
+        readonly size: 8;
+        readonly type: "vec2";
+    };
+    readonly uAlphaCutout: {
+        readonly offset: 80;
+        readonly size: 8;
+        readonly type: "vec2";
+    };
+    readonly uSceneTime: {
+        readonly offset: 88;
+        readonly size: 4;
+        readonly type: "float";
+    };
+    readonly uBoneClip: {
+        readonly offset: 96;
+        readonly size: 8;
+        readonly type: "vec2";
+    };
+};
 /**
  * The format the shadow map is stored in.
  *
@@ -160,7 +210,9 @@ skinned?: boolean,
  * Separate for the palette's reason: the plain layout stays exactly what it was, and a frame with
  * no cutout caster pays nothing.
  */
-cutout?: boolean): GPUBindGroupLayout;
+cutout?: boolean, 
+/** An instanced caster playing a bone animation: its three vertex textures. */
+animated?: boolean): GPUBindGroupLayout;
 export declare function createDepthBindGroup(device: GPUDevice, layout: GPUBindGroupLayout, perDraw: GPUBuffer, perPass: GPUBuffer, previous: GPUTextureView, sampler: GPUSampler, 
 /** The joint palette, for a layout built with `skinned`. Omit for the rigid layout. */
 palette?: GPUTextureView | null, 
@@ -170,7 +222,9 @@ cutout?: {
     readonly sampler: GPUSampler;
 } | null, 
 /** A skinned group's cloth views: the caster's, or the stand-in where it has none. */
-cloth?: ClothViews | null): GPUBindGroup;
+cloth?: ClothViews | null, 
+/** An animated caster's clip and clocks. See `AnimationViews`. */
+animation?: AnimationViews | null): GPUBindGroup;
 /**
  * The depth pipeline.
  *
@@ -209,4 +263,6 @@ cutout?: boolean,
  */
 skinEight?: boolean, 
 /** Whether a skinned caster is placed by a cloth binding, as its visible draw is. The key carries it. */
-cloth?: boolean): GPURenderPipeline;
+cloth?: boolean, 
+/** An instanced caster playing a bone animation. The key must carry it. */
+animated?: boolean): GPURenderPipeline;

package/dist/render/backend/webgpu/depthPass.js

@@ -1,4 +1,4 @@
-import { DEPTH_BINDINGS, DEPTH_CUTOUT_FRAG_WGSL, DEPTH_CUTOUT_VERT_WGSL, DEPTH_FRAG_WGSL, DEPTH_INSTANCED_CUTOUT_VERT_WGSL, DEPTH_INSTANCED_VERT_WGSL, DEPTH_SKINNED_VERT_WGSL, DEPTH_VERT_WGSL, } from '../../shaders/generated/depth.wgsl.js';
+import { DEPTH_BINDINGS, DEPTH_CUTOUT_FRAG_WGSL, DEPTH_CUTOUT_VERT_WGSL, DEPTH_FRAG_WGSL, DEPTH_INSTANCED_ANIMATED_CUTOUT_VERT_WGSL, DEPTH_INSTANCED_ANIMATED_VERT_WGSL, DEPTH_INSTANCED_CUTOUT_VERT_WGSL, DEPTH_INSTANCED_VERT_WGSL, DEPTH_SKINNED_VERT_WGSL, DEPTH_VERT_WGSL, } from '../../shaders/generated/depth.wgsl.js';
 import { vertexBufferLayouts } from './buffers.js';
 import { vertexConstants } from './flatPass.js';
 import { shaderModule } from './shaderModules.js';
@@ -37,6 +37,14 @@ const CLOTH_TEXTURES = [
     DEPTH_BINDINGS.DEPTH_SKINNED_VERT.textures.uClothParticles,
     DEPTH_BINDINGS.DEPTH_SKINNED_VERT.textures.uClothRest,
 ];
+/** A bone animation's three textures, at the bindings both animated depth variants declare them. */
+const ANIMATION_TEXTURES = [
+    DEPTH_BINDINGS.DEPTH_INSTANCED_ANIMATED_VERT.textures.uBonePlaces,
+    DEPTH_BINDINGS.DEPTH_INSTANCED_ANIMATED_VERT.textures.uBoneTurns,
+    DEPTH_BINDINGS.DEPTH_INSTANCED_ANIMATED_VERT.textures.uInstanceClocks,
+];
+export const DEPTH_INSTANCED_ANIMATED_VERT_FIELDS = DEPTH_BINDINGS.DEPTH_INSTANCED_ANIMATED_VERT.fields;
+export const DEPTH_INSTANCED_ANIMATED_CUTOUT_VERT_FIELDS = DEPTH_BINDINGS.DEPTH_INSTANCED_ANIMATED_CUTOUT_VERT.fields;
 const VISIBILITY_VERTEX = 0x1;
 const VISIBILITY_FRAGMENT = 0x2;
 /**
@@ -63,10 +71,19 @@ skinned = false,
  * Separate for the palette's reason: the plain layout stays exactly what it was, and a frame with
  * no cutout caster pays nothing.
  */
-cutout = false) {
+cutout = false, 
+/** An instanced caster playing a bone animation: its three vertex textures. */
+animated = false) {
     return device.createBindGroupLayout({
-        label: skinned ? 'depth.layout.skinned' : cutout ? 'depth.layout.cutout' : 'depth.layout',
+        label: `${skinned ? 'depth.layout.skinned' : cutout ? 'depth.layout.cutout' : 'depth.layout'}${animated ? '.animated' : ''}`,
         entries: [
+            ...(animated
+                ? ANIMATION_TEXTURES.map((binding) => ({
+                    binding: binding.texture,
+                    visibility: VISIBILITY_VERTEX,
+                    texture: { sampleType: 'unfilterable-float' },
+                }))
+                : []),
             /* The texture and no sampler: the shader reads the palette with `textureLoad`, an integer
                coordinate with nothing to filter, which is what `flatPass.ts` binds for the same
                palette. naga declares a sampler for it and nothing ever reads one. */
@@ -147,7 +164,9 @@ palette = null,
 /** The cutout map and its sampler, for a layout built with `cutout`. */
 cutout = null, 
 /** A skinned group's cloth views: the caster's, or the stand-in where it has none. */
-cloth = null) {
+cloth = null, 
+/** An animated caster's clip and clocks. See `AnimationViews`. */
+animation = null) {
     return device.createBindGroup({
         label: palette !== null
             ? 'depth.bindGroup.skinned'
@@ -180,6 +199,13 @@ cloth = null) {
                     { binding: CUTOUT_MAP.sampler, resource: cutout.sampler },
                 ]
                 : []),
+            ...(animation !== null
+                ? [
+                    { binding: ANIMATION_TEXTURES[0].texture, resource: animation.places },
+                    { binding: ANIMATION_TEXTURES[1].texture, resource: animation.turns },
+                    { binding: ANIMATION_TEXTURES[2].texture, resource: animation.clocks },
+                ]
+                : []),
         ],
     });
 }
@@ -221,20 +247,29 @@ cutout = false,
  */
 skinEight = false, 
 /** Whether a skinned caster is placed by a cloth binding, as its visible draw is. The key carries it. */
-cloth = false) {
+cloth = false, 
+/** An instanced caster playing a bone animation. The key must carry it. */
+animated = false) {
     return cache.get(key, () => ({
         label: key,
         layout: device.createPipelineLayout({ bindGroupLayouts: [layout] }),
         vertex: {
-            module: shaderModule(device, cutout
-                ? instanced
-                    ? { label: 'depth.instanced.cutout.vert', code: DEPTH_INSTANCED_CUTOUT_VERT_WGSL }
-                    : { label: 'depth.cutout.vert', code: DEPTH_CUTOUT_VERT_WGSL }
-                : instanced
-                    ? { label: 'depth.instanced.vert', code: DEPTH_INSTANCED_VERT_WGSL }
-                    : skinned
-                        ? { label: 'depth.skinned.vert', code: DEPTH_SKINNED_VERT_WGSL }
-                        : { label: 'depth.vert', code: DEPTH_VERT_WGSL }),
+            module: shaderModule(device, animated
+                ? cutout
+                    ? {
+                        label: 'depth.instanced.animated.cutout.vert',
+                        code: DEPTH_INSTANCED_ANIMATED_CUTOUT_VERT_WGSL,
+                    }
+                    : { label: 'depth.instanced.animated.vert', code: DEPTH_INSTANCED_ANIMATED_VERT_WGSL }
+                : cutout
+                    ? instanced
+                        ? { label: 'depth.instanced.cutout.vert', code: DEPTH_INSTANCED_CUTOUT_VERT_WGSL }
+                        : { label: 'depth.cutout.vert', code: DEPTH_CUTOUT_VERT_WGSL }
+                    : instanced
+                        ? { label: 'depth.instanced.vert', code: DEPTH_INSTANCED_VERT_WGSL }
+                        : skinned
+                            ? { label: 'depth.skinned.vert', code: DEPTH_SKINNED_VERT_WGSL }
+                            : { label: 'depth.vert', code: DEPTH_VERT_WGSL }),
             entryPoint: 'main',
             buffers: vertexBufferLayouts(present, instanced),
             ...(skinned && !instanced && !cutout

package/dist/render/backend/webgpu/drawCommand.d.ts

@@ -2,7 +2,7 @@
  * One recorded draw, in the only shape this backend ever issues.
  *
  * Sampled across three unrelated verbs — panels, particles, wind streaks — the sequence is the
- * same every time: a pipeline, a bind group with up to two dynamic offsets, some vertex
+ * same every time: a pipeline, a bind group with up to four dynamic offsets, some vertex
  * buffers, perhaps an index buffer, then a draw. Nothing in it is specific to what is being
  * drawn except the values.
  *
@@ -13,9 +13,14 @@
 export interface DrawCommand {
     pipeline: GPURenderPipeline | null;
     bindGroup: GPUBindGroup | null;
-    /** Dynamic offsets, held as two numbers rather than an array so a reset stays free. */
+    /**
+     * Dynamic offsets, held as numbers rather than an array so a reset stays free. Four only for a
+     * lit mesh: its draw's slot, its pass's, its material's and its view's, in binding order.
+     */
     offsetA: number;
     offsetB: number;
+    offsetC: number;
+    offsetD: number;
     offsetCount: number;
     /** Fixed length; `vertexCount` says how many slots are live. */
     readonly vertexBuffers: (GPUBuffer | null)[];
@@ -29,6 +34,12 @@ export interface DrawCommand {
      * cull's survivors, counted on the device. Null for every other draw.
      */
     indirect: GPUBuffer | null;
+    /**
+     * Render bundles to execute instead of everything above: a static list recorded once, replayed
+     * as one command. Held as the array `executeBundles` takes, kept by the list, so issuing it
+     * allocates nothing. Null for every other command, and put back to null by every take.
+     */
+    bundles: readonly GPURenderBundle[] | null;
 }
 export interface CommandPool {
     commands: DrawCommand[];
@@ -40,8 +51,11 @@ export declare function createCommandPool(capacity: number): CommandPool;
 /**
  * Hand out the next command, growing if a frame overruns.
  *
- * The entry is **not cleared**. Every caller fills every field it uses, and clearing here would
- * be a write per field per draw for no reader — the same reasoning the node arena uses.
+ * The entry is **not cleared**, but for `bundles`. Every caller fills every field it uses, and
+ * clearing here would be a write per field per draw for no reader — the same reasoning the node
+ * arena uses. `bundles` is the exception because almost no caller knows it exists: a pooled command
+ * that once carried a static list's bundles and was then taken for an ordinary draw would replay the
+ * list instead, so the one field nobody fills is the one field put back here.
  */
 export declare function takeCommand(pool: CommandPool): number;
 /** Empty the pool for a new frame. Keeps every entry; that is the whole point. */

package/dist/render/backend/webgpu/drawCommand.js

@@ -2,7 +2,7 @@
  * One recorded draw, in the only shape this backend ever issues.
  *
  * Sampled across three unrelated verbs — panels, particles, wind streaks — the sequence is the
- * same every time: a pipeline, a bind group with up to two dynamic offsets, some vertex
+ * same every time: a pipeline, a bind group with up to four dynamic offsets, some vertex
  * buffers, perhaps an index buffer, then a draw. Nothing in it is specific to what is being
  * drawn except the values.
  *
@@ -22,6 +22,8 @@ function emptyCommand() {
         bindGroup: null,
         offsetA: 0,
         offsetB: 0,
+        offsetC: 0,
+        offsetD: 0,
         offsetCount: 0,
         vertexBuffers: new Array(VERTEX_BUFFER_SLOTS).fill(null),
         vertexCount: 0,
@@ -30,6 +32,7 @@ function emptyCommand() {
         count: 0,
         instances: 1,
         indirect: null,
+        bundles: null,
     };
 }
 export function createCommandPool(capacity) {
@@ -41,8 +44,11 @@ export function createCommandPool(capacity) {
 /**
  * Hand out the next command, growing if a frame overruns.
  *
- * The entry is **not cleared**. Every caller fills every field it uses, and clearing here would
- * be a write per field per draw for no reader — the same reasoning the node arena uses.
+ * The entry is **not cleared**, but for `bundles`. Every caller fills every field it uses, and
+ * clearing here would be a write per field per draw for no reader — the same reasoning the node
+ * arena uses. `bundles` is the exception because almost no caller knows it exists: a pooled command
+ * that once carried a static list's bundles and was then taken for an ordinary draw would replay the
+ * list instead, so the one field nobody fills is the one field put back here.
  */
 export function takeCommand(pool) {
     const at = pool.taken;
@@ -51,6 +57,7 @@ export function takeCommand(pool) {
     pool.taken = at + 1;
     if (pool.taken > pool.highWater)
         pool.highWater = pool.taken;
+    pool.commands[at].bundles = null;
     return at;
 }
 /** Empty the pool for a new frame. Keeps every entry; that is the whole point. */