@driftengine/core 4.10.0 → 4.11.0

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

@@ -133,6 +133,10 @@ export declare class WebGPURenderer implements RendererApi {
      * flight at the time, so a consumer that builds more meshes later can wait again.
      */
     ready(): Promise<void>;
+    /** Every distinct cache a lit draw reaches: the frame's, the canvas's, the late pass's, skin's. */
+    private pipelineCaches;
+    /** Whether a lit draw whose pipeline is not built is left out while it compiles. */
+    private skipCompiling;
     private presentedFrameCount;
     /**
      * The joint palettes this frame has set, one slot each. The WebGL2 field of this name is a
@@ -1179,6 +1183,11 @@ export declare class WebGPURenderer implements RendererApi {
     private modelMap;
     /** The material's shading model, which picks the lit pipeline: null the standard. */
     private materialModel;
+    /** `uWorldUv`, the material's projection packed by `packSurfaceProjection`. */
+    private readonly projection;
+    /** `uLayers`, the material's layers packed by `packSurfaceLayers`. */
+    private readonly layerFloats;
+    private warnedLayersModelMap;
     /** Its numbers, `uModelParams`, packed by `packModel`. */
     private readonly modelParams;
     /**
@@ -1398,6 +1407,8 @@ export declare class WebGPURenderer implements RendererApi {
      * this one is called per crossfading region per frame and a closure per call is an allocation.
      */
     setDitherFade(amount: number): void;
+    /** Whether the draws that follow spend their own opacity on that screen door. See `renderer.ts`. */
+    setDitherOpacity(on: boolean): void;
     /**
      * How strong the microscopic relief on the surfaces drawn next is, and how coarse.
      *
@@ -2013,6 +2024,22 @@ export declare class WebGPURenderer implements RendererApi {
      * the texel-for-texel comparison that settled it.
      */
     private readonly correctedLightViewProj;
+    /**
+     * 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.
+     */
+    private readonly receiverLightViewProj;
+    /**
+     * 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`.
+     */
+    private readonly movingLightViewProj;
+    private movingLightKnown;
     /**
      * The same matrix *uncorrected*, which is what the flat shader must project with.
      *
@@ -2061,6 +2088,19 @@ export declare class WebGPURenderer implements RendererApi {
      * the lit pass on every surface whether they find anything or not.
      */
     private noteGlassCaster;
+    /**
+     * 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.
+     */
+    private layersOf;
+    /**
+     * 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.
+     */
+    private movingLightFor;
+    /** The moving layer's own matrix on, the first time a frame draws that layer with one. */
+    private enableMovingSun;
     /** One of the lit stage's switches on, in every cache a lit pipeline can come from. */
     private enableLit;
     /** One resolution every glass caster is read through, so recording one allocates nothing. */
@@ -3202,6 +3242,14 @@ export declare class WebGPURenderer implements RendererApi {
      * 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`.
+     */
+    private skinHalvesReady;
+    /** One kept half's pipeline, or none where it is still compiling: see `PipelineCache.lit`. */
+    private skinHalfPipeline;
     private keepSkinDiffuse;
     /**
      * Spread the frame's skin and add it back: once, at the first blended draw or before the frame's

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,9 @@ 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 { orthographicDepthSpan } from '../../lightMatrix.js';
+import { LAYER_FLOATS, packSurfaceLayers } from '../../surfaceLayers.js';
 import { frameReflectionsRefused, resolveFrameReflections, } from '../../frameReflections.js';
 import { REFLECTION_SURFACE_FORMAT, ReflectionSurfacePass } from './reflectionSurfacePass.js';
 import { validateClothBinding } from '../../clothBindingData.js';
@@ -857,7 +862,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;
     /**
@@ -2177,6 +2196,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 +2209,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 +2243,11 @@ 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);
+    warnedLayersModelMap = false;
     /** Its numbers, `uModelParams`, packed by `packModel`. */
     modelParams = new Float32Array(MODEL_PARAM_FLOATS);
     /**
@@ -2623,7 +2648,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 goes where a model's map would: see `SurfaceMaterial.layers`. */
+        const layers = this.layersOf(material);
+        const modelMap = ownModelMap ?? (layers?.mask ?? null);
         this.materialModel = material?.model ?? null;
         const reflectivity = material?.reflectivity;
         const environmentGain = material?.environmentGain;
@@ -2634,7 +2662,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 +2710,23 @@ 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. */
+            packSurfaceProjection(material?.projection, this.projection);
+            f.set(this.projection, this.materialField('uWorldUv'));
+            /* How much light from behind it lets through, in the glass tint's spare lane. */
+            f[this.materialField('uGlassTint') + 3] =
+                Math.min(Math.max(material?.diffuseTransmission ?? 0, 0), 1) || 0;
+            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 +2914,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 +4203,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 +4232,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 +4242,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 +4958,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 +5070,44 @@ 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 ((material?.modelMap ?? null) === null)
+            return layers;
+        if (!this.warnedLayersModelMap) {
+            this.warnedLayersModelMap = true;
+            console.warn("WebGPU: a material's layers are drawn as one: its mask is read where a model's map goes, " +
+                'and this material carries a `modelMap` too.');
+        }
+        return null;
+    }
+    /**
+     * 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 +5161,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 +5234,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 +5277,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 +5648,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 +6517,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 +6822,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 +7036,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 +7152,12 @@ 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`. */
+        f[at('uGlassTint') + 3] = 0;
+        /* 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 +7230,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 +7511,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 +7699,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;
@@ -7939,14 +8069,20 @@ export class WebGPURenderer {
          * thrown error in the middle of one.
          */
         const pipelines = blend ? this.blendedPipelines(lands) : this.targetPipelines();
-        let pipeline = pipelines.peek(key);
-        if (pipeline === undefined) {
+        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;
+        }
         /*
          * Guards the draw call only, not the restore below.
          *
@@ -7963,8 +8099,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 +8123,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 +8141,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) {
@@ -8378,16 +8516,17 @@ export class WebGPURenderer {
             `${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) {
+        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, 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) {
+        /* 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 +8548,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 +8567,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 +8768,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 +9057,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 +9334,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 +9368,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 +9396,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 +11525,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;
@@ -11778,6 +11927,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 +11950,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 +11962,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 +12000,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 +12017,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 +12456,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 +12524,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