reze-engine 0.62.1 → 0.64.0

package/dist/engine.js

@@ -22,7 +22,12 @@ import { ID_DEBUG_SHADER_WGSL } from "./shaders/passes/id-debug";
 import { paramChanged, sampleParamTrack } from "./param-track";
 import { advanceSim, DISSOLVE_PARAMS, dissolveConstants, dissolveCycleOf, effectState, sampleDissolveCycle, scheduledDissolve, } from "./effect-schedule";
 import { parentKeySpan } from "./parent-keys";
-import { SHADOW_CASCADES, buildShadowCascades } from "./shadow-cascades";
+import { NativeHost } from "./unity/host";
+import { NativeLooks } from "./unity/looks";
+import { NativeStage } from "./unity/stage";
+import { gameDir, unityFrameGlobals } from "./unity/globals";
+import { outlineMaxOffsetMultiplier, towardMatrix } from "./unity/character";
+import { SHADOW_ATLAS_SIZE, SHADOW_CASCADES, buildShadowCascades, cascadeSpheres } from "./shadow-cascades";
 import { REFLECTION_DEBUG_WGSL, buildMirrorCamera, planeFromPointNormal } from "./reflection";
 import { MIRROR_MASK_DOWNSAMPLE_WGSL, MIRROR_MAT_BYTES, mirrorShaderWgsl, mirrorShadowWgsl } from "./shaders/passes/mirror";
 import { packHalf } from "./hdr";
@@ -706,6 +711,18 @@ const FIELD_LAYER_BLEND_ADDITIVE = {
     // construction rather than by hoping an author stayed inside it.
     alpha: { srcFactor: "one", dstFactor: "one", operation: "add" },
 };
