@driftengine/core 4.9.0 → 4.10.0

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

@@ -63,11 +63,27 @@ export interface StageBindings {
     readonly textures: Readonly<Record<string, TextureBinding>>;
     /** Each pipeline-overridable constant's id, by the GLSL name it was declared under. */
     readonly overrides?: Readonly<Record<string, number>>;
+    /**
+     * The second block, of the uniforms marked `// wgsl:material`: its binding, size and fields.
+     * Absent from a stage that marks none, which is every stage but the lit fragment's.
+     */
+    readonly materialUniforms?: number;
+    readonly materialSize?: number;
+    readonly materialFields?: StageBindings['fields'];
+    /**
+     * The vertex stage's view block, of the uniforms marked `// wgsl:view`: the camera, the light's
+     * matrix and the wind, which a pass settles. Absent from every stage but the lit vertex one.
+     */
+    readonly viewUniforms?: number;
+    readonly viewSize?: number;
+    readonly viewFields?: StageBindings['fields'];
 }
 /** The key for a set of vertex flags: the same rule `variantKey` uses, flags on, sorted, joined. */
-export declare function flatVertexKey(skinned: boolean, morphed: boolean, instanced?: boolean): string;
+export declare function flatVertexKey(skinned: boolean, morphed: boolean, instanced?: boolean, 
+/** Whether an instanced variant plays a bone animation. See `shaders/boneAnimation.ts`. */
+animated?: boolean): string;
 /** Everything the generator recorded about one variant of the vertex stage. */
