@driftengine/core 4.10.0 → 4.11.1

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

@@ -1,3 +1,5 @@
+import { vertexPackingOf } from '../../vertexPacking.js';
+import { markPacking, markPackingOfKey, packingKey } from './vertexFormats.js';
 import { mat4 } from 'gl-matrix';
 import { probeFaceRange } from '../../reflectionProbe.js';
 import { TEMPORAL_FLICKER, TEMPORAL_HISTORY_BLEND, TemporalHistory, flickerRule, jitterOffset, jitterProjection, } from '../../temporalAa.js';
@@ -60,6 +62,11 @@ import { gpuCompressedFormats } from './compressedUpload.js';
 import { GpuClothBinding, GpuClothParticles, clothStandIn } from './clothTextures.js';
 import { MODEL_PARAM_FLOATS, eyeAxisInWorld, packModel, skinProfileDistance, } from '../../surfaceModel.js';
 import { OVERLAY_FLOATS, overlayLays, packSurfaceOverlay, } from '../../surfaceOverlay.js';
+import { PROJECTION_FLOATS, packSurfaceProjection } from '../../surfaceProjection.js';
+import { resolveTransmission } from '../../transmission.js';
+import { resolveOcclusionFade } from '../../occlusionFade.js';
+import { orthographicDepthSpan } from '../../lightMatrix.js';
+import { LAYER_FLOATS, layerMaskMap, layeredProjection, layersFitBeside, packSurfaceLayers, } from '../../surfaceLayers.js';
 import { frameReflectionsRefused, resolveFrameReflections, } from '../../frameReflections.js';
 import { REFLECTION_SURFACE_FORMAT, ReflectionSurfacePass } from './reflectionSurfacePass.js';
 import { validateClothBinding } from '../../clothBindingData.js';
@@ -223,6 +230,11 @@ const MAX_OVERLAYS = 64;
  * and passes nobody has written yet; the cost is sixteen kilobytes.
  */
 const MAX_SKY_DRAWS = 64;
+/** The draw a preparation asks pipelines for: every option at its default. See `prepareMesh`. */
+const PREPARED_DRAW = {};
+/** A preparation's morph states for a mesh with no targets, and for one with some. */
+const NOT_MORPHED = [false];
+const MORPHED_OR_NOT = [false, true];
 /**
  * Whether the environment probe's permutation fits this device's per-stage binding limits.
  *
@@ -857,7 +869,21 @@ export class WebGPURenderer {
      * flight at the time, so a consumer that builds more meshes later can wait again.
      */
     async ready() {
-        await Promise.all(this.pipelineTargets.map((cache) => cache.ready()));
+        await Promise.all(this.pipelineCaches().map((cache) => cache.ready()));
+    }
+    /** Every distinct cache a lit draw reaches: the frame's, the canvas's, the late pass's, skin's. */
+    pipelineCaches() {
+        const caches = [...this.pipelineTargets];
+        for (const cache of [this.latePipelines, this.skinPipelines]) {
+            if (cache !== null && !caches.includes(cache))
+                caches.push(cache);
+        }
+        return caches;
+    }
+    /** Whether a lit draw whose pipeline is not built is left out while it compiles. */
+    skipCompiling(skips) {
+        for (const cache of this.pipelineCaches())
+            cache.skipsCompiling = skips;
     }
     presentedFrameCount = 0;
     /**
@@ -1627,6 +1653,8 @@ export class WebGPURenderer {
     temporalHistoryUsable = false;
     aoStaging = new ArrayBuffer(AO_FRAG_SIZE);
     aoFloats = new Float32Array(this.aoStaging);
+    /** Where occlusion fades out with distance, `uFade`: none until a caller sets one. */
+    aoFade = new Float32Array([-1, 0]);
     aoBindGroup = null;
     aoBlurLayout;
     /**
@@ -2177,6 +2205,7 @@ export class WebGPURenderer {
             }
             filmCommand.vertexCount = geometry.vertexBuffers.length;
             filmCommand.indexBuffer = geometry.indexBuffer;
+            filmCommand.indexFormat = geometry.indexFormat;
             filmCommand.indexed = true;
             filmCommand.count = geometry.indexCount;
         }
@@ -2189,7 +2218,7 @@ export class WebGPURenderer {
             for (let index = 0; index < geometry.vertexBuffers.length; index++) {
                 pass.setVertexBuffer(index, geometry.vertexBuffers[index]);
             }
-            pass.setIndexBuffer(geometry.indexBuffer, 'uint32');
+            pass.setIndexBuffer(geometry.indexBuffer, geometry.indexFormat);
             pass.drawIndexed(geometry.indexCount);
         }
     }
@@ -2223,6 +2252,17 @@ export class WebGPURenderer {
     modelMap = null;
     /** The material's shading model, which picks the lit pipeline: null the standard. */
     materialModel = null;
+    /** `uWorldUv`, the material's projection packed by `packSurfaceProjection`. */
+    projection = new Float32Array(PROJECTION_FLOATS);
+    /** `uLayers`, the material's layers packed by `packSurfaceLayers`. */
+    layerFloats = new Float32Array(LAYER_FLOATS);
+    /**
+     * `uGlassTint` as the material leaves it, its light from behind and that light's colour, which a
+     * pane overwrites for its own draw and `releaseSeeThrough` puts back. See `transmission.ts`.
+     */
+    transmission = new Float32Array([-1, -1, -1, 0]);
+    warnedLayersModelMap = false;
+    warnedLayersTriplanar = false;
     /** Its numbers, `uModelParams`, packed by `packModel`. */
     modelParams = new Float32Array(MODEL_PARAM_FLOATS);
     /**
@@ -2623,7 +2663,10 @@ export class WebGPURenderer {
         const normal = (material?.normal ?? null);
         const orm = (material?.orm ?? null);
         const emissiveMap = (material?.emissive ?? null);
-        const modelMap = (material?.modelMap ?? null);
+        const ownModelMap = (material?.modelMap ?? null);
+        /* A layered material's mask, where it is a map, goes where a model's would: surfaceLayers.ts. */
+        const layers = this.layersOf(material);
+        const modelMap = ownModelMap ?? layerMaskMap(layers);
         this.materialModel = material?.model ?? null;
         const reflectivity = material?.reflectivity;
         const environmentGain = material?.environmentGain;