+/**
+ * Rendering layers, as the game's pipeline (URP's rendering layers) uses them:
+ * every drawing carries layer bits and a light reaches it only where its mask
+ * shares one. A stage, prop or plane draws on DEFAULT; the cast on DEFAULT and
+ * CHARACTER, the bits Aether Gazer's characters carry (0x40000001).
+ */
+export const RENDERING_LAYER_DEFAULT = 1;
+export const RENDERING_LAYER_CHARACTER = 1 << 30;
+/** Every layer — what a light without a mask reaches. */
+const ALL_LAYERS = 0xffffffff;
+/** Where the directional slots' layer bits sit in the light uniform, in words. */
+const DIR_LAYERS_AT = 108;
 export class Engine {
     static getInstance() {
         if (!Engine.instance) {
@@ -741,7 +758,11 @@ export class Engine {
         // padded to 80. sh[0].w is the IBL flag: 0 = flat world colour, 1 = the sky.
         // …then the scene fog at [72..87] — see setSceneFog — and the cast's
         // shadow on a stage at [88..107] (colour, amount; its view-projection).
+        // …and the directional slots' rendering layers at [108..111], as u32 bits
+        // through lightDataWords — never through a float.
         this.lightData = new Float32Array(112);
+        this.lightDataWords = new Uint32Array(this.lightData.buffer);
+        this.sunLayers = ALL_LAYERS;
         this.castShadow = null;
         this.castShadowBundle = null;
         this.castShadowCleared = false;
@@ -1134,6 +1155,20 @@ export class Engine {
         /** Scene seconds, advanced by the frame delta — NOT wall time, so an offline
          *  export samples the same path the editor showed. */
         this.sceneClock = 0;
+        /** Models dressed in the game's own materials (unity/looks.ts); built on the
+         *  first look installed. */
+        this.nativeLooks = null;
+        /** The scene pass's host for the game's shaders, and the shadow atlas's. */
+        this.nativeHost = null;
+        this.nativeShadowHost = null;
+        /** A game stage drawn by its own shaders (unity/stage.ts). */
+        this.nativeStage = null;
+        /** The frame's Unity globals, computed once for every native draw. */
+        this.nativeGlobals = {};
+        this.nativeFallback = {};
+        /** A 1x1 depth map at the far plane: a game shader's shadow lookup into a
+         *  map the scene does not have reads lit. */
+        this.nativeNoShadowView = null;
         this.trailAccum = 0;
         /** Trail samples owed this frame, computed once so every trail on every
          *  character samples in lockstep and their paths stay comparable. */
@@ -1180,8 +1215,6 @@ export class Engine {
         /** The user's own "no ground" switch — see setGroundVisible. Distinct from
          *  hasGround, which records whether a ground was ever built. */
         this.groundHidden = false;
-        this.shadowMapTextures = [];
-        this.shadowMapDepthViews = [];
         // The shadow PASS reads one cascade's matrix per pass, and a uniform binding
         // into the aggregate would need 256-byte alignment padding — two tiny buffers
         // are simpler than teaching every reader about a stride.
@@ -1312,10 +1345,6 @@ export class Engine {
          *  resources are half-built, which is exactly the moment a host swaps a sky.
          *  Retried at the top of a frame until one of them takes. */
         this.worldBindingsDirty = false;
-        /** Per cascade: does its map currently hold nothing but the cleared far plane?
-         *  Set by the cascade loop, which skips a cascade that is unwanted and already
-         *  cleared rather than re-clearing it every frame. */
-        this.shadowCascadeCleared = [];
         this.tweenFrom = { position: new Vec3(0, 0, 0), rotation: Quat.identity() };
         this.tweenTo = { position: new Vec3(0, 0, 0), rotation: Quat.identity() };
         this.tweenPosition = new Vec3(0, 0, 0);
@@ -1604,6 +1633,10 @@ export class Engine {
         /** Models this wrote a dissolve onto last frame, so one nothing asks for any
          *  more comes back whole instead of holding wherever it was left. */
         this.dissolveTouched = new Set();
+        // Compile a group's graph → WGSL → pipeline(s), install keyed by group id. Reuses the
+        // install (pipeline + uniform buffer) when the graph/integration is byte-unchanged.
+        /** A graph's own images (ShaderGraph.images), fetched and decoded once per URL. */
+        this.graphImageCache = new Map();
         this.canvas = canvas;
         const d = DEFAULT_ENGINE_OPTIONS;
         this.world = {
@@ -1855,7 +1888,7 @@ export class Engine {
         // rebuilt per effect, so the compiled variant IS the flag.
         u[11] = this.backdropEquirectView ? 2 : showingWorld ? 3 : bg ? 1 : 0;
         // Which display transform forms the frame (see viewTransform in composite.ts).
-        u[25] = v.transform === "agx" ? 2 : v.transform === "standard" ? 1 : 0;
+        u[25] = v.transform === "aether-gazer" ? 3 : v.transform === "agx" ? 2 : v.transform === "standard" ? 1 : 0;
         u[26] = this.canvas.width;
         u[27] = this.canvas.height;
         // ── Grade (viewU[7..9]) ── The UI's three tonal COLORS map to ASC CDL here,
@@ -4096,6 +4129,7 @@ export class Engine {
             paramsDecl: params.wgsl(EFFECT_PARAMS_BINDING),
             gridSize: grid?.size ?? 0,
             cover: particleEntryPoints(wgsl).cover,
+            orient: particleEntryPoints(wgsl).orient,
             live: particleEntryPoints(wgsl).count,
             textures: d.textures,
         };
@@ -4216,8 +4250,7 @@ export class Engine {
                         { binding: PARTICLE_LIGHT_BINDING, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
                         { binding: PARTICLE_LIGHT_BINDING + 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
                         { binding: PARTICLE_LIGHT_BINDING + 2, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth" } },
-                        { binding: PARTICLE_LIGHT_BINDING + 3, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth" } },
-                        { binding: PARTICLE_LIGHT_BINDING + 4, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "comparison" } },
+                        { binding: PARTICLE_LIGHT_BINDING + 3, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "comparison" } },
                     ]
                     : []),
                 // The live count's arguments, for the COUNT kernel's layout alone. The
@@ -4264,9 +4297,8 @@ export class Engine {
                     ? [
                         { binding: PARTICLE_LIGHT_BINDING, resource: { buffer: this.lightUniformBuffer } },
                         { binding: PARTICLE_LIGHT_BINDING + 1, resource: { buffer: this.shadowLightVPBuffer } },
-                        { binding: PARTICLE_LIGHT_BINDING + 2, resource: this.shadowMapDepthViews[0] },
-                        { binding: PARTICLE_LIGHT_BINDING + 3, resource: this.shadowMapDepthViews[SHADOW_CASCADES.length - 1] },
-                        { binding: PARTICLE_LIGHT_BINDING + 4, resource: this.shadowComparisonSampler },
+                        { binding: PARTICLE_LIGHT_BINDING + 2, resource: this.shadowAtlasView },
+                        { binding: PARTICLE_LIGHT_BINDING + 3, resource: this.shadowComparisonSampler },
                     ]
                     : []),
                 ...(withIndirect && indirect ? [{ binding: PARTICLE_INDIRECT_BINDING, resource: { buffer: indirect } }] : []),
@@ -6213,11 +6245,6 @@ export class Engine {
             usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
         });
         this.device.queue.writeTexture({ texture: this.fallbackMaterialTexture }, new Uint8Array([255, 255, 255, 255]), { bytesPerRow: 4 }, [1, 1]);
-        this.noFillBuffer = this.device.createBuffer({
-            label: "model light (none)",
-            size: 48,
-            usage: GPUBufferUsage.UNIFORM,
-        });
         // Generic shared-toon ramp: lit white down to a soft cool shadow tone with
         // a tight terminator around the midpoint, approximating MMD's toon ramps.
         const TOON_H = 64;
@@ -6309,10 +6336,10 @@ export class Engine {
                 // The positional lights. Always bound, empty or not, so every material
                 // pipeline shares one layout whether or not the scene has any.
                 { binding: 6, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "read-only-storage" } },
-                // The far cascade's shadow map, then the world's sky (8) and the BRDF
-                // LUT (9). The sky is always bound — the 1x1 fallback when the scene
-                // has none — so every material pipeline keeps sharing one layout.
-                { binding: 7, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth" } },
+                // The world's sky (8) and the BRDF LUT (9). The sky is always bound —
+                // the 1x1 fallback when the scene has none — so every material
+                // pipeline keeps sharing one layout. (7 was the far cascade's map,
+                // which the atlas at 3 replaces.)
                 { binding: 8, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
                 { binding: 9, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float" } },
                 // The cast's shadow on a stage — setStageCastShadow.
@@ -6521,15 +6548,15 @@ export class Engine {
             magFilter: "linear",
             minFilter: "linear",
         });
-        // One map per cascade, each at its own resolution — the near one crisp,
-        // the far one wide. Same format so one pipeline records into both.
-        this.shadowMapTextures = SHADOW_CASCADES.map((c, i) => this.device.createTexture({
-            label: `shadow map cascade ${i}`,
-            size: [c.mapSize, c.mapSize],
+        // One atlas, a tile per cascade — the layout the game's pipeline uses, and
+        // one binding for every reader.
+        this.shadowAtlasTexture = this.device.createTexture({
+            label: "sun shadow atlas",
+            size: [SHADOW_ATLAS_SIZE, SHADOW_ATLAS_SIZE],
             format: Engine.SHADOW_DEPTH_FORMAT,
             usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
-        }));
-        this.shadowMapDepthViews = this.shadowMapTextures.map((t) => t.createView());
+        });
+        this.shadowAtlasView = this.shadowAtlasTexture.createView();
         // The cast's shadow on a stage (setStageCastShadow): one map, only the cast
         // in it, from the stage's own direction. Always allocated so every material
         // bind group and every instance's shadow bind group stays one shape; drawn
@@ -6624,7 +6651,6 @@ export class Engine {
                 // Same lights the materials read. A lamp that lit the cast and not the
                 // floor under her would read as a sticker.
                 { binding: 6, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "read-only-storage" } },
-                { binding: 7, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth" } },
                 // The floor mirror: the mirror camera's view-projection, the reflection
                 // resolve, an ordinary sampler beside the comparison one, and the
                 // mirror pass's own depth for the depth-proportional blur.
@@ -8670,7 +8696,7 @@ export class Engine {
         // picture later.
         if (!this.device ||
             !this.mainPerFrameBindGroupLayout ||
-            !this.shadowMapDepthViews?.length ||
+            !this.shadowAtlasView ||
             !this.cameraUniformBuffer ||
             !this.mirrorCameraBuffer ||
             !this.lightUniformBuffer ||
@@ -8695,11 +8721,10 @@ export class Engine {
                 { binding: 0, resource: { buffer: this.cameraUniformBuffer } },
                 { binding: 1, resource: { buffer: this.lightUniformBuffer } },
                 { binding: 2, resource: this.materialSampler },
-                { binding: 3, resource: this.shadowMapDepthViews[0] },
+                { binding: 3, resource: this.shadowAtlasView },
                 { binding: 4, resource: this.shadowComparisonSampler },
                 { binding: 5, resource: { buffer: this.shadowLightVPBuffer } },
                 { binding: 6, resource: { buffer: this.lightsBuffer } },
-                { binding: 7, resource: this.shadowMapDepthViews[SHADOW_CASCADES.length - 1] },
                 { binding: 8, resource: env },
                 { binding: 9, resource: this.brdfLutView },
                 { binding: 10, resource: this.castShadowView },
@@ -8712,11 +8737,10 @@ export class Engine {
                 { binding: 0, resource: { buffer: this.mirrorCameraBuffer } },
                 { binding: 1, resource: { buffer: this.lightUniformBuffer } },
                 { binding: 2, resource: this.materialSampler },
-                { binding: 3, resource: this.shadowMapDepthViews[0] },
+                { binding: 3, resource: this.shadowAtlasView },
                 { binding: 4, resource: this.shadowComparisonSampler },
                 { binding: 5, resource: { buffer: this.shadowLightVPBuffer } },
                 { binding: 6, resource: { buffer: this.lightsBuffer } },
-                { binding: 7, resource: this.shadowMapDepthViews[SHADOW_CASCADES.length - 1] },
                 { binding: 8, resource: env },
                 { binding: 9, resource: this.brdfLutView },
                 { binding: 10, resource: this.castShadowView },
@@ -8782,6 +8806,7 @@ export class Engine {
         this.lightData[base + 5] = this.sun.color.y;
         this.lightData[base + 6] = this.sun.color.z;
         this.lightData[base + 7] = this.sun.strength;
+        this.lightDataWords[DIR_LAYERS_AT + index] = this.sunLayers;
         if (index >= this.lightCount)
             this.lightCount = index + 1;
         this.updateLightBuffer();
@@ -8922,6 +8947,8 @@ export class Engine {
             this.sun.strength = options.strength;
         if (options.shadow !== undefined)
             this.sunShadow = Math.min(Math.max(options.shadow, 0), 1);
+        if (options.layers !== undefined)
+            this.sunLayers = options.layers >>> 0;
         if (options.direction) {
             this.sun.direction = options.direction;
             this.shadowLightVPDirty = true;
@@ -9013,7 +9040,20 @@ export class Engine {
      *  params make: a scene document's JSON passes straight in, and so does a
      *  literal typed into a console. Vec3 satisfies it either way. */
     lights) {
-        const list = (lights ?? []).slice(0, MAX_LIGHTS);
+        // The directional ones go to the light uniform's slots beside the sun's —
+        // three of them, in order; the rest are records the grid indexes.
+        const directional = (lights ?? []).filter((l) => l.kind === "directional");
+        for (let k = 1; k < 4; k++) {
+            const l = directional[k - 1];
+            const base = 4 + k * 8;
+            const a = l?.aim;
+            const len = a ? Math.hypot(a.x, a.y, a.z) : 0;
+            const i = l ? Math.max(l.intensity ?? 1, 0) : 0;
+            this.lightData.set(l && len > 0 ? [a.x / len, a.y / len, a.z / len, 0, l.color.x * i, l.color.y * i, l.color.z * i, 1] : [0, 0, -1, 0, 0, 0, 0, 0], base);
+            this.lightDataWords[DIR_LAYERS_AT + k] = l && len > 0 ? (l.layers ?? ALL_LAYERS) >>> 0 : 0;
+        }
+        this.updateLightBuffer();
+        const list = (lights ?? []).filter((l) => l.kind !== "directional").slice(0, MAX_LIGHTS);
         this.docLightCount = list.length;
         // RECORDS only — the header belongs to allocateLightSlots, the one writer.
         // This used to zero-and-upload the header region too, which left two CPU
@@ -9042,7 +9082,7 @@ export class Engine {
             // vector cannot be normalised, and a cone around nothing would light
             // nothing at all — a light that vanishes because its aim was left at the
             // default is worse than one that shines everywhere.
-            const len = l.aim ? Math.hypot(l.aim.x, l.aim.y, l.aim.z) : 0;
+            const len = l.aim && l.kind !== "point" ? Math.hypot(l.aim.x, l.aim.y, l.aim.z) : 0;
             this.lightsData[b + 7] = len > 0 ? 1 : 0;
             this.lightsData[b + 8] = len > 0 ? l.aim.x / len : 0;
             this.lightsData[b + 9] = len > 0 ? l.aim.y / len : 0;
@@ -9054,7 +9094,8 @@ export class Engine {
             const inner = len > 0 ? Math.cos((Math.min(Math.max(l.innerAngle ?? (l.angle ?? 45) * 0.8, 0), 179) / 2) * (Math.PI / 180)) : -1;
             this.lightsData[b + 11] = outer;
             this.lightsData[b + 12] = Math.max(inner, outer);
-            this.lightsData[b + 13] = 0;
+            // The layers it does NOT reach, as bits — inverted so a zero reaches all.
+            this.lightsWords[b + 13] = ~(l.layers ?? ALL_LAYERS) >>> 0;
             this.lightsData[b + 14] = 0;
             this.lightsData[b + 15] = 0;
         }
@@ -9443,6 +9484,8 @@ export class Engine {
      *  ground plane must not draw, and the far shadow cascade has nothing to
      *  cover without one (see the cascade loop). */
     hasStage() {
+        if (this.nativeStage)
+            return true;
         for (const inst of this.modelInstances.values())
             if (inst.isStage)
                 return true;
@@ -9492,94 +9535,34 @@ export class Engine {
         this.modelInstances.set(newName, inst);
     }
     /**
-     * Light one model with more than the world gives it: a FILL, linear RGB times
-     * its surface colour, added after its material graph. Null takes it away again.
-     *
-     * After the graph, not in its ambient: an NPR ramp read an ambient fill as
-     * light, so sliding it moved her shadows and flipped whole regions across a
-     * hard step. Added after, it brightens her evenly and every shadow stays put.
-     *
-     * A game lights its stage and its characters apart. Aether Gazer's rooms are
-     * lit by their lamps and a near-black ambient, while its characters take a
-     * flat base light of their own — so a stage whose World is right for the room
-     * leaves a face turned from the lamps in the dark. This is that second light,
-     * for the models the host counts as cast.
-     */
-    setModelFill(name, fill) {
-        return this.writeModelLight(name, 0, fill);
-    }
-    /**
-     * A model's own sun: the colour and strength the scene's sun has FOR THIS
-     * MODEL, in place of the scene's. Null gives it the scene's sun back.
+     * One model's own ambient: the irradiance arriving at it, as the 27 floats of
+     * folded SH setWorldAmbient takes (ibl.ts), in place of the world's. Null
+     * gives it the world's again.
      *
-     * The other half of lighting a stage and its cast apart. A game's stage is
-     * lit by its own daylight — Aether Gazer's kitchen at twenty times white —
-     * while its characters take a key light of their own that the stage never
-     * states. So a stage carries the sun it was lit by, and the scene's sun
-     * stays the cast's. Direction and shadow are still the scene's: one sun
-     * casts, and it casts the same way on both.
+     * The game's pipeline lights every renderer by its own probe sample, and a
+     * character by an ambient of its own; a loader that carries those hands them
+     * in here. Linear radiance, strength included.
      */
-    setModelSun(name, sun) {
-        return this.writeModelLight(name, 4, sun);
-    }
-    /**
-     * Light one model by the sky's AVERAGE rather than its shape: the world's
-     * colour and brightness from every direction alike. False gives it the
-     * directional sky back.
-     *
-     * For a cast under an anime look. An HDRI's sky is brighter and warmer one
-     * way than another, and taken at each normal it shades a face with soft
-     * realistic gradients that no toon ramp drew — PBR on an anime face. Aether
-     * Gazer gives its characters one flat base light instead. World strength and
-     * colour still reach her; only the shape is gone. A flat World is its own
-     * average, so without an HDRI this changes nothing.
-     */
-    setModelFlatSky(name, flat) {
-        return this.writeModelLight(name, 8, flat ? new Vec3(1, 0, 0) : null);
-    }
-    /** One part of a model's light, at `at` (0 the fill, 4 the sun, 8 its
-     *  options) in its ModelLight; w says whether that part is set. All unset
-     *  releases the buffer and the model takes the shared zero stand-in again. */
-    writeModelLight(name, at, value) {
+    setModelAmbient(name, sh) {
         const inst = this.modelInstances.get(name);
         if (!inst || !this.device)
             return false;
-        const light = inst.modelLight ?? new Float32Array(12);
-        light.set(value ? [value.x, value.y, value.z, 1] : [0, 0, 0, 0], at);
-        const any = light[3] > 0 || light[7] > 0 || light[11] > 0;
-        if (!any) {
-            if (!inst.lightBuffer)
-                return true;
-            const retired = inst.lightBuffer;
-            inst.lightBuffer = null;
-            inst.modelLight = null;
-            inst.mainPerInstanceBindGroup = this.perInstanceBindGroup(name, inst.skinMatrixBuffer, null);
-            this.bundlesDirty = true;
-            // Retired once the GPU is done with it: an encoded frame may still name it.
-            void this.device.queue.onSubmittedWorkDone().then(() => retired.destroy());
-            return true;
-        }
-        inst.modelLight = light;
-        if (!inst.lightBuffer) {
-            inst.lightBuffer = this.device.createBuffer({
-                label: `${name}: light`,
-                size: 48,
-                usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
-            });
-            inst.mainPerInstanceBindGroup = this.perInstanceBindGroup(name, inst.skinMatrixBuffer, inst.lightBuffer);
-            this.bundlesDirty = true;
+        const o = inst.objectLight;
+        o[4] = sh && sh.length >= 27 ? 1 : 0;
+        for (let i = 0; i < 9; i++) {
+            o.set(sh && sh.length >= 27 ? [sh[i * 3], sh[i * 3 + 1], sh[i * 3 + 2], 0] : [0, 0, 0, 0], 8 + i * 4);
         }
-        this.device.queue.writeBuffer(inst.lightBuffer, 0, light.buffer);
+        this.device.queue.writeBuffer(inst.lightBuffer, 0, o);
         return true;
     }
-    /** The per-model group: its skinning matrices and its light, or the zero stand-in. */
+    /** The per-model group: its skinning matrices and its ObjectLight. */
     perInstanceBindGroup(name, skinMatrixBuffer, light) {
         return this.device.createBindGroup({
             label: `${name}: main per-instance bind group`,
             layout: this.mainPerInstanceBindGroupLayout,
             entries: [
                 { binding: 0, resource: { buffer: skinMatrixBuffer } },
-                { binding: 1, resource: { buffer: light ?? this.noFillBuffer } },
+                { binding: 1, resource: { buffer: light } },
             ],
         });
     }
@@ -11161,7 +11144,9 @@ export class Engine {
         let changed = force;
         for (let i = 0; i < this.cullDraws.length; i++) {
             const { inst, draw } = this.cullDraws[i];
-            const v = inst.hiddenMaterials.has(draw.materialName) || inst.morphHiddenMaterials.has(draw.materialName) ? 1 : 0;
+            // bit 0: switched off; bit 1: drawn by its native look, not its graph
+            const v = (inst.hiddenMaterials.has(draw.materialName) || inst.morphHiddenMaterials.has(draw.materialName) ? 1 : 0) |
+                (this.nativeLooks?.dresses(inst.name, draw.materialName) ? 2 : 0);
             if (out[i] !== v) {
                 out[i] = v;
                 changed = true;
@@ -11306,6 +11291,15 @@ export class Engine {
                 maxZ = Math.max(maxZ, data[o + 18] + r);
             }
         }
+        if (this.nativeStage) {
+            const nb = this.nativeStage.bounds;
+            minX = Math.min(minX, nb.min[0]);
+            maxX = Math.max(maxX, nb.max[0]);
+            minY = Math.min(minY, nb.min[1]);
+            maxY = Math.max(maxY, nb.max[1]);
+            minZ = Math.min(minZ, nb.min[2]);
+            maxZ = Math.max(maxZ, nb.max[2]);
+        }
         if (!Number.isFinite(minX)) {
             this.shadowSceneBounds = null;
             return;
@@ -12099,7 +12093,19 @@ export class Engine {
                 { binding: 2, resource: this.materialSampler },
             ],
         }));
-        const mainPerInstanceBindGroup = this.perInstanceBindGroup(name, skinMatrixBuffer, null);
+        // Its ObjectLight: the world's ambient, and the layers its kind draws on —
+        // the cast on the character layer as well as the default one. Words:
+        // layers [0..3], ambient flag [4..7], SH [8..43] — see materials/common.ts.
+        const objectLight = new Float32Array(44);
+        new Uint32Array(objectLight.buffer)[0] =
+            isStage || isPlane || isProp ? RENDERING_LAYER_DEFAULT : (RENDERING_LAYER_DEFAULT | RENDERING_LAYER_CHARACTER) >>> 0;
+        const lightBuffer = this.device.createBuffer({
+            label: `${name}: object light`,
+            size: objectLight.byteLength,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        });
+        this.device.queue.writeBuffer(lightBuffer, 0, objectLight);
+        const mainPerInstanceBindGroup = this.perInstanceBindGroup(name, skinMatrixBuffer, lightBuffer);
         const pickPerInstanceBindGroup = this.device.createBindGroup({
             label: `${name}: pick per-instance bind group`,
             layout: this.pickPerInstanceBindGroupLayout,
@@ -12132,8 +12138,8 @@ export class Engine {
             shadowDrawCalls: [],
             shadowBindGroups,
             mainPerInstanceBindGroup,
-            lightBuffer: null,
-            modelLight: null,
+            lightBuffer,
+            objectLight,
             pickPerInstanceBindGroup,
             pickDrawCalls: [],
             isStage,
@@ -12347,7 +12353,6 @@ export class Engine {
         gb[3] = fadeStart;
         gb[4] = fadeEnd;
         gb[5] = shadowStrength;
-        gb[6] = 1 / SHADOW_CASCADES[0].mapSize;
         gb[7] = gridSpacing;
         gb[8] = gridLineWidth;
         gb[9] = gridLineOpacity;
@@ -12369,19 +12374,6 @@ export class Engine {
         // Which variant the draw picks. Zero is the sharp shader, which is the one
         // that existed before softness did.
         this.groundSoft = gb[18] > 0;
-        // gb[17] — does the FAR cascade hold anything?
-        //
-        // It holds something only when a stage is loaded; that is what it exists for
-        // and the cascade loop already skips drawing into it otherwise, leaving it
-        // cleared. A cleared depth map compares as "no occluder", so the ground's far
-        // branch is nine comparison taps whose answer is known in advance.
-        //
-        // That branch runs wherever the NEAR cascade does not reach, and the near one
-        // is a 64-unit box around the camera target — so on a floor receding to the
-        // horizon it is most of the visible pixels, on the most expensive
-        // full-coverage draw in the frame. Skipping it is free in the exact sense:
-        // the shader takes vis = 1.0, which is what the taps would have returned.
-        gb[17] = this.hasStage() ? 1 : 0;
         // gb[20..23] — the caster sphere, refreshed every frame by
         // writeGroundCasterSphere. Zero here so a frame that renders before the
         // first cull (there is one) reads "nothing casts" and skips the taps, which
@@ -12446,12 +12438,11 @@ export class Engine {
             entries: [
                 { binding: 0, resource: { buffer: this.cameraUniformBuffer } },
                 { binding: 1, resource: { buffer: this.lightUniformBuffer } },
-                { binding: 2, resource: this.shadowMapDepthViews[0] },
+                { binding: 2, resource: this.shadowAtlasView },
                 { binding: 3, resource: this.shadowComparisonSampler },
                 { binding: 4, resource: { buffer: this.groundShadowMaterialBuffer } },
                 { binding: 5, resource: { buffer: this.shadowLightVPBuffer } },
                 { binding: 6, resource: { buffer: this.lightsBuffer } },
-                { binding: 7, resource: this.shadowMapDepthViews[SHADOW_CASCADES.length - 1] },
                 { binding: 8, resource: { buffer: this.mirrorVPBuffer } },
                 // Created in handleResize, which runs during init — before any ground
                 // can exist to bind it.
@@ -12469,12 +12460,11 @@ export class Engine {
             entries: [
                 { binding: 0, resource: { buffer: this.mirrorCameraBuffer } },
                 { binding: 1, resource: { buffer: this.lightUniformBuffer } },
-                { binding: 2, resource: this.shadowMapDepthViews[0] },
+                { binding: 2, resource: this.shadowAtlasView },
                 { binding: 3, resource: this.shadowComparisonSampler },
                 { binding: 4, resource: { buffer: this.groundShadowMaterialBuffer } },
                 { binding: 5, resource: { buffer: this.shadowLightVPBuffer } },
                 { binding: 6, resource: { buffer: this.lightsBuffer } },
-                { binding: 7, resource: this.shadowMapDepthViews[SHADOW_CASCADES.length - 1] },
                 { binding: 8, resource: { buffer: this.mirrorVPBuffer } },
                 // Stand-ins, not the live mirror textures: this group draws INTO the
                 // mirror pass, where those are the attachments.
@@ -14088,54 +14078,54 @@ export class Engine {
         // the final frame's depth — and the ground, which draws on `hasGround` alone,
         // keeps PCF-sampling a character that is no longer in the scene. One clearing
         // pass on the transition to empty, then it stops.
-        if (hasModels || this.shadowMapPopulated) {
-            // The far cascade is the STAGE cascade, and it costs a full pass over the
-            // whole cast every frame to say so. Its own spec explains what it is for —
-            // "a set piece 100 units out still throws" — and a scene with no stage has
-            // no set piece: every caster sits inside the near cascade's 64-unit box,
-            // which follows the camera target, and the far map's only readers are
-            // ground pixels beyond that box, where nothing is casting.
-            //
-            // So when no stage is loaded it is drawn ONCE, cleared, and then skipped —
-            // the same shape as shadowMapPopulated above, and for the same reason. A
-            // cleared depth map reads as "no occluder", which is the correct answer
-            // here rather than a missing one. Load a stage and it comes straight back.
-            //
-            // 0.43 had ONE shadow map. This is half of what the second one costs.
+        // The game's globals before anything native draws: the stage's casters
+        // into the atlas are the first.
+        if (this.nativeStage || this.nativeLooks?.size)
+            this.prepareNativeLooks(encoder);
+        if (hasModels || this.nativeStage || this.shadowMapPopulated) {
+            // The outer cascades are the STAGE's, and each costs a pass over the whole
+            // cast. A scene with no stage has no set piece out there: every caster
+            // sits inside the inner cascade, which follows the camera target, and
+            // the outer tiles' only readers are ground pixels beyond it, where
+            // nothing is casting. So without a stage only the inner tile is drawn;
+            // the others keep the far plane cascade 0's pass cleared the whole atlas
+            // to, which compares as "no occluder" — the correct answer there.
             const stage = this.hasStage();
             for (let ci = 0; ci < SHADOW_CASCADES.length; ci++) {
-                const wanted = ci === 0 || stage;
-                // Already cleared and still unwanted — nothing to do, and the map still
-                // holds the far plane from the pass that cleared it.
-                if (!wanted && this.shadowCascadeCleared[ci])
+                if (ci > 0 && !stage)
                     continue;
+                const c = SHADOW_CASCADES[ci];
                 const sp = encoder.beginRenderPass({
-                    // One timestamp pair exists for "shadow"; the near cascade wears it.
+                    // One timestamp pair exists for "shadow"; the inner cascade wears it.
                     timestampWrites: ci === 0 ? this.stamps("shadow") : undefined,
                     colorAttachments: [],
                     depthStencilAttachment: {
-                        view: this.shadowMapDepthViews[ci],
+                        view: this.shadowAtlasView,
                         depthClearValue: 1.0,
-                        depthLoadOp: "clear",
+                        depthLoadOp: ci === 0 ? "clear" : "load",
                         depthStoreOp: "store",
                     },
                 });
+                // The tile: a bundle draws through the pass's viewport, which it
+                // cannot set itself, so one recording serves whichever tile is live.
+                sp.setViewport(c.origin[0], c.origin[1], c.mapSize, c.mapSize, 0, 1);
                 // The per-model `visible` test that used to guard this is gone: it is a
                 // per-frame boolean, and baking it into a bundle would make toggling a
                 // model re-record. It lives in the cull compute now, which zeroes the
                 // instance count of an invisible model's draws.
-                if (wanted && this.shadowBundles[ci])
+                if (this.shadowBundles[ci])
                     sp.executeBundles([this.shadowBundles[ci]]);
                 // The mirror throws shade like anything else standing on the floor.
                 // Direct rather than in the bundle: the bundles are recorded on scene
                 // STRUCTURE, and a mirror comes and goes with an effect's weight.
-                if (wanted && this.mirrorSurface && this.mirrorShadowPipeline) {
+                if (this.mirrorSurface && this.mirrorShadowPipeline) {
                     sp.setPipeline(this.mirrorShadowPipeline);
                     sp.setBindGroup(0, this.mirrorShadowBindGroups[ci]);
                     sp.draw(6);
                 }
+                if (this.nativeStage && this.nativeShadowHost)
+                    this.nativeStage.drawShadow(sp, this.nativeShadowHost, this.nativeGlobals, ci, this.shadowLightVPMatrix.subarray(ci * 16, ci * 16 + 16), 8);
                 sp.end();
-                this.shadowCascadeCleared[ci] = !wanted;
             }
             // The cast's shadow on a stage: drawn while a stage asks for it and has a
             // cast to shade it with; cleared once when it stops, then left alone.
@@ -14150,7 +14140,7 @@ export class Engine {
                 cp.end();
                 this.castShadowCleared = !castOn;
             }
-            this.shadowMapPopulated = hasModels;
+            this.shadowMapPopulated = hasModels || !!this.nativeStage;
         }
         // Before the particles and before the field pass: both may read the grid,
         // and a grid stepped after them is one frame stale in everything that used it.
@@ -14195,6 +14185,17 @@ export class Engine {
         // is FALSE for the cleared buffer — every such fragment silently rejected.
         // One redundant word against a whole class of invisible failure.
         pass.setStencilReference(Engine.STENCIL_EYE_VALUE);
+        // The models dressed in the game's materials, and the game's character
+        // passes after them (unity/looks.ts). They set their own stencil
+        // references, so the engine's is put back after.
+        if (this.nativeLooks?.size) {
+            this.nativeLooks.drawOpaque(pass);
+            pass.setStencilReference(Engine.STENCIL_EYE_VALUE);
+        }
+        if (this.nativeStage && this.nativeHost) {
+            this.nativeStage.drawOpaque(pass, this.nativeHost, this.nativeGlobals, this.nativeFrameTextures(), this.eyeArray());
+            pass.setStencilReference(Engine.STENCIL_EYE_VALUE);
+        }
         if (this.hasGround)
             this.renderGround(pass);
         // After the ground for the same early-z reason, and before the transparent
@@ -14227,6 +14228,14 @@ export class Engine {
         // which was never this renderer's bottleneck.
         const camView = this.sceneView("camera");
         this.forEachInstance((inst) => this.renderModelTransparentPhase(pass, inst, camView));
+        if (this.nativeStage && this.nativeHost) {
+            this.nativeStage.drawTransparent(pass, this.nativeHost, this.nativeGlobals, this.nativeFrameTextures(), this.eyeArray());
+            pass.setStencilReference(Engine.STENCIL_EYE_VALUE);
+        }
+        if (this.nativeLooks?.size) {
+            this.nativeLooks.drawTransparent(pass);
+            pass.setStencilReference(Engine.STENCIL_EYE_VALUE);
+        }
         // Last in the pass: depth-tested against everything drawn above, so a
         // particle behind the character is simply hidden, and still inside the HDR
         // target so an `#bloom` effect reaches the pyramid below.
@@ -14749,9 +14758,35 @@ export class Engine {
                 claimed.set(m, install.group.id);
         return claimed;
     }
-    // Compile a group's graph → WGSL → pipeline(s), install keyed by group id. Reuses the
-    // install (pipeline + uniform buffer) when the graph/integration is byte-unchanged.
-    async compileAndInstallGroup(inst, group, opts) {
+    graphImage(url) {
+        let p = this.graphImageCache.get(url);
+        if (!p) {
+            p = fetch(url)
+                .then((r) => (r.ok ? r.blob() : Promise.reject(new Error(`${r.status} ${url}`))))
+                .then((b) => createImageBitmap(b, { colorSpaceConversion: "none", premultiplyAlpha: "none" }))
+                .catch((e) => {
+                console.warn(`[style] graph image: ${e.message}`);
+                return null;
+            });
+            this.graphImageCache.set(url, p);
+        }
+        return p;
+    }
+    /** The group with its graph's images, where the group brings none of its own. */
+    async withGraphImages(group) {
+        const wanted = group.graph.images;
+        if (!wanted?.length || group.images?.length)
+            return group;
+        const images = await Promise.all(wanted.slice(0, 4).map(async (w) => {
+            if (!w)
+                return null;
+            const source = await this.graphImage(w.url);
+            return source ? { source, srgb: w.srgb ?? false } : null;
+        }));
+        return { ...group, images };
+    }
+    async compileAndInstallGroup(inst, groupIn, opts) {
+        const group = await this.withGraphImages(groupIn);
         const renderClass = group.renderClass ?? "auto";
         const alphaMode = group.alphaMode ?? "opaque";
         // THE MAPS ARE PART OF THE SIGNATURE, because a matching one skips the
@@ -15850,6 +15885,243 @@ export class Engine {
         // The count rides in the anchor's spare lane, so rzTrailCount is one read.
         cd[anchorBase + 11] = count;
     }
+    /**
+     * Dress a model in the game's own materials — a look exported with ag-rip
+     * (translated shaders, their images, per-material passes and values, and a
+     * character rig) — or take it off with null. The materials it names are
+     * drawn by the game's shaders from then on; the rest keep their graphs, and
+     * every one still casts its shadow through the engine's pass.
+     */
+    setModelNativeLook(name, look) {
+        const inst = this.modelInstances.get(name);
+        if (!inst || !this.device)
+            return false;
+        if (!look) {
+            this.nativeLooks?.remove(name);
+            this.writeCullHidden(true);
+            return true;
+        }
+        if (!this.nativeLooks)
+            this.nativeLooks = new NativeLooks(this.device, this.ensureNativeHosts());
+        const skeleton = inst.model.getSkeleton();
+        const head = skeleton.bones.findIndex((b) => b.name === "頭");
+        // The head's rest position: a rigid inverse bind [R t] is the bind pose
+        // inverted, so the bind position is −Rᵀt.
+        let headRest = [0, 0, 0];
+        if (head >= 0) {
+            const m = skeleton.inverseBindMatrices.subarray(head * 16, head * 16 + 16);
+            headRest = [
+                -(m[0] * m[12] + m[1] * m[13] + m[2] * m[14]),
+                -(m[4] * m[12] + m[5] * m[13] + m[6] * m[14]),
+                -(m[8] * m[12] + m[9] * m[13] + m[10] * m[14]),
+            ];
+        }
+        const draws = inst.drawCalls
+            .filter((dc) => dc.baseBindGroupEntries)
+            .map((dc) => ({
+            materialName: dc.materialName,
+            firstIndex: dc.firstIndex,
+            count: dc.count,
+            diffuse: dc.baseBindGroupEntries.find((e) => e.binding === 0).resource,
+        }));
+        this.nativeLooks.install({
+            name,
+            vertices: inst.model.getVertices(),
+            indices: inst.model.getIndices(),
+            vertexBuffer: inst.vertexBuffer,
+            jointsBuffer: inst.jointsBuffer,
+            weightsBuffer: inst.weightsBuffer,
+            skinMatrixBuffer: inst.skinMatrixBuffer,
+            indexBuffer: inst.indexBuffer,
+            draws,
+            hidden: (m) => inst.hiddenMaterials.has(m) || inst.morphHiddenMaterials.has(m),
+            headSkin: () => (head >= 0 ? inst.model.getSkinMatrices().subarray(head * 16, head * 16 + 16) : null),
+            headRest,
+            layers: new Uint32Array(inst.objectLight.buffer)[0],
+        }, look);
+        this.writeCullHidden(true);
+        return true;
+    }
+    /** The hosts for the game's shaders: the scene pass's and the shadow atlas's,
+     *  with the stand-ins an empty slot reads. Built on first use. */
+    ensureNativeHosts() {
+        if (this.nativeHost)
+            return this.nativeHost;
+        const d = this.device;
+        const noShadow = d.createTexture({
+            label: "native: no shadow",
+            size: [1, 1],
+            format: "depth32float",
+            usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
+        });
+        const enc = d.createCommandEncoder();
+        enc
+            .beginRenderPass({
+            colorAttachments: [],
+            depthStencilAttachment: { view: noShadow.createView(), depthClearValue: 1, depthLoadOp: "clear", depthStoreOp: "store" },
+        })
+            .end();
+        d.queue.submit([enc.finish()]);
+        this.nativeNoShadowView = noShadow.createView();
+        const solid = (label, rgba, cube = false) => {
+            const t = d.createTexture({
+                label,
+                size: [1, 1, cube ? 6 : 1],
+                format: "rgba8unorm",
+                usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,
+            });
+            for (let l = 0; l < (cube ? 6 : 1); l++)
+                d.queue.writeTexture({ texture: t, origin: [0, 0, l] }, new Uint8Array(rgba), { bytesPerRow: 4 }, [1, 1]);
+            return t.createView(cube ? { dimension: "cube" } : undefined);
+        };
+        const white = solid("native: white", [255, 255, 255, 255]);
+        const black = solid("native: black", [0, 0, 0, 255]);
+        // Unity's stand-ins for an empty slot, by the name a shader declares.
+        this.nativeFallback = {
+            white,
+            black,
+            "": white,
+            grey: solid("native: grey", [128, 128, 128, 255]),
+            gray: solid("native: gray", [128, 128, 128, 255]),
+            bump: solid("native: bump", [128, 128, 255, 255]),
+            red: solid("native: red", [255, 0, 0, 255]),
+        };
+        const fallback = {
+            white,
+            black,
+            blackCube: solid("native: black cube", [0, 0, 0, 255], true),
+            depth: this.nativeNoShadowView,
+            comparison: this.shadowComparisonSampler,
+        };
+        this.nativeHost = new NativeHost(d, {
+            colorFormats: sceneColorFormats(this.sceneFormats),
+            depthFormat: this.depthFormat,
+            sampleCount: Engine.MULTISAMPLE_COUNT,
+            reversedZ: this.reversedZ,
+        }, fallback);
+        this.nativeShadowHost = new NativeHost(d, { colorFormats: [], depthFormat: Engine.SHADOW_DEPTH_FORMAT, sampleCount: 1, reversedZ: false }, fallback);
+        return this.nativeHost;
+    }
+    /**
+     * Load a game stage as the game draws it - a package ag-rip's
+     * stage_native.py exported (stage.json and the files beside it, read through
+     * `read` by their paths in it) - or remove the one loaded with null. Its
+     * scene settings (fog, tint, ambient, environment) become the game shaders'
+     * for the whole scene; its lights are the caller's to set, as lights.
+     */
+    async setNativeStage(pkg, read, onProgress) {
+        const old = this.nativeStage;
+        this.nativeStage = null;
+        if (old)
+            old.destroy([this.nativeHost, this.nativeShadowHost]);
+        if (!pkg || !read || !this.device)
+            return;
+        const scene = this.ensureNativeHosts();
+        this.nativeStage = await NativeStage.load(this.device, pkg, read, { scene, shadow: this.nativeShadowHost }, { mipmaps: (t, levels) => this.generateMipmaps(t, levels), fallback: this.nativeFallback }, onProgress);
+    }
+    /** What went wrong in the game's shaders, and the names nothing supplied. */
+    nativeReport() {
+        const errors = [...(this.nativeHost?.errors ?? []), ...(this.nativeShadowHost?.errors ?? [])];
+        const missing = {};
+        for (const h of [this.nativeHost, this.nativeShadowHost])
+            for (const [k, v] of h?.missing ?? [])
+                missing[k] = (missing[k] ?? 0) + v;
+        return { errors, missing };
+    }
+    nativeFrameTextures() {
+        return { _MainLightShadowmapTexture: this.shadowAtlasView, sim_CharacterShadowmap: this.nativeNoShadowView ?? undefined };
+    }
+    eyeArray() {
+        const e = this.camera.getEyePosition();
+        return [e.x, e.y, e.z];
+    }
+    /** Before the scene pass: the dressed models' skinning and the game's globals. */
+    prepareNativeLooks(encoder) {
+        const looks = this.nativeLooks;
+        const view = this.camera.getViewMatrix().values;
+        const proj = this.camera.getProjectionMatrix().values;
+        const eye = this.camera.getEyePosition();
+        const sun = this.sun;
+        const dir = sun.direction.normalize();
+        const k = sun.strength;
+        // The document's lamps as their records store them.
+        const lights = [];
+        for (let i = 0; i < this.docLightCount; i++) {
+            const b = LIGHT_HEADER + i * LIGHT_STRIDE;
+            const d = this.lightsData;
+            lights.push({
+                position: [d[b], d[b + 1], d[b + 2]],
+                radius: d[b + 3],
+                color: [d[b + 4], d[b + 5], d[b + 6]],
+                aim: [d[b + 8], d[b + 9], d[b + 10]],
+                cosOuter: d[b + 11],
+                cosInner: d[b + 12],
+                layers: ~this.lightsWords[b + 13] >>> 0,
+            });
+        }
+        // A game stage brings its own lights: the game's shaders get exactly those
+        // (its sun, its lamps, all layers), whatever the scene's lamps are.
+        const stage = this.nativeStage;
+        let sunDirection = [dir.x, dir.y, dir.z];
+        let sunColor = [sun.color.x * k, sun.color.y * k, sun.color.z * k];
+        let sunShadow = this.sunShadow;
+        if (stage) {
+            // Its lamps are the stage's own; its key is the scene's sun, which the
+            // host sets from the stage (and a person may then move).
+            const L = stage.pkg.lights;
+            const sc = stage.pkg.scale;
+            lights.length = 0;
+            for (const l of L.additional) {
+                lights.push({
+                    position: [-l.position[0] * sc, l.position[1] * sc, -l.position[2] * sc],
+                    radius: l.range * sc,
+                    color: [l.color[0] * sc * sc, l.color[1] * sc * sc, l.color[2] * sc * sc],
+                    aim: (l.aim ? gameDir(l.aim) : [0, 0, 0]),
+                    cosOuter: l.cosOuter ?? -1,
+                    cosInner: l.cosInner ?? -1,
+                    layers: 0xffffffff,
+                    unity: l.unity,
+                });
+            }
+        }
+        const s = this.world.strength;
+        const sh = this.worldAmbientSH ?? this.worldSH ?? this.worldGradientSH;
+        const g = unityFrameGlobals({
+            scale: 8,
+            view,
+            proj,
+            eye: [eye.x, eye.y, eye.z],
+            near: this.camera.near,
+            far: this.camera.far,
+            width: this.canvas.width,
+            height: this.canvas.height,
+            time: this.sceneClock,
+            dt: 1 / 60,
+            sunDirection,
+            sunColor,
+            sunShadow,
+            lights,
+            ambientSH: sh ? Array.from(sh, (v) => v * s) : null,
+            ambientFlat: [this.world.color.x * s, this.world.color.y * s, this.world.color.z * s],
+            shadow: {
+                viewProj: SHADOW_CASCADES.map((_, i) => this.shadowLightVPMatrix.subarray(i * 16, i * 16 + 16)),
+                tiles: SHADOW_CASCADES.map((c) => [c.origin[0], c.origin[1]]),
+                tileSize: SHADOW_CASCADES[0].mapSize,
+                atlasSize: SHADOW_ATLAS_SIZE,
+                spheres: cascadeSpheres(this.shadowView, this.shadowSceneBounds).map((p) => ({
+                    center: [p.center.x, p.center.y, p.center.z],
+                    radius: p.radius,
+                })),
+            },
+            settings: this.nativeStage?.pkg.settings ?? null,
+        });
+        g.sim_TowardMatrix = towardMatrix(gameDir([view[2], view[6], view[10]]));
+        g._OutlineMaxOffsetMultiplier = outlineMaxOffsetMultiplier(this.canvas.width);
+        this.nativeGlobals = stableGlobals(this.nativeGlobals, g);
+        this.nativeHost?.beginFrame();
+        this.nativeShadowHost?.beginFrame();
+        looks?.prepare(encoder, this.nativeGlobals, 8, this.nativeFrameTextures());
+    }
     updateSkinMatrices() {
         this.forEachInstance((inst) => {
             // Only a pose pass can change these, and an idle stage did not run one —
@@ -16174,3 +16446,35 @@ Engine.CULL_MODEL_RIGID = 2;
 /** A cache key no material can collide with — a PMX name is never empty and
  *  never contains a NUL. */
 Engine.SEAM_KEY = "\u0000seams";
+/**
+ * This frame's Unity globals, keeping last frame's object for every value that
+ * did not change: the native host refills a uniform member only when its value
+ * object is new, so a light table or an SH that holds still costs nothing.
+ */
+function stableGlobals(prev, next) {
+    for (const k in next) {
+        const a = prev[k];
+        if (a !== undefined && sameValue(a, next[k]))
+            next[k] = a;
+    }
+    return next;
+}
+function sameValue(a, b) {
+    if (typeof a === "number" || typeof b === "number")
+        return a === b;
+    if (a.length !== b.length)
+        return false;
+    if (a instanceof Uint32Array !== b instanceof Uint32Array)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i];
+        const y = b[i];
+        if (typeof x === "number" || typeof y === "number") {
+            if (x !== y)
+                return false;
+        }
+        else if (!sameValue(x, y))
+            return false;
+    }
+    return true;
+}