@driftengine/core 4.9.0 → 4.11.0

package/dist/render/backend/select.js

@@ -207,12 +207,18 @@ async function acquireWebGpu(gpu, wantsGpuTiming, shaders, stage) {
             features.push('timestamp-query');
         }
         /*
-         * BC compressed textures, on the same terms: asked for wherever the adapter offers it, because
-         * a device without it still draws — the loader decodes for it — and one with it samples a BC7
-         * texture at a byte a texel instead of four. See `compressedUpload.ts`.
+         * The three block families, on the same terms: each asked for wherever the adapter offers it,
+         * because a device without one still draws — the loader decodes, or encodes ETC2, for it — and
+         * one with it samples a texture at a byte a texel or half of one instead of four. Desktops
+         * offer BC; phones ETC2 and ASTC. See `compressedUpload.ts`.
          */
-        if (adapter.features?.has('texture-compression-bc') === true) {
-            features.push('texture-compression-bc');
+        for (const family of [
+            'texture-compression-bc',
+            'texture-compression-etc2',
+            'texture-compression-astc',
+        ]) {
+            if (adapter.features?.has(family) === true)
+                features.push(family);
         }
         const descriptor = {};
         if (Object.keys(required).length > 0)

package/dist/render/backend/webgl2/boneAnimations.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A bone animation's textures on this backend, and a batch's clocks: what
+ * `shaders/boneAnimation.ts` reads with `texelFetch`, made once and never filtered. The twin of
+ * `webgpu/boneAnimations.ts`, at the same formats for the same reason: a turn in half floats jitters
+ * a crowd's hands at the frame's rate.
+ */
+import { type BoneAnimationHandle, type BoneAnimationTexels } from '../../boneAnimation.ts';
+/** A clip on the device, from `createBoneAnimation`. */
+export declare class GlBoneAnimation implements BoneAnimationHandle {
+    readonly bones: number;
+    readonly frames: number;
+    readonly framesPerSecond: number;
+    readonly boneScale: number;
+    readonly places: WebGLTexture;
+    readonly turns: WebGLTexture;
+    disposed: boolean;
+    constructor(gl: WebGL2RenderingContext, texels: BoneAnimationTexels);
+    dispose(gl: WebGL2RenderingContext): void;
+}
+/** A batch's clocks: two floats an instance, wrapped onto rows `CLOCK_TEXTURE_WIDTH` wide. */
+export declare class GlInstanceClocks {
+    readonly texture: WebGLTexture;
+    readonly staging: Float32Array;
+    private readonly width;
+    constructor(gl: WebGL2RenderingContext, capacity: number);
+    /** The rows that hold the first `count` instances, from `staging`. */
+    upload(gl: WebGL2RenderingContext, count: number): void;
+    dispose(gl: WebGL2RenderingContext): void;
+}

package/dist/render/backend/webgl2/boneAnimations.js

@@ -0,0 +1,80 @@
+/**
+ * A bone animation's textures on this backend, and a batch's clocks: what
+ * `shaders/boneAnimation.ts` reads with `texelFetch`, made once and never filtered. The twin of
+ * `webgpu/boneAnimations.ts`, at the same formats for the same reason: a turn in half floats jitters
+ * a crowd's hands at the frame's rate.
+ */
+import { CLOCK_TEXTURE_WIDTH, } from '../../boneAnimation.js';
+/**
+ * A float texture read by index: one level, nearest, clamped. Bound on unit 0, chosen rather than
+ * inherited, for the reason `oitPass.ts` gives: `bindTexture` binds to whatever unit is active, and
+ * a frame leaves that wherever its last pass finished.
+ */
+function floatTexture(gl, internal, width, height) {
+    const texture = gl.createTexture();
+    if (texture === null)
+        throw new Error('boneAnimations: createTexture failed');
+    gl.activeTexture(gl.TEXTURE0);
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.texStorage2D(gl.TEXTURE_2D, 1, internal, width, height);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    return texture;
+}
+/** A clip on the device, from `createBoneAnimation`. */
+export class GlBoneAnimation {
+    bones;
+    frames;
+    framesPerSecond;
+    boneScale;
+    places;
+    turns;
+    disposed = false;
+    constructor(gl, texels) {
+        this.bones = texels.bones;
+        this.frames = texels.frames;
+        this.framesPerSecond = texels.framesPerSecond;
+        this.boneScale = texels.boneScale;
+        const make = (data) => {
+            const texture = floatTexture(gl, gl.RGBA32F, texels.bones, texels.frames);
+            gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, texels.bones, texels.frames, gl.RGBA, gl.FLOAT, data);
+            return texture;
+        };
+        this.places = make(texels.places);
+        this.turns = make(texels.turns);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+    }
+    dispose(gl) {
+        this.disposed = true;
+        gl.deleteTexture(this.places);
+        gl.deleteTexture(this.turns);
+    }
+}
+/** A batch's clocks: two floats an instance, wrapped onto rows `CLOCK_TEXTURE_WIDTH` wide. */
+export class GlInstanceClocks {
+    texture;
+    staging;
+    width;
+    constructor(gl, capacity) {
+        this.width = Math.max(1, Math.min(capacity, CLOCK_TEXTURE_WIDTH));
+        const rows = Math.max(1, Math.ceil(capacity / this.width));
+        this.staging = new Float32Array(this.width * rows * 2);
+        this.texture = floatTexture(gl, gl.RG32F, this.width, rows);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+    }
+    /** The rows that hold the first `count` instances, from `staging`. */
+    upload(gl, count) {
+        if (count <= 0)
+            return;
+        const rows = Math.ceil(count / this.width);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this.texture);
+        gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, this.width, rows, gl.RG, gl.FLOAT, this.staging);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+    }
+    dispose(gl) {
+        gl.deleteTexture(this.texture);
+    }
+}

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