-export declare function flatVertexBindings(skinned: boolean, morphed?: boolean, instanced?: boolean): StageBindings;
+export declare function flatVertexBindings(skinned: boolean, morphed?: boolean, instanced?: boolean, animated?: boolean): StageBindings;
 /**
  * A vertex stage's constants, keyed by each override's **id** as the fragment's are: `SKIN_EIGHT` and
  * `CLOTH_BOUND` in a skinned stage, `LIGHTMAP_REGIONS` in an instanced one, nothing in any other. Every override a stage declares is set, and one this does
@@ -78,63 +94,51 @@ export declare function vertexConstants(bindings: StageBindings, skinEight: bool
 /** Whether an instanced stage reads its tint lane as a lightmap region. See `lightmap.ts`. */
 lightmapRegions?: boolean): Record<string, number>;
 export declare const FLAT_VERT_FIELDS: {
-    readonly uViewProj: {
-        readonly offset: 0;
-        readonly size: 64;
-        readonly type: "mat4";
-    };
     readonly uHasTangents: {
-        readonly offset: 64;
+        readonly offset: 0;
         readonly size: 4;
         readonly type: "int";
     };
-    readonly uLightViewProj: {
-        readonly offset: 80;
-        readonly size: 64;
-        readonly type: "mat4";
-    };
     readonly uUvScale: {
-        readonly offset: 144;
+        readonly offset: 8;
         readonly size: 8;
         readonly type: "vec2";
     };
     readonly uUvOffset: {
-        readonly offset: 152;
+        readonly offset: 16;
         readonly size: 8;
         readonly type: "vec2";
     };
     readonly uModel: {
-        readonly offset: 160;
+        readonly offset: 32;
         readonly size: 64;
         readonly type: "mat4";
     };
     readonly uTint: {
-        readonly offset: 224;
+        readonly offset: 96;
         readonly size: 12;
         readonly type: "vec3";
     };
-    readonly uWindDirection: {
-        readonly offset: 240;
-        readonly size: 8;
-        readonly type: "vec2";
-    };
-    readonly uWindSpeed: {
-        readonly offset: 248;
+};
+/** The animated instanced variant's block: the instanced fields, and the clip's `uBoneClip`. */
+export declare const FLAT_ANIMATED_VERT_FIELDS: {
+    readonly uHasTangents: {
+        readonly offset: 0;
         readonly size: 4;
-        readonly type: "float";
+        readonly type: "int";
     };
-    readonly uWindGust: {
-        readonly offset: 252;
-        readonly size: 4;
-        readonly type: "float";
+    readonly uUvScale: {
+        readonly offset: 8;
+        readonly size: 8;
+        readonly type: "vec2";
     };
-    readonly uWindTime: {
-        readonly offset: 256;
-        readonly size: 4;
-        readonly type: "float";
+    readonly uUvOffset: {
+        readonly offset: 16;
+        readonly size: 8;
+        readonly type: "vec2";
     };
-    readonly uWindSpatialPhase: {
-        readonly offset: 264;
+    readonly uBoneClip: {
+        readonly offset: 24;
         readonly size: 8;
         readonly type: "vec2";
     };
@@ -147,6 +151,14 @@ export declare const FLAT_VERT_FIELDS: {
  * 144 bytes a slot and is what a single ring costs.
  */
 export declare const FLAT_VERT_SIZE: number;
+/** The view block's fields, binding and size: the largest variant's, as `FLAT_VERT_SIZE` is. */
+export declare const FLAT_VIEW_FIELDS: Readonly<Record<string, {
+    readonly offset: number;
+    readonly size: number;
+    readonly length?: number;
+    readonly stride?: number;
+}>>;
+export declare const FLAT_VIEW_SIZE: number;
 /**
  * The most sampled textures and distinct samplers any lit variant carrying the environment probe
  * binds in its fragment stage, counted from the generated bindings: what a device must allow per
@@ -159,16 +171,43 @@ export declare function probeStageCeilings(): {
 };
 /** Everything the generator recorded about one permutation of the fragment stage. */
 export declare function flatFragmentBindings(variant: FlatVariant): StageBindings;
+/**
+ * The lit fragment stage's two blocks as the renderer keeps them on the CPU: the pass's, then the
+ * material's straight after it, in one scratch, with every field at its offset in that scratch.
+ *
+ * **One scratch rather than two, so no setter has to know which block its field is in.** A setter
+ * writes by name, as it always has; the draw copies the material's bytes — `passSize` onwards — into
+ * the store and the pass's bytes into a ring slot, each only when something has changed it.
+ */
+export interface FlatFragmentScratch {
+    readonly fields: StageBindings['fields'];
+    /** Bytes of the pass's block, which is where the material's starts in the scratch. */
+    readonly passSize: number;
+    readonly passBinding: number;
+    readonly materialSize: number;
+    readonly materialBinding: number;
+}
+export declare function flatFragmentScratch(variant: FlatVariant): FlatFragmentScratch;
 /** The depth format both backends compare with. */
 export { DEPTH_FORMAT } from '../../depthConvention.ts';
 /**
  * The layout this variant binds against.
  *
- * The vertex block is **dynamic**, because every draw supplies its own model matrix and tint
- * from its own slot of one buffer. The fragment block is not: it holds the lights, the fog
- * and the camera, settled once by `bindMeshPass` and unchanged between draws.
+ * All four blocks are **dynamic**: the vertex block because every draw supplies its own model
+ * matrix and tint from its own slot of one buffer; the fragment stage's pass block — the lights, the
+ * fog, the camera — and the vertex stage's view block because a frame binds more than one pass; and
+ * the material block because a material changes between draws. Their dynamic offsets go in binding
+ * order: the draw's, the pass's, the material's, the view's.
  */
-export declare function createFlatBindGroupLayout(device: GPUDevice, variant: FlatVariant, skinned?: boolean, morphed?: boolean): GPUBindGroupLayout;
+export declare function createFlatBindGroupLayout(device: GPUDevice, variant: FlatVariant, skinned?: boolean, morphed?: boolean, 
+/** The instanced variant that plays a bone animation: its three vertex textures. */
+animated?: boolean): GPUBindGroupLayout;
+/** What an animated draw binds besides its material: the clip's two textures and its batch's clocks. */
+export interface AnimationViews {
+    readonly places: GPUTextureView;
+    readonly turns: GPUTextureView;
+    readonly clocks: GPUTextureView;
+}
 /**
  * Bind the buffers and one view per declared texture.
  *
@@ -178,7 +217,7 @@ export declare function createFlatBindGroupLayout(device: GPUDevice, variant: Fl
  * and WebGPU still requires something there, which is why `renderer.ts` keeps an
  * `emptyTexture2D` for the same reason on the other side.
  */
-export declare function createFlatBindGroup(device: GPUDevice, layout: GPUBindGroupLayout, variant: FlatVariant, perDraw: GPUBuffer, perFrame: GPUBuffer, resolve: (name: string) => {
+export declare function createFlatBindGroup(device: GPUDevice, layout: GPUBindGroupLayout, variant: FlatVariant, perDraw: GPUBuffer, passes: GPUBuffer, materials: GPUBuffer, views: GPUBuffer, resolve: (name: string) => {
     view: GPUTextureView;
     sampler: GPUSampler;
 }, 
@@ -187,7 +226,9 @@ palette?: GPUTextureView | null,
 /** The delta view for a morphed bind group, or null for an unmorphed one. */
 deltas?: GPUTextureView | null, 
 /** A skinned bind group's cloth views — the draw's, or the stand-in where it sets none. */
-cloth?: ClothViews | null): GPUBindGroup;
+cloth?: ClothViews | null, 
+/** An animated instanced group's views. See `AnimationViews`. */
+animation?: AnimationViews | null): GPUBindGroup;
 /**
  * The pipeline, cached by the state that distinguishes it.
  *
@@ -251,7 +292,9 @@ skinPass?: SkinHalf,
  * The reflection pass's surface half: the draw again, against its own depth, into the two
  * targets `reflectionSurfacePass.ts` holds. The key must carry it: `|rs`.
  */
-reflectionSurface?: boolean): GPURenderPipeline;
+reflectionSurface?: boolean, 
+/** An instanced pipeline that plays a bone animation. The key must carry it: `|anim`. */
+animated?: boolean): GPURenderPipeline;
 /**
  * The same pipeline, compiled off the main thread.
  *

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

@@ -52,9 +52,13 @@ const FRAGMENT_BINDINGS = FLAT_BINDINGS.flatFrag;
  */
 const VERTEX_BINDINGS = FLAT_BINDINGS.flatVert;
 /** The key for a set of vertex flags: the same rule `variantKey` uses, flags on, sorted, joined. */
-export function flatVertexKey(skinned, morphed, instanced = false) {
+export function flatVertexKey(skinned, morphed, instanced = false, 
+/** Whether an instanced variant plays a bone animation. See `shaders/boneAnimation.ts`. */
+animated = false) {
     const on = [];
     /* Alphabetical, because the generator's own `variantKey` sorts and the two keys must agree. */
+    if (animated)
+        on.push('animated');
     if (instanced)
         on.push('instanced');
     if (morphed)
@@ -64,8 +68,8 @@ export function flatVertexKey(skinned, morphed, instanced = false) {
     return on.length === 0 ? 'none' : on.join('+');
 }
 /** Everything the generator recorded about one variant of the vertex stage. */
-export function flatVertexBindings(skinned, morphed = false, instanced = false) {
-    const key = flatVertexKey(skinned, morphed, instanced);
+export function flatVertexBindings(skinned, morphed = false, instanced = false, animated = false) {
+    const key = flatVertexKey(skinned, morphed, instanced, animated);
     const found = VERTEX_BINDINGS[key];
     if (found === undefined)
         throw new Error(`flatPass: no vertex bindings for variant "${key}"`);
@@ -136,6 +140,8 @@ for (const [key, bindings] of Object.entries(VERTEX_BINDINGS)) {
     }
 }
 export const FLAT_VERT_FIELDS = FLAT_BINDINGS.flatVert.none.fields;
+/** The animated instanced variant's block: the instanced fields, and the clip's `uBoneClip`. */
+export const FLAT_ANIMATED_VERT_FIELDS = FLAT_BINDINGS.flatVert['animated+instanced'].fields;
 /**
  * The **largest** variant's block, because one ring serves every draw.
  *
@@ -145,6 +151,30 @@ export const FLAT_VERT_FIELDS = FLAT_BINDINGS.flatVert.none.fields;
  */
 export const FLAT_VERT_SIZE = Math.max(...Object.values(VERTEX_BINDINGS).map((bindings) => bindings.uniformSize));
 const FLAT_VERT_BINDING = PLAIN_VERTEX.uniforms;
+/*
+ * **The view block may be shorter in a variant, never different.** One slot serves every lit draw
+ * of a pass, plain and instanced alike, so every field a variant's view block declares must sit
+ * where the plain variant has it. The instanced variant declares no wind, and its block is the plain
+ * one's first two matrices.
+ */
+const PLAIN_VIEW_FIELDS = PLAIN_VERTEX.viewFields ?? {};
+for (const [key, bindings] of Object.entries(VERTEX_BINDINGS)) {
+    if (bindings.viewUniforms !== PLAIN_VERTEX.viewUniforms) {
+        throw new Error(`flatPass: vertex variant "${key}" binds its view block elsewhere`);
+    }
+    for (const [field, here] of Object.entries(bindings.viewFields ?? {})) {
+        if (PLAIN_VIEW_FIELDS[field]?.offset !== here.offset) {
+            throw new Error(`flatPass: vertex variant "${key}" puts view field ${field} at ${here.offset} where the ` +
+                `plain variant has it at ${PLAIN_VIEW_FIELDS[field]?.offset}.`);
+        }
+    }
+}
+/** The view block's fields, binding and size: the largest variant's, as `FLAT_VERT_SIZE` is. */
+export const FLAT_VIEW_FIELDS = PLAIN_VIEW_FIELDS;
+export const FLAT_VIEW_SIZE = Math.max(...Object.values(VERTEX_BINDINGS).map((bindings) => bindings.viewSize ?? 0));
+const FLAT_VIEW_BINDING = PLAIN_VERTEX.viewUniforms ?? -1;
+if (FLAT_VIEW_BINDING < 0)
+    throw new Error('flatPass: the lit vertex stage declares no view block');
 /**
  * The most sampled textures and distinct samplers any lit variant carrying the environment probe
  * binds in its fragment stage, counted from the generated bindings: what a device must allow per
@@ -170,6 +200,26 @@ export function flatFragmentBindings(variant) {
         throw new Error(`flatPass: no bindings for variant "${variant}"`);
     return found;
 }
+export function flatFragmentScratch(variant) {
+    const bindings = flatFragmentBindings(variant);
+    const { materialUniforms, materialSize, materialFields } = bindings;
+    if (materialUniforms === undefined ||
+        materialSize === undefined ||
+        materialFields === undefined) {
+        throw new Error(`flatPass: variant "${variant}" has no material block`);
+    }
+    const fields = { ...bindings.fields };
+    for (const [name, field] of Object.entries(materialFields)) {
+        fields[name] = { ...field, offset: bindings.uniformSize + field.offset };
+    }
+    return {
+        fields,
+        passSize: bindings.uniformSize,
+        passBinding: bindings.uniforms,
+        materialSize,
+        materialBinding: materialUniforms,
+    };
+}
 /**
  * The lit fragment stage's constants, set from the cache's switches, keyed by each one's **id**.
  *
@@ -209,6 +259,13 @@ function flatFragmentConstants(variant, cache, model, skinPass = 'whole', reflec
     }
     return constants;
 }
+/** The material block's binding, which every lit variant declares. */
+function materialBinding(fragment) {
+    if (fragment.materialUniforms === undefined) {
+        throw new Error('flatPass: the lit fragment stage declares no material block');
+    }
+    return fragment.materialUniforms;
+}
 /** The depth format both backends compare with. */
 /* Re-exported so the twenty passes that already import it from here do not each learn a new
    module; `depthConvention.ts` is where the decision lives and why. */
@@ -218,11 +275,15 @@ const VISIBILITY_FRAGMENT = 0x2;
 /**
  * The layout this variant binds against.
  *
- * The vertex block is **dynamic**, because every draw supplies its own model matrix and tint
- * from its own slot of one buffer. The fragment block is not: it holds the lights, the fog
- * and the camera, settled once by `bindMeshPass` and unchanged between draws.
+ * All four blocks are **dynamic**: the vertex block because every draw supplies its own model
+ * matrix and tint from its own slot of one buffer; the fragment stage's pass block — the lights, the
+ * fog, the camera — and the vertex stage's view block because a frame binds more than one pass; and
+ * the material block because a material changes between draws. Their dynamic offsets go in binding
+ * order: the draw's, the pass's, the material's, the view's.
  */
-export function createFlatBindGroupLayout(device, variant, skinned = false, morphed = false) {
+export function createFlatBindGroupLayout(device, variant, skinned = false, morphed = false, 
+/** The instanced variant that plays a bone animation: its three vertex textures. */
+animated = false) {
     const fragment = flatFragmentBindings(variant);
     const entries = [
         {
@@ -230,15 +291,31 @@ export function createFlatBindGroupLayout(device, variant, skinned = false, morp
             visibility: VISIBILITY_VERTEX,
             buffer: { type: 'uniform', hasDynamicOffset: true, minBindingSize: FLAT_VERT_SIZE },
         },
+        {
+            binding: FLAT_VIEW_BINDING,
+            visibility: VISIBILITY_VERTEX,
+            /* Dynamic, a slot a pass, for the reason the fragment stage's pass block is. */
+            buffer: { type: 'uniform', hasDynamicOffset: true, minBindingSize: FLAT_VIEW_SIZE },
+        },
         {
             binding: fragment.uniforms,
             visibility: VISIBILITY_FRAGMENT,
             /*
-             * Dynamic, because this block carries the material and a material changes between draws.
-             * See `WebGPURenderer.perFrame` for why one buffer cannot hold two answers.
+             * Dynamic, because a pass's lights and camera change between passes of one frame — a
+             * mirror's, a capture's — and one buffer cannot hold two answers. See `WebGPURenderer.passRing`.
              */
             buffer: { type: 'uniform', hasDynamicOffset: true, minBindingSize: fragment.uniformSize },
         },
+        {
+            binding: materialBinding(fragment),
+            visibility: VISIBILITY_FRAGMENT,
+            /* Dynamic, because a material changes between draws. See `MaterialStore`. */
+            buffer: {
+                type: 'uniform',
+                hasDynamicOffset: true,
+                minBindingSize: fragment.materialSize ?? 0,
+            },
+        },
     ];
     /** What each sampler binding was declared as, so a shared one is declared once and agrees. */
     const samplerKind = new Map();
@@ -379,11 +456,33 @@ export function createFlatBindGroupLayout(device, variant, skinned = false, morp
             });
         }
     }
+    /* A bone animation's places, turns and the batch's clocks, read by index as the palette is. */
+    if (animated) {
+        for (const binding of animationBindings()) {
+            entries.push({
+                binding,
+                visibility: VISIBILITY_VERTEX,
+                texture: { sampleType: 'unfilterable-float' },
+            });
+        }
+    }
     return device.createBindGroupLayout({
-        label: `flat.layout:${variant}|${flatVertexKey(skinned, morphed)}`,
+        label: `flat.layout:${variant}|${flatVertexKey(skinned, morphed, animated, animated)}`,
         entries,
     });
 }
+/** The three textures a bone animation binds, in the order `AnimationViews` holds them. */
+function animationBindings() {
+    const textures = flatVertexBindings(false, false, true, true).textures;
+    const at = (name) => {
+        const found = textures[name];
+        if (found === undefined) {
+            throw new Error(`flatPass: the animated vertex shader declares no ${name}`);
+        }
+        return found.texture;
+    };
+    return [at('uBonePlaces'), at('uBoneTurns'), at('uInstanceClocks')];
+}
 /**
  * Bind the buffers and one view per declared texture.
  *
@@ -393,20 +492,27 @@ export function createFlatBindGroupLayout(device, variant, skinned = false, morp
  * and WebGPU still requires something there, which is why `renderer.ts` keeps an
  * `emptyTexture2D` for the same reason on the other side.
  */
-export function createFlatBindGroup(device, layout, variant, perDraw, perFrame, resolve, 
+export function createFlatBindGroup(device, layout, variant, perDraw, passes, materials, views, resolve, 
 /** The palette view for a skinned bind group, or null for an unskinned one. */
 palette = null, 
 /** The delta view for a morphed bind group, or null for an unmorphed one. */
 deltas = null, 
 /** A skinned bind group's cloth views — the draw's, or the stand-in where it sets none. */
-cloth = null) {
+cloth = null, 
+/** An animated instanced group's views. See `AnimationViews`. */
+animation = null) {
     const fragment = flatFragmentBindings(variant);
     const entries = [
         {
             binding: FLAT_VERT_BINDING,
             resource: { buffer: perDraw, size: FLAT_VERT_SIZE },
         },
-        { binding: fragment.uniforms, resource: { buffer: perFrame, size: fragment.uniformSize } },
+        { binding: FLAT_VIEW_BINDING, resource: { buffer: views, size: FLAT_VIEW_SIZE } },
+        { binding: fragment.uniforms, resource: { buffer: passes, size: fragment.uniformSize } },
+        {
+            binding: materialBinding(fragment),
+            resource: { buffer: materials, size: fragment.materialSize ?? 0 },
+        },
     ];
     /* The same dedupe the layout does, and for the same reason: the shadow bindings share one
        sampler, and a bind group that filled it fifteen times would be rejected. Every member
@@ -441,8 +547,14 @@ cloth = null) {
         entries.push({ binding: particlesAt, resource: cloth.particles });
         entries.push({ binding: restAt, resource: cloth.rest });
     }
+    if (animation !== null) {
+        const [places, turns, clocks] = animationBindings();
+        entries.push({ binding: places, resource: animation.places });
+        entries.push({ binding: turns, resource: animation.turns });
+        entries.push({ binding: clocks, resource: animation.clocks });
+    }
     return device.createBindGroup({
-        label: `flat.bindGroup:${variant}|${flatVertexKey(palette !== null, deltas !== null)}`,
+        label: `flat.bindGroup:${variant}|${flatVertexKey(palette !== null, deltas !== null, animation !== null, animation !== null)}`,
         layout,
         entries,
     });
@@ -510,8 +622,10 @@ skinPass = 'whole',
  * The reflection pass's surface half: the draw again, against its own depth, into the two
  * targets `reflectionSurfacePass.ts` holds. The key must carry it: `|rs`.
  */
-reflectionSurface = false) {
-    return cache.get(key, () => flatDescriptor(cache, device, layout, variant, key, present, translucent, skinned, morphed, depthWrite, depthLayer, instanced, oit, doubleSided, alphaToCoverage, skinEight, cloth, model, skinPass, reflectionSurface), true);
+reflectionSurface = false, 
+/** An instanced pipeline that plays a bone animation. The key must carry it: `|anim`. */
+animated = false) {
+    return cache.get(key, () => flatDescriptor(cache, device, layout, variant, key, present, translucent, skinned, morphed, depthWrite, depthLayer, instanced, oit, doubleSided, alphaToCoverage, skinEight, cloth, model, skinPass, reflectionSurface, animated), true);
 }
 /**
  * The same pipeline, compiled off the main thread.
@@ -591,7 +705,9 @@ oit = 'none',
 /** Culls nothing: a surface seen from both faces. */
 doubleSided = false, alphaToCoverage = false, skinEight = false, 
 /** Whether its vertex stage places vertices by a cloth binding. See `clothBinding.ts`. */
-cloth = false, model = null, skinPass = 'whole', reflectionSurface = false) {
+cloth = false, model = null, skinPass = 'whole', reflectionSurface = false, 
+/** An instanced pipeline that plays a bone animation. See `shaders/boneAnimation.ts`. */
+animated = false) {
     const offset = depthOffsetForLayer(depthLayer);
     /* The diffuse and colour halves are the same surface again, into the blur's targets; and so is
        the reflection pass's surface half, into its two. */
@@ -606,12 +722,12 @@ cloth = false, model = null, skinPass = 'whole', reflectionSurface = false) {
              * layout validates, draws, and is wrong, exactly as this file's header says.
              */
             module: shaderModule(device, {
-                label: `flat.vert:${flatVertexKey(skinned, morphed, instanced)}`,
-                code: FLAT_VERT_WGSL[flatVertexKey(skinned, morphed, instanced)] ?? '',
+                label: `flat.vert:${flatVertexKey(skinned, morphed, instanced, animated)}`,
+                code: FLAT_VERT_WGSL[flatVertexKey(skinned, morphed, instanced, animated)] ?? '',
             }),
             entryPoint: 'main',
             buffers: vertexBufferLayouts(present, instanced),
-            constants: vertexConstants(flatVertexBindings(skinned, morphed, instanced), skinEight, cloth, model === 'lightmap'),
+            constants: vertexConstants(flatVertexBindings(skinned, morphed, instanced, animated), skinEight, cloth, model === 'lightmap'),
         },
         fragment: {
             module: shaderModule(device, {

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

@@ -1,6 +1,7 @@
 import type { CullSlot } from './instanceCullPass.ts';
 import type { MeshInstances } from '../../instances.ts';
 import type { GpuMesh } from './buffers.ts';
+import { GpuInstanceClocks, type GpuBoneAnimation } from './boneAnimations.ts';
 /**
  * One mesh's per-instance buffer on the device.
  *
@@ -25,7 +26,19 @@ export declare class GpuInstancedBatch {
     /** The frame the slots were last taken in, and how many were taken. */
     slotFrame: number;
     slotsTaken: number;
-    constructor(device: GPUDevice, mesh: GpuMesh, capacity: number, label: string, cull?: boolean);
+    /** The bone animation every instance plays, and its clocks; null for a batch that plays none. */
+    readonly animation: GpuBoneAnimation | null;
+    readonly clocks: GpuInstanceClocks | null;
+    /**
+     * An animated batch's own groups — its lit twins by the material group they were built beside, its
+     * shadow groups by what they cut with — and the renderer's group epoch they were built in, after
+     * which every one is dropped. See `WebGPURenderer.animatedGroup`.
+     */
+    readonly litGroups: Map<GPUBindGroup, GPUBindGroup>;
+    readonly depthGroups: Map<unknown, GPUBindGroup>;
+    readonly depthPeelGroups: Map<unknown, GPUBindGroup>;
+    groupEpoch: number;
+    constructor(device: GPUDevice, mesh: GpuMesh, capacity: number, label: string, cull?: boolean, animation?: GpuBoneAnimation | null);
     /** Last frame's packed slots, for a reconstruction; made on first use by the renderer. */
     previousBuffer: GPUBuffer | null;
     /** How many slots the upload before the last one held, and how many the last one holds. */

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

@@ -1,6 +1,8 @@
 import { instancesBox } from '../../instanceCull.js';
 import { INSTANCE_FLOATS, INSTANCE_STRIDE, packInstances } from '../../instances.js';
 import { destroySlot } from './instanceCullPass.js';
+import { packInstanceClocks } from '../../boneAnimation.js';
+import { GpuInstanceClocks } from './boneAnimations.js';
 /** VERTEX | COPY_DST, spelled the way every other pass here spells it. */
 const USAGE_VERTEX = 0x0020 | 0x0008;
 /** A culling batch's source is read by the cull as storage too. */
@@ -29,10 +31,26 @@ export class GpuInstancedBatch {
     /** The frame the slots were last taken in, and how many were taken. */
     slotFrame = -1;
     slotsTaken = 0;
-    constructor(device, mesh, capacity, label, cull = false) {
+    /** The bone animation every instance plays, and its clocks; null for a batch that plays none. */
+    animation;
+    clocks;
+    /**
+     * An animated batch's own groups — its lit twins by the material group they were built beside, its
+     * shadow groups by what they cut with — and the renderer's group epoch they were built in, after
+     * which every one is dropped. See `WebGPURenderer.animatedGroup`.
+     */
+    litGroups = new Map();
+    depthGroups = new Map();
+    depthPeelGroups = new Map();
+    groupEpoch = -1;
+    constructor(device, mesh, capacity, label, cull = false, animation = null) {
         this.mesh = mesh;
         this.capacity = capacity;
+        /* An animated batch is culled whole and never by instance: see `submitInstanced`. */
         this.cull = cull;
+        this.animation = animation;
+        this.clocks =
+            animation === null ? null : new GpuInstanceClocks(device, capacity, `${label}.clocks`);
         this.staging = new Float32Array(capacity * INSTANCE_FLOATS);
         this.buffer = device.createBuffer({
             /*
@@ -76,10 +94,15 @@ export class GpuInstancedBatch {
             return;
         packInstances(data, this.staging);
         queue.writeBuffer(this.buffer, 0, this.staging, 0, count * INSTANCE_FLOATS);
+        if (this.clocks !== null) {
+            packInstanceClocks(data, this.clocks.staging);
+            this.clocks.upload(queue, count);
+        }
     }
     dispose() {
         this.previousBuffer?.destroy();
         this.buffer.destroy();
+        this.clocks?.dispose();
         for (const slot of this.slots)
             destroySlot(slot);
     }