@@ -2634,7 +2677,7 @@ export class WebGPURenderer {
         this.writeEnvironmentDials();
         /* What the blur spreads this skin by: the last material to name a profile says. */
         const model = material?.model;
-        warnUnpagedLightmap(model, modelMap);
+        warnUnpagedLightmap(model, ownModelMap);
         if (model?.kind === 'skin' && this.skinScatter !== null) {
             this.skinScatter.setProfile(model.profile, skinProfileDistance(model, 0), skinProfileDistance(model, 1), skinProfileDistance(model, 2));
         }
@@ -2682,10 +2725,26 @@ export class WebGPURenderer {
             f[emissive + 1] = asked?.[1] ?? 1;
             f[emissive + 2] = asked?.[2] ?? 1;
             /* The model's numbers and whether its map is bound. See `packModel`. */
-            packModel(material?.model ?? null, modelMap !== null, this.modelParams, material?.physicalSpecular === true);
+            packModel(material?.model ?? null, ownModelMap !== null, this.modelParams, material?.physicalSpecular === true);
             /* The first physical highlight asked for is when the lit pipelines start carrying one. */
             if (material?.physicalSpecular === true)
                 this.enableLit('PHYSICAL_SPECULAR');
+            /* Maps placed by the world: the first material that asks is when lit pipelines carry it. */
+            const projection = layeredProjection(material?.projection, layers);
+            if (projection !== (material?.projection ?? null))
+                this.warnLayersTriplanar();
+            packSurfaceProjection(projection, this.projection);
+            f.set(this.projection, this.materialField('uWorldUv'));
+            /* How much light from behind it lets through, and its colour: transmission.ts. */
+            resolveTransmission(material, this.transmission);
+            f.set(this.transmission, this.materialField('uGlassTint'));
+            if (this.projection[0] > 0)
+                this.enableLit('WORLD_UVS');
+            /* And its layers, the first time a material blends any: layered.ts. */
+            packSurfaceLayers(layers, this.layerFloats);
+            f.set(this.layerFloats, this.materialField('uLayers'));
+            if (layers !== null)
+                this.enableLit('LAYERED');
             f.set(this.modelParams, this.materialField('uModelParams'));
         });
         /*
@@ -2873,6 +2932,14 @@ export class WebGPURenderer {
         this.perFrameFloats[this.materialField('uWriteMode') + 1] = Math.min(1, Math.max(-1, amount));
         this.materials.dirty();
     }
+    /** Whether the draws that follow spend their own opacity on that screen door. See `renderer.ts`. */
+    setDitherOpacity(on) {
+        if (this.surface.lost)
+            return;
+        /* The third lane of `uWriteMode`, beside the fade. */
+        this.perFrameFloats[this.materialField('uWriteMode') + 2] = on ? 1 : 0;
+        this.materials.dirty();
+    }
     /**
      * How strong the microscopic relief on the surfaces drawn next is, and how coarse.
      *
@@ -4154,6 +4221,7 @@ export class WebGPURenderer {
             const sunShadow = env === undefined ? 0 : clamp(options.sunShadow ?? 0, 0, 1);
             ring.writeFloat(fragmentSlot, at('uSunShadow'), sunShadow);
             ring.writeFloats(fragmentSlot, at('uLightViewProj'), env === undefined ? NO_LIGHT_MATRIX : env.lightViewProj);
+            ring.writeFloats(fragmentSlot, at('uMovingLightViewProj'), env === undefined ? NO_LIGHT_MATRIX : this.movingLightFor(env));
             ring.writeFloat(fragmentSlot, at('uShadowMapSize'), this.quality.directionalShadowMapSize);
             /* Sampled only where a pass filled it — see `peelFilled` for why existing is not enough. */
             ring.writeInt(fragmentSlot, at('uPeeledShadowEnabled'), this.peelFilled ? 1 : 0);
@@ -4182,6 +4250,7 @@ export class WebGPURenderer {
             }
             volumeCommand.vertexCount = mesh.vertexBuffers.length;
             volumeCommand.indexBuffer = mesh.indexBuffer;
+            volumeCommand.indexFormat = mesh.indexFormat;
             volumeCommand.indexed = true;
             volumeCommand.count = mesh.indexCount;
         }
@@ -4191,7 +4260,7 @@ export class WebGPURenderer {
             for (let index = 0; index < mesh.vertexBuffers.length; index++) {
                 pass.setVertexBuffer(index, mesh.vertexBuffers[index]);
             }
-            pass.setIndexBuffer(mesh.indexBuffer, 'uint32');
+            pass.setIndexBuffer(mesh.indexBuffer, mesh.indexFormat);
             pass.drawIndexed(mesh.indexCount);
         }
     }