@@ -1,6 +1,7 @@
 import type { MeshInstances } from '../../instances.ts';
 import type { Mesh } from '../../mesh.ts';
 import type { FrustumPlanes } from '../../../math/frustum.ts';
+import { GlInstanceClocks, type GlBoneAnimation } from './boneAnimations.ts';
 /**
  * One batch of a mesh: its per-instance buffer and a vertex array of its own.
  *
@@ -29,7 +30,10 @@ export declare class InstancedBatch {
     /** The survivors of a lightmapped batch's cull, made the first time one is culled. */
     private keptRegioned;
     private readonly kept;
-    constructor(gl: WebGL2RenderingContext, mesh: Mesh, capacity: number, cull?: boolean);
+    /** The bone animation every instance plays, and its clocks; null for a batch that plays none. */
+    readonly animation: GlBoneAnimation | null;
+    readonly clocks: GlInstanceClocks | null;
+    constructor(gl: WebGL2RenderingContext, mesh: Mesh, capacity: number, cull?: boolean, animation?: GlBoneAnimation | null);
     upload(gl: WebGL2RenderingContext, data: MeshInstances): void;
     /** Draw the first `count` uploaded instances: every draw but a culling camera draw. */
     draw(gl: WebGL2RenderingContext, count: number): void;

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

@@ -1,5 +1,7 @@
 import { cullInstances, instancesBox } from '../../instanceCull.js';
 import { INSTANCE_FLOATS, INSTANCE_STRIDE, createMeshInstances, packInstances, } from '../../instances.js';
+import { packInstanceClocks } from '../../boneAnimation.js';
+import { GlInstanceClocks } from './boneAnimations.js';
 /**
  * One batch of a mesh: its per-instance buffer and a vertex array of its own.
  *
@@ -28,10 +30,15 @@ export class InstancedBatch {
     /** The survivors of a lightmapped batch's cull, made the first time one is culled. */
     keptRegioned = null;
     kept;