@@ -4907,6 +4976,22 @@ export class WebGPURenderer {
      * the texel-for-texel comparison that settled it.
      */
     correctedLightViewProj = new Float32Array(16);
+    /**
+     * What a receiver projects through to read the sun's static layers: the environment's
+     * `lightViewProj`, taken at `bindMeshPass` as WebGL2 takes it there.
+     *
+     * **It was the last shadow pass's matrix**, which is the environment's wherever both layers are
+     * drawn with one and the moving layer's wherever they are not: the static layer was then read
+     * through the moving layer's tight square, and a distant pillar lost its shadow on WebGPU and kept
+     * it on WebGL2, measured on demo/dev/sunLayers.html?moving=tight.
+     */
+    receiverLightViewProj = new Float32Array(16);
+    /**
+     * The matrix the sun's dynamic shadow pass was last drawn with, uncorrected as the lit stage
+     * projects with, and whether one has been. See `movingLightFor`.
+     */
+    movingLightViewProj = new Float32Array(16);
+    movingLightKnown = false;
     /**
      * The same matrix *uncorrected*, which is what the flat shader must project with.
      *
@@ -5003,6 +5088,53 @@ export class WebGPURenderer {
         this.glassSeen = true;
         this.enableLit('GLASS_SHADOWS');
     }
+    /**
+     * A material's layers where they can be drawn: none asked, or a model's map in the mask's place,
+     * said once, leave one layer.
+     */
+    layersOf(material) {
+        const layers = material?.layers ?? null;
+        if (layers === null || layers.repeats.length === 0)
+            return null;
+        if (layersFitBeside(layers, material?.modelMap))
+            return layers;
+        if (!this.warnedLayersModelMap) {
+            this.warnedLayersModelMap = true;
+            console.warn("WebGPU: a material's layers are drawn as one: its mask is a map, read where a model's map " +
+                "goes, and this material carries a `modelMap` too. A mask in the ORM array (`mask: 'orm'`) " +
+                "or the vertex colour (`mask: 'vertex'`) leaves the slot free.");
+        }
+        return null;
+    }
+    /** Says once that a layered material's triplanar projection is laid on the horizontal plane. */
+    warnLayersTriplanar() {
+        if (this.warnedLayersTriplanar)
+            return;
+        this.warnedLayersTriplanar = true;
+        console.warn("WebGPU: a layered material's triplanar projection is laid on the horizontal plane: every " +
+            "layer's maps on three planes would be three times the reads. See `SurfaceMaterial.layers`.");
+    }
+    /**
+     * What the sun's moving layer is read through: the matrix its shadow pass was last drawn with,
+     * where the lit pipelines carry one (`MOVING_SUN`); the environment's otherwise, which every caller
+     * drawing both layers with one matrix hands it anyway.
+     */
+    movingLightFor(env) {
+        return this.movingLightKnown && this.pipelines.litSwitches.MOVING_SUN
+            ? this.movingLightViewProj
+            : env.lightViewProj;
+    }
+    /** The moving layer's own matrix on, the first time a frame draws that layer with one. */
+    enableMovingSun(env) {
+        if (this.pipelines.litSwitches.MOVING_SUN || !this.movingLightKnown)
+            return;
+        for (let k = 0; k < 16; k++) {
+            if (this.movingLightViewProj[k] !== env.lightViewProj[k]) {
+                this.enableLit('MOVING_SUN');
+                return;
+            }
+        }
+    }
     /** One of the lit stage's switches on, in every cache a lit pipeline can come from. */
     enableLit(feature) {
         if (this.pipelines.litSwitches[feature])
@@ -5056,7 +5188,7 @@ export class WebGPURenderer {
             for (let index = 0; index < geometry.vertexBuffers.length; index++) {
                 pass.setVertexBuffer(index, geometry.vertexBuffers[index]);
             }
-            pass.setIndexBuffer(geometry.indexBuffer, 'uint32');
+            pass.setIndexBuffer(geometry.indexBuffer, geometry.indexFormat);
             pass.drawIndexed(geometry.indexCount);
         },
         /**
@@ -5129,7 +5261,7 @@ export class WebGPURenderer {
                 pass.setVertexBuffer(index, geometry.vertexBuffers[index]);
             }
             pass.setVertexBuffer(index, gpuBatch.buffer);
-            pass.setIndexBuffer(geometry.indexBuffer, 'uint32');
+            pass.setIndexBuffer(geometry.indexBuffer, geometry.indexFormat);
             pass.drawIndexed(geometry.indexCount, count);
         },
         skinnedMesh: (mesh, model, palette, material, cloth) => {
@@ -5172,7 +5304,7 @@ export class WebGPURenderer {
             for (let index = 0; index < geometry.vertexBuffers.length; index++) {
                 pass.setVertexBuffer(index, geometry.vertexBuffers[index]);
             }
-            pass.setIndexBuffer(geometry.indexBuffer, 'uint32');
+            pass.setIndexBuffer(geometry.indexBuffer, geometry.indexFormat);
             pass.drawIndexed(geometry.indexCount);
         },
         /**
@@ -5543,6 +5675,8 @@ export class WebGPURenderer {
             this.overlayPipelines === this.pipelines
                 ? [this.pipelines]
                 : [this.pipelines, this.overlayPipelines];
+        /* A lit draw first needed inside a frame waits for its compile or is left out while it runs. */
+        this.skipCompiling(quality.pipelineCompile === 'skip');
         this.variant = flatVariant({
             directionalShadows: quality.directionalShadows,
             /* No `bakeReflectionProbe` here; see the field. */
@@ -6410,6 +6544,8 @@ export class WebGPURenderer {
         present['layers'] = key.includes(':layers');
         /* Nor is a dynamic mesh's split, which moves positions and normals into buffers of their own. */
         present['dynamic'] = key.includes(':dynamic');
+        /* Nor how each attribute travels, which moves every field after a packed one. */
+        markPackingOfKey(present, key);
         return present;
     }
     /**
@@ -6713,6 +6849,13 @@ export class WebGPURenderer {
             present['dynamic'] = true;
             key += ':dynamic';
         }
+        /*
+         * And how each attribute travels (`vertexPacking.ts`): a field read as sixteen bits rather than
+         * thirty-two, or not interleaved at all, moves every field after it, so the key says so.
+         */
+        const packing = vertexPackingOf(data, dynamic);
+        markPacking(present, packing);
+        key += packingKey(packing);
         const fullKey = `${this.variant}|${key}`;
         /*
          * **For every target this mesh can land on, which is two when the overlay is its own.**
@@ -6920,6 +7063,8 @@ export class WebGPURenderer {
     bindMeshPass(camera, env) {
         if (this.surface.lost)
             return;
+        /* The matrix every receiver projects through: the environment's, as WebGL2's. See the field. */
+        this.receiverLightViewProj.set(env.lightViewProj);
         /* Rectangles past the fixed arm's are the froxel table's, and without it nobody shades them. */
         if (!this.warnedAreaOverflow &&
             !this.quality.clusteredLights &&
@@ -7034,6 +7179,13 @@ export class WebGPURenderer {
         this.surfaceFog = FOG_RECEDE;
         /* Every material switch off — albedo, ORM map, emissive map, two-sided — as WebGL2 resets them. */
         i.fill(0, at('uMaterialFlags'), at('uMaterialFlags') + 4);
+        /* And no projection: maps follow the mesh's coordinates until a material asks otherwise. */
+        f.fill(0, at('uWorldUv'), at('uWorldUv') + 4);
+        /* Nor light through from behind. See `SurfaceMaterial.diffuseTransmission`. */
+        resolveTransmission(null, this.transmission);
+        f.set(this.transmission, at('uGlassTint'));
+        /* Nor layers: one layer until a material asks for more. */
+        f.fill(0, at('uLayers'), at('uLayers') + LAYER_FLOATS);
         f[at('uCutout')] = 0;
         f[at('uCutout') + 1] = 0;
         this.cutoutResolveStaged = 'hard';
@@ -7106,6 +7258,7 @@ export class WebGPURenderer {
         /* No weighting and no dither until a pass or a crossfade asks. See `setDitherFade`. */
         f[at('uWriteMode')] = 0;
         f[at('uWriteMode') + 1] = 0;
+        f[at('uWriteMode') + 2] = 0;
         /* 1, not 0: a multiplier's identity is one. See `setEnvironmentGain`. */
         f[at('uEnvironmentDials') + 2] = 1;
         /* No overlay until a draw sets one. See `setSurfaceOverlay`. */
@@ -7386,6 +7539,11 @@ export class WebGPURenderer {
             f[at('uShadowStrength')] = env.shadowStrength;
             f[at('uShadowMapSize')] = this.quality.directionalShadowMapSize;
             f[at('uShadowDepthSpan')] = env.shadowDepthSpan;
+            /* The moving layer's own matrix and span, where the lit stage reads one: `movingLightFor`. */
+            this.enableMovingSun(env);
+            const moving = this.movingLightFor(env);
+            f.set(moving, at('uMovingLightViewProj'));
+            f[at('uMovingShadowDepthSpan')] = orthographicDepthSpan(moving);
             f[at('uShadowMaxDistance')] = this.quality.directionalShadowMaxDistance;
             f[at('uShadowMaxSlope')] = this.quality.directionalShadowMaxSlope;
             /* Sampled only where a pass filled it — see `peelFilled` for why existing is not enough. */
@@ -7569,7 +7727,7 @@ export class WebGPURenderer {
     /** A view block: the camera, the light's matrix and the frame's wind, into `ring` at `slot`. */
     writeView(ring, slot, viewProj) {
         ring.writeFloats(slot, FLAT_VIEW_FIELDS.uViewProj.offset, viewProj);
-        ring.writeFloats(slot, FLAT_VIEW_FIELDS.uLightViewProj.offset, this.lightViewProj);
+        ring.writeFloats(slot, FLAT_VIEW_FIELDS.uLightViewProj.offset, this.receiverLightViewProj);
         /* The scene's clock, which a bone animation's instances read their moment from. */
         ring.writeFloat(slot, FLAT_VIEW_FIELDS.uSceneTime.offset, this.animationTime);
         const d = this.frameWind;
@@ -7750,6 +7908,153 @@ export class WebGPURenderer {
            `TranslucentMeshOptions.tint` for why, and for the fade it was added for. */
         this.submitMesh(mesh, model, options.tint ?? null, Math.min(opacity, 1), true, options);
     }
+    /**
+     * Compile off the main thread every pipeline a draw of `mesh` in `material` takes. **The other
+     * backend's `prepareMesh` carries the contract**; here a draw's key is `meshShape`'s, so a prepared
+     * key is exactly the one the draw asks for, and the compiles are started as a skipping draw starts
+     * them (`PipelineCache.lit`) whatever `pipelineCompile` says, into the frame's own caches.
+     */
+    prepareMesh(mesh, material, options = {}) {
+        if (this.surface.lost)
+            return;
+        this.preparing(material, (into, blend) => {
+            const skinned = mesh.isSkinned;
+            const eight = skinned && mesh.isSkinnedEight;
+            for (const morphed of mesh.morph === null ? NOT_MORPHED : MORPHED_OR_NOT) {
+                this.meshShape(mesh, blend, PREPARED_DRAW, skinned, morphed, eight, false);
+                this.meshPipeline(blend, false, skinned, morphed, eight, false, into);
+            }
+        }, options);
+    }
+    /** `prepareMesh` for an instanced batch. See the other backend's `prepareInstanced`. */
+    prepareInstanced(batch, material, options = {}) {
+        if (this.surface.lost)
+            return;
+        this.preparing(material, (into, blend) => {
+            const coverage = !blend && this.cutoutResolveStaged === 'coverage';
+            this.instancedPipeline(batch.mesh, batch.animation !== null, blend, false, PREPARED_DRAW, true, 0, coverage, into);
+        }, options);
+    }
+    /**
+     * `material` set, every cache a draw in it may build into passed to `start` with whether that draw
+     * blends, compiles started rather than built (`PipelineCache.lit`), and then no material set and
+     * each cache back to what `pipelineCompile` says.
+     */
+    preparing(material, start, options) {
+        this.setMaterial(material);
+        this.skipCompiling(true);
+        try {
+            start(this.pipelines, false);
+            if (options.translucent === true) {
+                start(this.pipelines, true);
+                /* A blended draw in a reconstructing frame lands in the late pass, whose cache is its own. */
+                if (this.latePipelines !== this.pipelines)
+                    start(this.latePipelines, true);
+            }
+        }
+        finally {
+            this.skipCompiling(this.quality.pipelineCompile === 'skip');
+            this.setMaterial(null);
+        }
+    }
+    /** What `meshShape` worked out for the mesh draw at hand. Reused, so a draw allocates no record. */
+    drawShape = {
+        base: '',
+        key: '',
+        depthWrite: true,
+        layer: 0,
+        adds: false,
+        coverage: false,
+        splits: false,
+        modelKind: null,
+    };
+    /**
+     * The key a mesh draw's pipeline is cached under, and the pipeline state that key encodes, under
+     * the current material and these options, into `drawShape`. **The one statement of it**:
+     * `submitMesh` draws by it and `prepareMesh` compiles by it, so the two cannot disagree about a key.
+     */
+    meshShape(mesh, blend, options, skinned, morphed, eight, clothed) {
+        const modelKind = this.materialModel?.kind ?? null;
+        const base = mesh.key ?? 'flat:s0:u0';
+        const keyed = `${base}${morphed ? '|morph' : ''}${skinned ? (eight ? '|skin8' : '|skin') : ''}` +
+            `${clothed ? '|cloth' : ''}`;
+        /*
+         * Depth writing and the overlay layer are pipeline state on this backend, so they belong in
+         * the key: two draws of one mesh differing only in these would otherwise share a cached
+         * pipeline and the second would silently take the first one's depth behaviour.
+         *
+         * **Both suffixes are empty for the defaults**, which is what keeps the keys `createMesh`
+         * warms — `fullKey` and `${'`'}${'$'}{fullKey}|blend${'`'}` — the ones an ordinary draw still asks for. A
+         * caller that opts in pays one compile on its first draw, the same bargain the overlay
+         * pipelines above already make.
+         */
+        const depthWrite = options.depthWrite ?? true;
+        const layer = Math.min(Math.max(Math.round(options.depthLayer ?? 0), 0), MAX_DEPTH_LAYER);
+        /* Added rather than blended over: its own blend state, so its own pipeline. */
+        const adds = blend && options.additive === true;
+        const coverage = !blend && this.cutoutResolveStaged === 'coverage';
+        /* Skin under the screen-space blur draws its two halves; see `keepSkinDiffuse`. */
+        const splits = modelKind === 'skin' && !blend && this.skinSplits();
+        const key = `${keyed}${blend ? (adds ? '|add' : '|blend') : ''}` +
+            `${depthWrite ? '' : '|nodepth'}${layer > 0 ? `|dl${layer}` : ''}` +
+            /* The two order-independent buffers are two formats and two blend states, so a draw into
+               one must never share a cached pipeline with the same mesh drawn into the other. */
+            `${this.oitMode === 'none' ? '' : `|oit${this.oitMode}`}` +
+            /* Culling is pipeline state here: a two-sided surface culls nothing. */
+            `${this.materialDoubleSided ? '|2s' : ''}` +
+            /* And so is alpha-to-coverage, for a dithered cutout in a multisampled frame. */
+            `${coverage ? '|a2c' : ''}` +
+            /* And the material's shading model, which is the fragment stage's own switch. */
+            `${modelKind === null ? '' : `|m:${modelKind}`}` +
+            /* And which half of a skin it draws, under the screen-space blur. */
+            `${splits ? '|ss' : ''}`;
+        const shape = this.drawShape;
+        shape.base = base;
+        shape.key = key;
+        shape.depthWrite = depthWrite;
+        shape.layer = layer;
+        shape.adds = adds;
+        shape.coverage = coverage;
+        shape.splits = splits;
+        shape.modelKind = modelKind;
+        return shape;
+    }
+    /**
+     * The pipeline `drawShape` names: the one built, one built here, or none where draws skip a
+     * compile and this one has not landed (`PipelineCache.lit`) — and none for a split skin until all
+     * of its halves have.
+     */
+    meshPipeline(blend, lands, skinned, morphed, eight, clothed, 
+    /** Which cache to build into: the one the draw's target reads, unless a preparation says. */
+    into = null) {
+        const { base, key, depthWrite, layer, adds, coverage, splits, modelKind } = this.drawShape;
+        /*
+         * **Asynchronous by default, synchronous if it has to be, and never absent.**
+         *
+         * `createMesh` compiles off the main thread, so a draw can legitimately arrive before the
+         * driver has finished — a consumer that awaits `ready()` never sees this, and one that
+         * draws immediately gets the old behaviour rather than an exception. Correctness cannot be
+         * allowed to depend on which of those happened, so the miss builds the pipeline here and
+         * pays the compile it was trying to avoid. That is a slow frame; the alternative is a
+         * thrown error in the middle of one.
+         */
+        const pipelines = into ?? (blend ? this.blendedPipelines(lands) : this.targetPipelines());
+        let pipeline = pipelines.peek(key) ?? null;
+        if (pipeline === null) {
+            const present = this.meshPresent.get(base);
+            if (present === undefined) {
+                throw new Error(`WebGPU: no pipeline for ${key}; createMesh builds it`);
+            }
+            pipeline = flatPipeline(pipelines, this.surface.device, this.flatLayoutFor(skinned, morphed), this.variant, key, present, adds ? 'additive' : blend, skinned, morphed, depthWrite, layer, false, this.oitMode, this.materialDoubleSided, coverage, eight, clothed, modelKind, splits ? 'scene' : 'whole');
+        }
+        /* A split skin draws its three halves or none of them. */
+        if (pipeline !== null &&
+            splits &&
+            !this.skinHalvesReady(key, base, skinned, morphed, layer, eight, clothed)) {
+            pipeline = null;
+        }
+        return pipeline;
+    }
     /**
      * @param blend Which of the two entry points above this came through, and **not** something to
      * infer from `opacity`.
@@ -7869,7 +8174,6 @@ export class WebGPURenderer {
         const modelKind = this.materialModel?.kind ?? null;
         if (modelKind === 'eye')
             this.writeEyeAxis(model, this.skinPaletteSlot >= 0 && mesh.isSkinned);
-        const base = mesh.key ?? 'flat:s0:u0';
         /*
          * A rigged mesh takes the skinned vertex variant, an unrigged one the plain variant, and the
          * key carries the flag so the two never share a cached pipeline. A rigged mesh whose caller
@@ -7884,38 +8188,6 @@ export class WebGPURenderer {
         /* A cloth set and a skinned draw: the pipeline built with CLOTH_BOUND on, warmed when the
            binding was made. See `createClothBinding`. */
         const clothed = skinned && this.cloth !== null;
-        const keyed = `${base}${morphed ? '|morph' : ''}${skinned ? (eight ? '|skin8' : '|skin') : ''}` +
-            `${clothed ? '|cloth' : ''}`;
-        /*
-         * Depth writing and the overlay layer are pipeline state on this backend, so they belong in
-         * the key: two draws of one mesh differing only in these would otherwise share a cached
-         * pipeline and the second would silently take the first one's depth behaviour.
-         *
-         * **Both suffixes are empty for the defaults**, which is what keeps the keys `createMesh`
-         * warms — `fullKey` and `${'`'}${'$'}{fullKey}|blend${'`'}` — the ones an ordinary draw still asks for. A
-         * caller that opts in pays one compile on its first draw, the same bargain the overlay
-         * pipelines above already make.
-         */
-        const depthWrite = options.depthWrite ?? true;
-        const layer = Math.min(Math.max(Math.round(options.depthLayer ?? 0), 0), MAX_DEPTH_LAYER);
-        /* Added rather than blended over: its own blend state, so its own pipeline. */
-        const adds = blend && options.additive === true;
-        const coverage = !blend && this.cutoutResolveStaged === 'coverage';
-        /* Skin under the screen-space blur draws its two halves; see `keepSkinDiffuse`. */
-        const splits = modelKind === 'skin' && !blend && this.skinSplits();
-        const key = `${keyed}${blend ? (adds ? '|add' : '|blend') : ''}` +
-            `${depthWrite ? '' : '|nodepth'}${layer > 0 ? `|dl${layer}` : ''}` +
-            /* The two order-independent buffers are two formats and two blend states, so a draw into
-               one must never share a cached pipeline with the same mesh drawn into the other. */
-            `${this.oitMode === 'none' ? '' : `|oit${this.oitMode}`}` +
-            /* Culling is pipeline state here: a two-sided surface culls nothing. */
-            `${this.materialDoubleSided ? '|2s' : ''}` +
-            /* And so is alpha-to-coverage, for a dithered cutout in a multisampled frame. */
-            `${coverage ? '|a2c' : ''}` +
-            /* And the material's shading model, which is the fragment stage's own switch. */
-            `${modelKind === null ? '' : `|m:${modelKind}`}` +
-            /* And which half of a skin it draws, under the screen-space blur. */
-            `${splits ? '|ss' : ''}`;
         /*
          * The morph uniforms, written only for a morphed draw and read from the *morphed* variant's
          * field table. `FLAT_VERT_FIELDS` is the plain variant's and does not name them at all — every
@@ -7928,25 +8200,9 @@ export class WebGPURenderer {
             this.perDraw.writeInt(slot, fields.uMorphTargetCount.offset, mesh.morph.targetCount);
             this.perDraw.writeInt(slot, fields.uMorphTextureWidth.offset, mesh.morph.width);
         }
-        /*
-         * **Asynchronous by default, synchronous if it has to be, and never absent.**
-         *
-         * `createMesh` compiles off the main thread, so a draw can legitimately arrive before the
-         * driver has finished — a consumer that awaits `ready()` never sees this, and one that
-         * draws immediately gets the old behaviour rather than an exception. Correctness cannot be
-         * allowed to depend on which of those happened, so the miss builds the pipeline here and
-         * pays the compile it was trying to avoid. That is a slow frame; the alternative is a
-         * thrown error in the middle of one.
-         */
-        const pipelines = blend ? this.blendedPipelines(lands) : this.targetPipelines();
-        let pipeline = pipelines.peek(key);
-        if (pipeline === undefined) {
-            const present = this.meshPresent.get(base);
-            if (present === undefined) {
-                throw new Error(`WebGPU: no pipeline for ${key}; createMesh builds it`);
-            }
-            pipeline = flatPipeline(pipelines, this.surface.device, this.flatLayoutFor(skinned, morphed), this.variant, key, present, adds ? 'additive' : blend, skinned, morphed, depthWrite, layer, false, this.oitMode, this.materialDoubleSided, coverage, eight, clothed, modelKind, splits ? 'scene' : 'whole');
-        }
+        /* Its pipeline, by the key a prepared draw compiled too: see `meshShape`. */
+        const { base, key, layer, depthWrite, splits } = this.meshShape(mesh, blend, options, skinned, morphed, eight, clothed);
+        let pipeline = this.meshPipeline(blend, lands, skinned, morphed, eight, clothed);
         /*
          * Guards the draw call only, not the restore below.
          *
@@ -7963,8 +8219,9 @@ export class WebGPURenderer {
          * close to the 256-slot budget before the gateway, the play controls, the waveform, the
          * label handles and the sparkles are even counted.
          */
-        const material = this.materialSlotForDraw();
-        if (material !== null) {
+        /* A draw whose pipeline is still compiling is left out, its state restored all the same. */
+        const material = pipeline === null ? null : this.materialSlotForDraw();
+        if (pipeline !== null && material !== null) {
             /*
              * Record rather than issue. Every per-draw value is already in `slot` and `material` —
              * the uniform rings are the state arena this design would otherwise have had to build —
@@ -7986,6 +8243,7 @@ export class WebGPURenderer {
                 }
                 command.vertexCount = mesh.vertexBuffers.length;
                 command.indexBuffer = mesh.indexBuffer;
+                command.indexFormat = mesh.indexFormat;
                 command.indexed = true;
                 command.count = mesh.indexCount;
             }
@@ -8003,7 +8261,7 @@ export class WebGPURenderer {
                 for (let index = 0; index < mesh.vertexBuffers.length; index++) {
                     pass.setVertexBuffer(index, mesh.vertexBuffers[index]);
                 }
-                pass.setIndexBuffer(mesh.indexBuffer, 'uint32');
+                pass.setIndexBuffer(mesh.indexBuffer, mesh.indexFormat);
                 pass.drawIndexed(mesh.indexCount);
             }
             if (splits) {
@@ -8250,6 +8508,8 @@ export class WebGPURenderer {
         const seeAt = this.materialField('uSeeThrough');
         this.perFrameFloats[seeAt] = 0;
         this.perFrameFloats[seeAt + 2] = 0;
+        /* The material's light through, over the pane's tint: transmission.ts. */
+        this.perFrameFloats.set(this.transmission, this.materialField('uGlassTint'));
     }
     /**
      * One draw, one material slot, one uniform slot, however many instances.
@@ -8263,6 +8523,41 @@ export class WebGPURenderer {
      * **What it gives up** against `drawMesh` is skinning and morphing, refused where the variant
      * is built, and a per-instance opacity: `opacity` here dims the whole batch.
      */
+    /**
+     * An instanced draw's pipeline under the current material and these options: the one built, one
+     * built here, or none while it compiles (`PipelineCache.lit`), its key, base and model left in
+     * `drawShape`. **The one statement of an instanced key**: `submitInstanced` draws by it and
+     * `prepareInstanced` compiles by it.
+     */
+    instancedPipeline(mesh, animated, blend, lands, options, depthWrite, layer, coverage, 
+    /** Which cache to build into: the one the draw's target reads, unless a preparation says. */
+    into = null) {
+        /* A batch shades by its material's model too; an eye's axis is a placement's, not a batch's. */
+        const modelKind = this.materialModel?.kind ?? null;
+        const base = mesh.key ?? 'flat:s0:u0';
+        /* `|inst` in the key, for the reason every other suffix is there: an instanced pipeline binds
+           a third vertex buffer and a different vertex module, and sharing a cache entry with the
+           plain one would hand a draw the wrong layout. */
+        const adds = blend && options.additive === true;
+        const key = `${base}|inst${!animated ? '' : '|anim'}${blend ? (adds ? '|add' : '|blend') : ''}` +
+            `${depthWrite ? '' : '|nodepth'}${layer > 0 ? `|dl${layer}` : ''}` +
+            `${this.materialDoubleSided ? '|2s' : ''}${coverage ? '|a2c' : ''}` +
+            `${modelKind === null ? '' : `|m:${modelKind}`}`;
+        const shape = this.drawShape;
+        shape.base = base;
+        shape.key = key;
+        shape.modelKind = modelKind;
+        const pipelines = into ?? (blend ? this.blendedPipelines(lands) : this.targetPipelines());
+        let pipeline = pipelines.peek(key) ?? null;
+        if (pipeline === null) {
+            const present = this.meshPresent.get(base);
+            if (present === undefined) {
+                throw new Error(`WebGPU: no mesh attributes recorded for ${base}; createMesh records them`);
+            }
+            pipeline = flatPipeline(pipelines, this.surface.device, !animated ? this.flatLayoutFor(false, false) : this.animatedBindGroupLayout, this.variant, key, present, adds ? 'additive' : blend, false, false, depthWrite, layer, true, 'none', this.materialDoubleSided, coverage, false, false, modelKind, 'whole', false, animated);
+        }
+        return pipeline;
+    }
     /**
      * The next of a batch's cull slots this frame, with its cull queued against the current view; null
      * when the batch has drawn from `MAX_CULL_SLOTS` views already or the frame's job ring is full,
@@ -8366,28 +8661,12 @@ export class WebGPURenderer {
         const own = ownsMaterial({ opacity, lit, fog, toneMapped, refracting }, this.surfaceFog) || ditheredBlend;
         if (own)
             this.materials.dirty();
-        /* A batch shades by its material's model too; an eye's axis is a placement's, not a batch's. */
-        const modelKind = this.materialModel?.kind ?? null;
-        const base = mesh.key ?? 'flat:s0:u0';
-        /* `|inst` in the key, for the reason every other suffix is there: an instanced pipeline binds
-           a third vertex buffer and a different vertex module, and sharing a cache entry with the
-           plain one would hand a draw the wrong layout. */
-        const adds = blend && options.additive === true;
-        const key = `${base}|inst${animation === null ? '' : '|anim'}${blend ? (adds ? '|add' : '|blend') : ''}` +
-            `${depthWrite ? '' : '|nodepth'}${layer > 0 ? `|dl${layer}` : ''}` +
-            `${this.materialDoubleSided ? '|2s' : ''}${coverage ? '|a2c' : ''}` +
-            `${modelKind === null ? '' : `|m:${modelKind}`}`;
-        const pipelines = blend ? this.blendedPipelines(lands) : this.targetPipelines();
-        let pipeline = pipelines.peek(key);
-        if (pipeline === undefined) {
-            const present = this.meshPresent.get(base);
-            if (present === undefined) {
-                throw new Error(`WebGPU: no mesh attributes recorded for ${base}; createMesh records them`);
-            }
-            pipeline = flatPipeline(pipelines, this.surface.device, animation === null ? this.flatLayoutFor(false, false) : this.animatedBindGroupLayout, this.variant, key, present, adds ? 'additive' : blend, false, false, depthWrite, layer, true, 'none', this.materialDoubleSided, coverage, false, false, modelKind, 'whole', false, animation !== null);
-        }
-        const material = this.materialSlotForDraw();
-        if (material !== null) {
+        /* Its pipeline, by the key a prepared batch compiled too: see `instancedPipeline`. */
+        const pipeline = this.instancedPipeline(mesh, animation !== null, blend, lands, options, depthWrite, layer, coverage);
+        const { base, key, modelKind } = this.drawShape;
+        /* A batch whose pipeline is still compiling is left out, as a mesh is. */
+        const material = pipeline === null ? null : this.materialSlotForDraw();
+        if (pipeline !== null && material !== null) {
             const command = blend
                 ? this.recordBlended(0, lands)
                 : this.recordDraw(0, this.currentTarget());
@@ -8409,6 +8688,7 @@ export class WebGPURenderer {
                 command.vertexBuffers[index] = instanceBuffer;
                 command.vertexCount = mesh.vertexBuffers.length + 1;
                 command.indexBuffer = mesh.indexBuffer;
+                command.indexFormat = mesh.indexFormat;
                 command.indexed = true;
                 command.count = mesh.indexCount;
                 command.instances = count;
@@ -8427,7 +8707,7 @@ export class WebGPURenderer {
                     pass.setVertexBuffer(index, mesh.vertexBuffers[index]);
                 }
                 pass.setVertexBuffer(index, instanceBuffer);
-                pass.setIndexBuffer(mesh.indexBuffer, 'uint32');
+                pass.setIndexBuffer(mesh.indexBuffer, mesh.indexFormat);
                 if (cut === null)
                     pass.drawIndexed(mesh.indexCount, count);
                 else
@@ -8628,6 +8908,11 @@ export class WebGPURenderer {
         if (view === null)
             return false;
         this.lightViewProj.set(lightViewProj);
+        /* The moving layer is read through the matrix it is drawn with: see `movingLightFor`. */
+        if (dynamic) {
+            this.movingLightViewProj.set(lightViewProj);
+            this.movingLightKnown = true;
+        }
         this.reopenViews();
         mat4.multiply(this.correctedLightViewProj, SHADOW_CLIP_CORRECTION, lightViewProj);
         this.shadowLayerIsPeel = peel;
@@ -8912,11 +9197,14 @@ export class WebGPURenderer {
         this.lateViewBlock.slot = list.viewOffset(0);
         this.materials.dirty();
         this.staticRecording = recording;
+        /* A recorded list keeps what it recorded, so every draw of it waits for its pipeline. */
+        this.skipCompiling(false);
         try {
             this.sceneCasterMaterial = undefined;
             replayStaticDraws(list, this.sceneCasterSink);
         }
         finally {
+            this.skipCompiling(this.quality.pipelineCompile === 'skip');
             this.staticRecording = null;
             this.perDraw = perDraw;
             this.passRing = passRing;
@@ -9186,7 +9474,7 @@ export class WebGPURenderer {
             for (let index = 0; index < geometry.vertexBuffers.length; index++) {
                 pass.setVertexBuffer(index, geometry.vertexBuffers[index]);
             }
-            pass.setIndexBuffer(geometry.indexBuffer, 'uint32');
+            pass.setIndexBuffer(geometry.indexBuffer, geometry.indexFormat);
             pass.drawIndexed(geometry.indexCount);
         },
         instanced: (batch, data, material, glass) => {
@@ -9220,7 +9508,7 @@ export class WebGPURenderer {
                 pass.setVertexBuffer(index, geometry.vertexBuffers[index]);
             }
             pass.setVertexBuffer(index, gpuBatch.buffer);
-            pass.setIndexBuffer(geometry.indexBuffer, 'uint32');
+            pass.setIndexBuffer(geometry.indexBuffer, geometry.indexFormat);
             pass.drawIndexed(geometry.indexCount, count);
         },
         skinnedMesh: (mesh, model, palette, _material, glass) => {
@@ -9248,7 +9536,7 @@ export class WebGPURenderer {
             for (let index = 0; index < geometry.vertexBuffers.length; index++) {
                 pass.setVertexBuffer(index, geometry.vertexBuffers[index]);
             }
-            pass.setIndexBuffer(geometry.indexBuffer, 'uint32');
+            pass.setIndexBuffer(geometry.indexBuffer, geometry.indexFormat);
             pass.drawIndexed(geometry.indexCount);
         },
     };
@@ -11377,6 +11665,7 @@ export class WebGPURenderer {
         /* Uncorrected, for the reason the shaft's own copy of this line carries: the shader does its
            own `* 0.5 + 0.5`, and correcting the matrix as well doubles it. */
         f.set(env?.lightViewProj ?? this.mediumIdentity, at('uLightViewProj'));
+        f.set((env === null ? this.mediumIdentity : this.movingLightFor(env)), at('uMovingLightViewProj'));
         ints[at('uPeeledShadowEnabled')] = this.peelView === null || !this.peelFilled ? 0 : 1;
         device.queue.writeBuffer(this.mediumUniforms, 0, this.mediumStaging);
         const g = this.mediumUpsampleFloats;
@@ -11432,6 +11721,7 @@ export class WebGPURenderer {
         const f = this.aoFloats;
         const at = (name) => this.postField(AO_FRAG_FIELDS, name);
         f[at('uRadius')] = this.quality.ambientOcclusionRadius;
+        f.set(this.aoFade, at('uFade'));
         f.set(this.aoProjScale, at('uProjScale'));
         f.set(this.aoInvProjection, at('uInvProjection'));
         device.queue.writeBuffer(this.aoUniforms, 0, this.aoStaging);
@@ -11778,6 +12068,9 @@ export class WebGPURenderer {
         const key = `${frameKey}|rs`;
         const pipeline = this.pipelines.peek(key) ??
             flatPipeline(this.pipelines, this.surface.device, animation === null ? this.flatLayoutFor(skinned, morphed) : this.animatedBindGroupLayout, this.variant, key, present, false, skinned, morphed, true, layer, instanceBuffer !== null, 'none', this.materialDoubleSided, false, eight, clothed, modelKind, 'whole', true, animation !== null);
+        /* Still compiling where draws skip: the probe stands in for this surface until it lands. */
+        if (pipeline === null)
+            return;
         /* A static list's surface halves go into its own pool, beside its draws. */
         const command = this.staticRecording === null ? surface.take() : takeRecorded(this.staticRecording.surface);
         command.pipeline = pipeline;
@@ -11798,6 +12091,7 @@ export class WebGPURenderer {
             command.vertexBuffers[index++] = instanceBuffer;
         command.vertexCount = index;
         command.indexBuffer = mesh.indexBuffer;
+        command.indexFormat = mesh.indexFormat;
         command.indexed = true;
         command.count = mesh.indexCount;
         command.instances = instances;
@@ -11809,6 +12103,30 @@ export class WebGPURenderer {
      * light alone and its colour alone into the blur's targets and test for the depth its frame half
      * wrote.
      */
+    /**
+     * Whether a split skin draw's two kept halves have pipelines, starting the compile of either that
+     * has not: a skin drawn without them would lose its diffuse light for the frames they take, so a
+     * split skin draws all three halves or none. See `PipelineCache.lit`.
+     */
+    skinHalvesReady(frameKey, base, skinned, morphed, layer, eight, clothed) {
+        let ready = true;
+        for (const half of SKIN_KEPT_HALVES) {
+            const pipeline = this.skinHalfPipeline(half, frameKey, base, skinned, morphed, layer, eight, clothed);
+            if (pipeline === null)
+                ready = false;
+        }
+        return ready;
+    }
+    /** One kept half's pipeline, or none where it is still compiling: see `PipelineCache.lit`. */
+    skinHalfPipeline(half, frameKey, base, skinned, morphed, layer, eight, clothed) {
+        const pipelines = this.skinPipelines;
+        const present = this.meshPresent.get(base);
+        if (pipelines === null || present === undefined)
+            return null;
+        const key = `${frameKey}|${half === 'diffuse' ? 'sd' : 'sa'}`;
+        return (pipelines.peek(key) ??
+            flatPipeline(pipelines, this.surface.device, this.flatLayoutFor(skinned, morphed), this.variant, key, present, false, skinned, morphed, true, layer, false, 'none', this.materialDoubleSided, false, eight, clothed, 'skin', half));
+    }
     keepSkinDiffuse(mesh, frameKey, base, skinned, morphed, deltas, layer, eight, clothed, slot, material) {
         /* A skin's halves are not bundled: a static list holding one replays draw by draw. */
         if (this.staticRecording !== null) {
@@ -11823,9 +12141,10 @@ export class WebGPURenderer {
         const bindGroup = this.flatBindGroupFor(skinned, morphed, deltas);
         /* The light alone, which the blur spreads, then the colour alone, which it is multiplied by. */
         for (const half of SKIN_KEPT_HALVES) {
-            const key = `${frameKey}|${half === 'diffuse' ? 'sd' : 'sa'}`;
-            const pipeline = pipelines.peek(key) ??
-                flatPipeline(pipelines, this.surface.device, this.flatLayoutFor(skinned, morphed), this.variant, key, present, false, skinned, morphed, true, layer, false, 'none', this.materialDoubleSided, false, eight, clothed, 'skin', half);
+            const pipeline = this.skinHalfPipeline(half, frameKey, base, skinned, morphed, layer, eight, clothed);
+            /* Both landed before the draw was let through: see `skinHalvesReady`. */
+            if (pipeline === null)
+                return;
             const command = half === 'diffuse' ? skin.take() : skin.takeAlbedo();
             command.pipeline = pipeline;
             command.bindGroup = bindGroup;
@@ -11839,6 +12158,7 @@ export class WebGPURenderer {
             }
             command.vertexCount = mesh.vertexBuffers.length;
             command.indexBuffer = mesh.indexBuffer;
+            command.indexFormat = mesh.indexFormat;
             command.indexed = true;
             command.count = mesh.indexCount;
             command.instances = 1;
@@ -12277,6 +12597,7 @@ export class WebGPURenderer {
         command.offsetCount = 0;
         command.vertexCount = 0;
         command.indexBuffer = null;
+        command.indexFormat = 'uint32';
         command.indexed = false;
         command.instances = 1;
         command.indirect = null;
@@ -12344,7 +12665,7 @@ export class WebGPURenderer {
                 pass.setVertexBuffer(i, buffer);
         }
         if (command.indexed && command.indexBuffer !== null) {
-            pass.setIndexBuffer(command.indexBuffer, 'uint32');
+            pass.setIndexBuffer(command.indexBuffer, command.indexFormat);
             if (command.indirect !== null)
                 pass.drawIndexedIndirect(command.indirect, 0);
             else
@@ -13992,6 +14313,13 @@ export class WebGPURenderer {
         this.exposurePass = new ExposurePass(this.surface.device, this.pipelines, this.postSampler);
         this.rebuildRushBindGroup();
     }
+    /**
+     * Where ambient occlusion fades out with distance. **The other backend's
+     * `setAmbientOcclusionFade` carries the reasoning**; this is the same setter over the same state.
+     */
+    setAmbientOcclusionFade(distance, radius) {
+        resolveOcclusionFade(distance, radius, this.aoFade);
+    }
     /**
      * Where this frame's lens is focused, how deep the sharp zone is, and how much of the ceiling
      * to take. **The other backend's `setDepthOfField` carries the reasoning**, whole: the