-    constructor(gl, mesh, capacity, cull = false) {
+    /** The bone animation every instance plays, and its clocks; null for a batch that plays none. */
+    animation;
+    clocks;
+    constructor(gl, mesh, capacity, cull = false, animation = null) {
         this.mesh = mesh;
         this.capacity = capacity;
         this.cull = cull;
+        this.animation = animation;
+        this.clocks = animation === null ? null : new GlInstanceClocks(gl, capacity);
         this.staging = new Float32Array(capacity * INSTANCE_FLOATS);
         this.buffer = allocate(gl, capacity);
         this.vao = mesh.createInstanceArray(gl, this.buffer, INSTANCE_STRIDE);
@@ -56,6 +63,10 @@ export class InstancedBatch {
         packInstances(data, this.staging);
         gl.bindBuffer(gl.ARRAY_BUFFER, this.buffer);
         gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.staging, 0, count * INSTANCE_FLOATS);
+        if (this.clocks !== null) {
+            packInstanceClocks(data, this.clocks.staging);
+            this.clocks.upload(gl, count);
+        }
     }
     /** Draw the first `count` uploaded instances: every draw but a culling camera draw. */
     draw(gl, count) {
@@ -88,6 +99,7 @@ export class InstancedBatch {
     dispose(gl) {
         gl.deleteVertexArray(this.vao);
         gl.deleteBuffer(this.buffer);
+        this.clocks?.dispose(gl);
         if (this.kept !== null) {
             gl.deleteVertexArray(this.kept.vao);
             gl.deleteBuffer(this.kept.buffer);

package/dist/render/backend/webgl2/renderer.d.ts

@@ -44,13 +44,14 @@ import type { AreaLightBuffer, AreaLightSource } from '../../areaLights.ts';
 import type { PhotometricProfile } from '../../iesProfile.ts';
 import type { ShadowLight } from '../../pointShadowSystem.ts';
 import type { ShadowCasters } from '../../shadowCasters.ts';
+import type { StaticDrawsHandle } from '../../staticDraws.ts';
 import type { RenderQuality, RenderQualityOptions } from '../../renderQuality.ts';
 import { Mesh } from '../../mesh.ts';
 import type { IncrementalMesh } from '../../mesh.ts';
 import type { MeshData } from '../../mesh.ts';
 import type { MeshOptions } from '../api.ts';
 import { SurfaceTexture } from '../../surfaceTexture.ts';
-import type { CompressedTextureFormat, SurfaceSource } from '../../compressedSource.ts';
+import type { CompressedTextureFormat, CompressedTextureSource, SurfaceSource } from '../../compressedSource.ts';
 import type { SurfaceMaterial, SurfaceTextureOptions } from '../../surfaceTexture.ts';
 import { PlumeRenderer } from '../../plumeRenderer.ts';
 import type { PlumeOptions, PlumePlacement } from '../../plumeRenderer.ts';
@@ -82,6 +83,7 @@ import type { WindStreakOptions } from '../../windStreakRenderer.ts';
 import type { WindField } from '../../windField.ts';
 import type { FlockParams } from '../../flockRenderer.ts';
 import { InstancedBatch } from './instanced.ts';
+import type { BoneAnimationClip, BoneAnimationHandle } from '../../boneAnimation.ts';
 import type { InstancedOptions, MeshInstances } from '../../instances.ts';
 /** Reused each frame: which shader light slot each bound cubemap serves. */
 export type { ShadowCasterSink, ShadowCasters } from '../../shadowCasters.ts';
@@ -929,6 +931,15 @@ export declare class WebGL2Renderer implements RendererApi {
      * compiled the first time a draw asks for one. See `modelProgram`.
      */
     private readonly modelFlat;
+    /**
+     * Model programs still compiling, where draws skip a compile (`pipelineCompile: 'skip'`) and the
+     * context offers `KHR_parallel_shader_compile`; `parallelCompile` is its completion query then,
+     * and null where draws wait for a program here instead. See `modelProgram`.
+     */
+    private readonly modelPending;
+    /** What `drawVariantOf` answers, rewritten each draw rather than made. */
+    private readonly drawVariant;
+    private readonly parallelCompile;
     /** The last palette chosen, which an eye's axis is turned by. See `setSkinPalette`. */
     private paletteData;
     private readonly emptyTexture2D;
@@ -991,7 +1002,7 @@ export declare class WebGL2Renderer implements RendererApi {
     private oitReplaying;
     /** `uSurfaceScene`, resolved once a pass. See `surfaceScene.ts`. */
     private readonly surfaceScene;
-    /** The two halves of `uWriteMode`, kept here because a `vec2` is written whole. */
+    /** The three lanes of `uWriteMode`, kept here because a `vec3` is written whole. */
     private oitWeight;
     /**
      * How the surfaces drawn next meet the medium: what `setSurfaceFog` set, and `FOG_RECEDE` from
@@ -999,6 +1010,7 @@ export declare class WebGL2Renderer implements RendererApi {
      */
     private surfaceFog;
     private ditherFade;
+    private ditherOpacity;
     /** Said once, not per frame, where the context cannot give the float target the sum needs. */
     private oitRefused;
     /** Said once for the whole renderer. See `refuseOitMultisampled`. */
@@ -1156,6 +1168,11 @@ export declare class WebGL2Renderer implements RendererApi {
     private readonly depthCutoutUniforms;
     private readonly depthInstancedCutoutProgram;
     private readonly depthInstancedCutoutUniforms;
+    /** A crowd's casters: the instanced depth programs that play a bone animation. */
+    private readonly depthAnimatedProgram;
+    private readonly depthAnimatedUniforms;
+    private readonly depthAnimatedCutoutProgram;
+    private readonly depthAnimatedCutoutUniforms;
     private readonly scatterDepthProgram;
     private readonly scatterDepthUniforms;
     /** The sun's static, moving and peeled maps, as layers of one array. See `shadowMap.ts`. */
@@ -1250,6 +1267,28 @@ export declare class WebGL2Renderer implements RendererApi {
     private overlayTexture;
     /** Whether this device's lit stage has room for the overlay's vectors: asked once. */
     private overlayRoom;
+    /**
+     * The matrix the sun's dynamic shadow pass was last drawn with, uncorrected, and whether one has
+     * been: what the moving layer is read through. See `movingLightFor`.
+     */
+    private readonly movingLightViewProj;
+    private movingLightKnown;
+    /** Whether the lit stage has room for the moving layer's matrix, and whether its refusal was said. */
+    private movingRoom;
+    private warnedMovingRoom;
+    /** The same answer for a material's projection, and whether its refusal was said. */
+    private projectionRoom;
+    private warnedProjectionRoom;
+    /** `uWorldUv`, the current material's projection packed. See `surfaceProjection.ts`. */
+    private readonly projection;
+    /** The current material's `diffuseTransmission`, `uGlassTint.w`, 0 to 1. */
+    private diffuseTransmission;
+    /** `uLayers`, the current material's layers packed. See `surfaceLayers.ts`. */
+    private readonly layerFloats;
+    /** Whether the lit stage has room for layers' two vectors, and which refusals were said. */
+    private layersRoom;
+    private warnedLayersRoom;
+    private warnedLayersModelMap;
     private warnedOverlayRoom;
     private warnedOverlayBlocks;
     /** Whether a probe is being baked, so the passes that would recurse into one can tell. */
@@ -1779,6 +1818,15 @@ export declare class WebGL2Renderer implements RendererApi {
      * this before its first frame gets the right behaviour on both without asking which backend
      * it has, which is the contract `RendererApi` exists to keep.
      */
+    /**
+     * Resolve once every program a draw has started compiling has finished, adopting each: what a
+     * loading screen awaits after drawing what its scene will use, where draws skip a compile. See
+     * `RenderQuality.pipelineCompile`; nothing is started anywhere else here, so otherwise it is now.
+     *
+     * **It waits without holding the thread**, as the other backend's does: it asks the driver
+     * whether each is done, which does not wait, and yields between asks. A driver that never says
+     * done is asked the way that waits after `READY_MAX_POLLS`, so this cannot hang a loading screen.
+     */
     ready(): Promise<void>;
     dispose(options?: {
         releaseContext?: boolean;
@@ -1894,7 +1942,7 @@ export declare class WebGL2Renderer implements RendererApi {
      *
      * Not a hot path — it re-uploads the whole image and regenerates the mip chain.
      */
-    updateSurfaceTexture(texture: SurfaceTexture, source: TexImageSource): void;
+    updateSurfaceTexture(texture: SurfaceTexture, source: TexImageSource | CompressedTextureSource): void;
     disposeSurfaceTexture(texture: SurfaceTexture): void;
     /**
      * Choose the surface texture the following `drawMesh` calls sample, or `null` for none.
@@ -1929,6 +1977,8 @@ export declare class WebGL2Renderer implements RendererApi {
      * material at once, as `ensureClothPrograms` feeds its own.
      */
     private modelProgram;
+    /** A model program compiled: kept, written to by every material setter, and fed the pass. */
+    private adoptModel;
     /**
      * An eye's axis in the world for this draw, into its program's `uModelParams`: the material's
      * own numbers with the axis turned by the draw's model matrix and the eye's joint. See
@@ -2035,6 +2085,16 @@ export declare class WebGL2Renderer implements RendererApi {
      * exactly as it did.
      */
     setSurfaceReflectivity(amount: number): void;
+    /**
+     * The reflectivity and environment gain the setters gave the pass, and the ones the material
+     * set now states, or null where it states none (`SurfaceMaterial.reflectivity`). A draw wears the
+     * material's where it has one and the pass's otherwise.
+     */
+    private passReflectivity;
+    private passEnvironmentGain;
+    private materialReflectivity;
+    private materialEnvironmentGain;
+    private writeEnvironmentDials;
     /**
      * The overlay the following draws wear — a rim of light, a dissolve, wrinkles by region — or null
      * for none. Pass state, as the material is: `bindMeshPass` puts it back to none. See
@@ -2056,6 +2116,32 @@ export declare class WebGL2Renderer implements RendererApi {
     private overlayRoomLeft;
     /** Whether the lit shader with the overlay compiled in fits this GPU: counted once. */
     private overlayFits;
+    /**
+     * Whether a material's projection can be drawn: none asked, or the lit stage has the room for its
+     * one vector. **Refused, said once, where it has not**, as the overlay is, and the material's
+     * maps are then laid by the mesh's coordinates, as they were before it existed.
+     */
+    private projectionFits;
+    /**
+     * What the sun's moving layer is read through: the matrix its shadow pass was last drawn with,
+     * where the lit stage carries one (`MOVING_SUN`); the environment's otherwise, which every caller
+     * drawing both layers with one matrix hands it anyway.
+     */
+    private movingLightFor;
+    /**
+     * Turn the moving layer's own matrix on the first time a frame draws that layer with one the
+     * environment's does not share. **Refused, said once, where the lit stage has no room for its five
+     * vectors**: the layer is then read through the environment's matrix, so its shadows land where
+     * that matrix puts them, and a caller there draws both layers with one.
+     */
+    private askMovingSun;
+    /**
+     * A material's layers where they can be drawn: none asked, a model's map in the mask's place, or
+     * no room for their two vectors each leave one layer, the last two said once each.
+     */
+    private layersOf;
+    /** Whether the lit shader with `feature` compiled in fits this GPU's fragment uniform vectors. */
+    private switchFits;
     /**
      * How bright the environment the surfaces drawn next reflect is. 1 is the default and identity.
      *
@@ -2138,7 +2224,25 @@ export declare class WebGL2Renderer implements RendererApi {
      * are a pass of their own, do not. See `uDither` in `flat/preamble.ts` for what it costs.
      */
     setDitherFade(amount: number): void;
-    /** `uWriteMode`: the order-independent weight and the dither, which share one uniform row. */
+    /**
+     * Whether the draws that follow spend their own opacity on a screen door rather than on blending:
+     * an instance's `MeshInstances.alphas`, or a vertex's channel alpha, keeps that share of the
+     * pixels `setDitherFade` would and draws the rest not at all. So an opaque or cut-out batch fades
+     * one instance at a time, with no sorting and no blend, and an instance at 1 is drawn whole.
+     *
+     * Off is what `bindMeshPass` restores. It shares the fade's pattern, so a crossfade at `t` and
+     * `-t` of an instance at opacity `a` covers that instance's share once, without holes. Material
+     * state like `setDitherFade`; instanced draws read it, and shadow casters do not.
+     *
+     * What it gives up: a fade reads as grain while it lasts, which a temporal resolve smooths and a
+     * plain frame does not; a blended draw that asks spends its opacity here and blends none of it;
+     * and a lightmapped batch carries regions where the opacities would be, so it has none to fade.
+     */
+    setDitherOpacity(on: boolean): void;
+    /**
+     * `uWriteMode`: the order-independent weight, the fade and whether the opacity is dithered, which
+     * share one uniform row.
+     */
     private writeMode;
     /**
      * How strong the microscopic relief on the surfaces drawn next is, and how coarse.
@@ -2231,6 +2335,40 @@ export declare class WebGL2Renderer implements RendererApi {
      * one. `Mesh.attachInstances` is what refuses a second, and says why.
      */
     createInstanced(mesh: Mesh, capacity: number, options?: InstancedOptions): InstancedBatch;
+    /**
+     * A bone animation an instanced batch can play (`InstancedOptions.animation`): per frame, a turn
+     * and a place for each bone, which every vertex of the batch's mesh follows — the bone its second
+     * coordinates' u names, times `boneScale` — at each instance's own moment of the clip. What a
+     * crowd is made of: every instance moves at the frame's rate on its own clock, in the colour pass
+     * and in every shadow, with nothing on the processor after this. See `boneAnimation.ts` for the
+     * clip's layout and the arithmetic, which both backends run.
+     *
+     * What it gives up against skinning is the blend: a vertex follows one bone. Refused, with what
+     * was wrong, for a clip whose numbers are not its size, or past 2,048 bones or frames.
+     */
+    createBoneAnimation(clip: BoneAnimationClip): BoneAnimationHandle;
+    /** Release a clip. A batch still playing it draws nothing, and casts nothing, after. */
+    disposeBoneAnimation(animation: BoneAnimationHandle): void;
+    /**
+     * The clock a bone animation plays by this frame, in seconds on the caller's clock: an instance's
+     * moment is this times its rate plus its phase (`MeshInstances.clocks`). **Set it before the
+     * shadows are drawn**, once a frame, as the wind is set: a shadow drawn under one clock and its
+     * caster under another come apart at the frame's rate. 0 until set, which holds every crowd at
+     * the moment its phases name.
+     */
+    setAnimationTime(seconds: number): void;
+    /** The clock `setAnimationTime` set. */
+    private animationTime;
+    /**
+     * An animated batch's clip, clocks and numbers into whichever program is bound: the three vertex
+     * textures on units of their own (`lightBudget.ts`), the clip's speed and bone scale, the clock.
+     */
+    private bindAnimation;
+    /** The animated instanced program, compiled on first use. See `ensureInstancedProgram`. */
+    private flatAnimatedProgram;
+    private flatAnimatedUniforms;
+    /** Compile the animated variant, once, and feed it this frame's pass state. */
+    private ensureAnimatedProgram;
     /** Push placement and colour. Only the live prefix. */
     uploadInstanced(batch: InstancedBatch, data: MeshInstances): void;
     /** Draw every live instance, opaque. */
@@ -2765,6 +2903,43 @@ export declare class WebGL2Renderer implements RendererApi {
      */
     drawSceneCasters(casters: ShadowCasters): void;
     drawShadowCasters(casters: ShadowCasters): void;
+    /**
+     * Draws that do not change between frames, enumerated once and kept: what a stage, a set or any
+     * world that stands still draws, recorded so a frame replays it rather than issuing it.
+     *
+     * **The same enumeration `drawSceneCasters` takes**, called once, here: rigid meshes and instanced
+     * batches, each with its material. A skinned mesh or a scatter batch is refused by name, since
+     * both change every frame. What it captures is what the enumeration said at the time — the
+     * matrices and the instance counts are copied, so a caller's scratch is free to move on — while
+     * the meshes, batches, textures and materials stay the caller's: a list must be disposed, or made
+     * again, before anything it holds is, and made again when a material it holds is changed.
+     *
+     * **What it is for is the frame's processor time.** WebGPU records the list into a render bundle
+     * per view and replays it with one call, where a draw issued a frame at a time costs its encoding
+     * every frame and again for every view that draws it. This backend has no bundles and replays the
+     * entries through the scene-caster path every frame, at the cost a frame drawing them itself pays;
+     * the picture is the same.
+     *
+     * What a list gives up against drawing each frame is culling: every entry is drawn in every view,
+     * because a bundle cannot leave one out. A world split into lists by region culls by list.
+     */
+    createStaticDraws(casters: ShadowCasters): StaticDrawsHandle;
+    /**
+     * Draw a list into the open mesh pass, under the camera, the lights and the fog `bindMeshPass`
+     * set — the frame's, a mirror's, a capture's. Opaque draws, through each entry's material.
+     *
+     * **Its draws are rigid and wear no overlay**, so a skin palette, morph weights, cloth or a surface
+     * overlay set before it is put back to none, as `bindMeshPass` puts an overlay back; and no
+     * material is left set after it, which is what `setMaterial(null)` leaves. The state a pass set —
+     * the grain, the relief, the fog, the grade — is the list's to draw with, as it is any draw's, and
+     * a list drawn under a different one is recorded again for it on WebGPU.
+     */
+    drawStaticDraws(draws: StaticDrawsHandle): void;
+    /** Release a list. Its meshes, batches and materials are the caller's and are not released. */
+    disposeStaticDraws(draws: StaticDrawsHandle): void;
+    /** A disposed list drawn, said once: the frame loop does not throw. */
+    private warnStaticDisposed;
+    private warnedStaticDisposed;
     /**
      * Draw the pass's glass twice: where the nearest pane is, and what the panes let through.
      *
@@ -3621,6 +3796,16 @@ export declare class WebGL2Renderer implements RendererApi {
      */
     private scatterSkin;
     /** One draw of a mesh, as `drawMesh` describes, of the half of a skin `half` names. */
+    /**
+     * Whether every half a split skin draws has its program, starting any that has not: a skin drawn
+     * without its kept halves would lose its diffuse light for the frames they take to compile.
+     */
+    private skinHalvesReady;
+    /**
+     * The vertex variant a draw of `mesh` takes now, and its program and uniforms where it is not the
+     * plain one: what a model's program is keyed by, and what `drawMeshHalf` draws with.
+     */
+    private drawVariantOf;
     private drawMeshHalf;
     /**
      * Draw a mesh you can see through, in the same material as everything else by default.