reze-engine 0.63.0 → 0.64.0

package/dist/unity/character.d.ts

@@ -0,0 +1,59 @@
+import type { NativeValue } from "./host";
+/** A game character's CharacterEffect values, as its prefab serialises them. */
+export type CharacterRig = {
+    localLightInclination: number;
+    localLightAzimuth: number;
+    localLightIntensity: number;
+    localLightColor: [number, number, number, number];
+    faceReceiveShadow: boolean;
+    disableFaceSDFShadow: boolean;
+    emissionColor: [number, number, number, number];
+    fillOuter: [number, number, number, number];
+    fillInner: [number, number, number, number];
+    fillColor: [number, number, number, number];
+    fillRatio: number;
+    rimlightColor: [number, number, number, number];
+    rimlightThreshold: number;
+    rimlightFade: number;
+    rimlightRange: number;
+    rimlightInclination: number;
+    rimlightAzimuth1: number;
+    rimlightAzimuth2: number;
+    characterLayer: number;
+    /** EnvironmentEffect's trilight, sRGB as serialised. */
+    skyColor: [number, number, number];
+    equatorColor: [number, number, number];
+    groundColor: [number, number, number];
+};
+/**
+ * Unity's ambient probe of a trilight (RenderSettings.ambientProbe in Trilight
+ * mode), measured in Unity 6 rather than derived: the colours are taken to
+ * linear, then
+ *   c0 = (S + 4E + G) / 6        c1 = (√6 / 9)(S − G)
+ *   c6 = (5/192)(2E − S − G)     c8 = (5/64)(2E − S − G)
+ * and every other coefficient is zero — Unity's raw coefficients, which its
+ * shader constants pack as SHA = (c3, c1, c2, c0 − c6), SHB = (c4, c5, 3c6, c7),
+ * SHC = c8. Checked against the game's recorded block for (0.8, 0.5, 0.3).
+ */
+export declare function trilightProbe(sky: [number, number, number], equator: [number, number, number], ground: [number, number, number]): number[][];
+/** Unity's shader constants from raw coefficients (channel, index). */
+export declare function probeConstants(c: number[][]): Record<string, number[]>;
+/**
+ * sim_TowardMatrix (LightingFeatures.SetupTowardMatrix): the frame the
+ * character light is expressed in — the camera's backward direction flattened
+ * to the ground, as columns (up × d, up, d). Taken immediately, as the DLC
+ * poster sets CameraExtension.shadowRotationImmediately.
+ */
+export declare function towardMatrix(cameraForward: [number, number, number]): Float32Array;
+/** CharacterGlobalParams.Execute: the outline's resolution allowance. */
+export declare function outlineMaxOffsetMultiplier(pixelWidth: number): number;
+/**
+ * The character's property block (CharacterEffect.LateUpdate with the default
+ * look: no dissolve, dither, interference), by name.
+ *
+ * `head` is the head bone's skinning matrix (its pose relative to the bind
+ * pose, engine units) and `headRest` its rest position; `scale` engine units
+ * per game unit.
+ */
+export declare function characterBlock(rig: CharacterRig, head: ArrayLike<number> | null, headRest: [number, number, number], scale: number): Record<string, NativeValue>;
+//# sourceMappingURL=character.d.ts.map

package/dist/unity/character.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character.d.ts","sourceRoot":"","sources":["../../src/unity/character.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAGzC,gFAAgF;AAChF,MAAM,MAAM,YAAY,GAAG;IACzB,qBAAqB,EAAE,MAAM,CAAA;IAC7B,iBAAiB,EAAE,MAAM,CAAA;IACzB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACjD,iBAAiB,EAAE,OAAO,CAAA;IAC1B,oBAAoB,EAAE,OAAO,CAAA;IAC7B,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/C,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/C,iBAAiB,EAAE,MAAM,CAAA;IACzB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;IACxB,gBAAgB,EAAE,MAAM,CAAA;IACxB,cAAc,EAAE,MAAM,CAAA;IACtB,wDAAwD;IACxD,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACtC,CAAA;AAID;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7B,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACjC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAC/B,MAAM,EAAE,EAAE,CAUZ;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAUtE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAMlF;AAED,yEAAyE;AACzE,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,EAC9B,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAClC,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CA+C7B"}

package/dist/unity/character.js

@@ -0,0 +1,120 @@
+// The game's per-character shading inputs, for a model wearing its character
+// shaders.
+//
+// In the game a CharacterEffect component (P08.RenderPipeline, ported in
+// ag-rip's charfx/CharacterEffect.cs from the decompiled GameAssembly.dll)
+// writes one property block shared by all of a character's renderers: its own
+// key light, expressed in a camera-facing frame (_LocalLightDir in
+// sim_TowardMatrix, LightingFeatures.SetupTowardMatrix); its face frame for the
+// SDF face shadow (_World2Face); its rim lights; its fills; and an ambient of
+// its own from three colours (EnvironmentEffect). Nothing here is per scene:
+// it is the character's look, carried by the character.
+//
+// An MMD model has no CharacterEffect. It takes a CharacterRig — the values a
+// game character's prefab carries, exported with the look — and the frames
+// come from its own bones: the face is the head bone turned to face the way
+// the game's faces do (the game's face node rests aligned with the world,
+// looking +Z; a PMX model looks −Z, so a half turn about Y).
+import { gameToEngine, invert4, mul4 } from "./globals";
+const srgbToLinear = (c) => (c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4));
+/**
+ * Unity's ambient probe of a trilight (RenderSettings.ambientProbe in Trilight
+ * mode), measured in Unity 6 rather than derived: the colours are taken to
+ * linear, then
+ *   c0 = (S + 4E + G) / 6        c1 = (√6 / 9)(S − G)
+ *   c6 = (5/192)(2E − S − G)     c8 = (5/64)(2E − S − G)
+ * and every other coefficient is zero — Unity's raw coefficients, which its
+ * shader constants pack as SHA = (c3, c1, c2, c0 − c6), SHB = (c4, c5, 3c6, c7),
+ * SHC = c8. Checked against the game's recorded block for (0.8, 0.5, 0.3).
+ */
+export function trilightProbe(sky, equator, ground) {
+    const out = [];
+    for (let k = 0; k < 3; k++) {
+        const S = srgbToLinear(sky[k]), E = srgbToLinear(equator[k]), G = srgbToLinear(ground[k]);
+        const ring = 2 * E - S - G;
+        out.push([(S + 4 * E + G) / 6, (Math.sqrt(6) / 9) * (S - G), 0, 0, 0, 0, (5 / 192) * ring, 0, (5 / 64) * ring]);
+    }
+    return out;
+}
+/** Unity's shader constants from raw coefficients (channel, index). */
+export function probeConstants(c) {
+    const ch = ["r", "g", "b"];
+    const o = {};
+    for (let k = 0; k < 3; k++) {
+        const s = c[k];
+        o[`SHA${ch[k]}`] = [s[3], s[1], s[2], s[0] - s[6]];
+        o[`SHB${ch[k]}`] = [s[4], s[5], s[6] * 3, s[7]];
+    }
+    o.SHC = [c[0][8], c[1][8], c[2][8], 1];
+    return o;
+}
+/**
+ * sim_TowardMatrix (LightingFeatures.SetupTowardMatrix): the frame the
+ * character light is expressed in — the camera's backward direction flattened
+ * to the ground, as columns (up × d, up, d). Taken immediately, as the DLC
+ * poster sets CameraExtension.shadowRotationImmediately.
+ */
+export function towardMatrix(cameraForward) {
+    const x = -cameraForward[0], z = -cameraForward[2];
+    const len = Math.hypot(x, z);
+    const d = len > 1e-5 ? [x / len, 0, z / len] : [0, 0, 0];
+    return Float32Array.from([d[2], 0, -d[0], 0, 0, 1, 0, 0, d[0], d[1], d[2], 0, 0, 0, 0, 1]);
+}
+/** CharacterGlobalParams.Execute: the outline's resolution allowance. */
+export function outlineMaxOffsetMultiplier(pixelWidth) {
+    return Math.max(pixelWidth / 768 - 1, 0);
+}
+/**
+ * The character's property block (CharacterEffect.LateUpdate with the default
+ * look: no dissolve, dither, interference), by name.
+ *
+ * `head` is the head bone's skinning matrix (its pose relative to the bind
+ * pose, engine units) and `headRest` its rest position; `scale` engine units
+ * per game unit.
+ */
+export function characterBlock(rig, head, headRest, scale) {
+    const o = {};
+    // _World2Face: the face frame's world-to-local, in game units. The face is
+    // the head's pose applied to a frame at the head's rest position looking −Z.
+    const faceRest = Float32Array.from([-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, headRest[0], headRest[1], headRest[2], 1]);
+    const face = head ? mul4(head, faceRest) : faceRest;
+    o._World2Face = mul4(invert4(face), gameToEngine(scale));
+    o._ExtralEmissionColor = rig.emissionColor;
+    let inner = rig.fillInner, outer = rig.fillOuter;
+    inner = [inner[0], inner[1], inner[2], inner[3] * rig.fillRatio];
+    outer = [outer[0], outer[1], outer[2], outer[3] * rig.fillRatio];
+    o._FillOuter = outer;
+    o._FillInner = inner;
+    o._FillClamp = 0;
+    o._FillSoft = 0;
+    o._DissolveFactor = 0;
+    // inclination about the horizon, azimuth negated — float math as the game's
+    const incl = (rig.localLightInclination * Math.PI) / 180;
+    const az = (-rig.localLightAzimuth * Math.PI) / 180;
+    const c = Math.cos(incl);
+    o._LocalLightDir = [Math.sin(az) * -c, Math.sin(incl), Math.cos(az) * c, 0];
+    const k = rig.localLightIntensity;
+    o._LocalLightColor = [rig.localLightColor[0] * k, rig.localLightColor[1] * k, rig.localLightColor[2] * k, rig.localLightColor[3] * k];
+    o._UseFaceReceiveShadow = rig.faceReceiveShadow ? 1 : 0;
+    o._DisableFaceSDFShadow = rig.disableFaceSDFShadow ? 1 : 0;
+    o._RimlightColor = rig.rimlightColor;
+    o._RimlightThreshold = rig.rimlightThreshold;
+    o._RimlightFade = rig.rimlightFade;
+    o._RimlightRange = rig.rimlightRange;
+    const zr = rig.rimlightInclination;
+    const sr = Math.sqrt(1 - zr * zr);
+    const a1 = rig.rimlightAzimuth1 * Math.PI, a2 = rig.rimlightAzimuth2 * Math.PI;
+    o._RimlightDir1 = [Math.cos(a1) * sr, Math.sin(a1) * sr, zr, 0];
+    o._RimlightDir2 = [Math.cos(a2) * sr, Math.sin(a2) * sr, zr, 0];
+    o._ZOffset_Unit = rig.characterLayer;
+    o._DitherAlpha = 1;
+    // EnvironmentEffect: the character's own ambient, in both names it is read by
+    const sh = probeConstants(trilightProbe(rig.skyColor, rig.equatorColor, rig.groundColor));
+    for (const [n, v] of Object.entries(sh)) {
+        o[`unity_${n}`] = v;
+        o[`_Replica_${n}`] = v;
+    }
+    // CharacterEffect.OnEnable: every character renderer on rendering layer 0x40000001
+    o.unity_RenderingLayer = new Uint32Array([0x40000001, 0, 0, 0]);
+    return o;
+}

package/dist/unity/globals.d.ts

@@ -0,0 +1,93 @@
+import type { NativeValue } from "./host";
+export type Mat4Like = ArrayLike<number>;
+export type UnityLight = {
+    /** World position, engine units. */
+    position: [number, number, number];
+    /** Reach, engine units. */
+    radius: number;
+    /** Linear colour times intensity. */
+    color: [number, number, number];
+    /** Unit aim, away from the light; zero for a point light. */
+    aim: [number, number, number];
+    cosOuter: number;
+    cosInner: number;
+    /** Rendering-layer bits it reaches. */
+    layers: number;
+    /** What the game's pipeline packs beside a light it lit with, when the light
+     *  came from a game stage (stage_native.py): spot direction with w = 1 /
+     *  its sphere's radius (the area term reads it), colour alpha, Extra,
+     *  WorldToLight and type — all in the game's world, used as they are. */
+    unity?: {
+        spotDir: number[];
+        colorW: number;
+        extra: number[];
+        worldToLight: number[] | null;
+        lightType: number;
+        simSpotDir?: number[] | null;
+        simColorW?: number;
+    };
+};
+export type UnityFrameInput = {
+    /** Engine units per game unit. */
+    scale: number;
+    view: Mat4Like;
+    proj: Mat4Like;
+    eye: [number, number, number];
+    near: number;
+    far: number;
+    width: number;
+    height: number;
+    /** Scene clock and its step, seconds. */
+    time: number;
+    dt: number;
+    /** The direction the main light travels, unit; null for none. */
+    sunDirection: [number, number, number] | null;
+    sunColor: [number, number, number];
+    sunShadow: number;
+    lights: UnityLight[];
+    /** Ambient as the engine's folded SH9 (27 floats, ibl.ts), or null for flat. */
+    ambientSH: ArrayLike<number> | null;
+    ambientFlat: [number, number, number];
+    /** The cascades as the engine drew them: render view-projections (engine
+     *  units, the atlas's own depth convention), their tiles, and the spheres
+     *  they were fitted to. */
+    shadow: {
+        viewProj: Mat4Like[];
+        tiles: [number, number][];
+        tileSize: number;
+        atlasSize: number;
+        spheres: {
+            center: [number, number, number];
+            radius: number;
+        }[];
+    } | null;
+    /** What a loaded game stage sets for its scene (stage.ts): fog, tint, ambient
+     *  SH, the environment cube's numbers — the pipeline's per-scene globals, in
+     *  place of the defaults below. Never camera, time, lights or shadows. */
+    settings?: Record<string, NativeValue> | null;
+};
+/** Column-major 4x4 multiply. */
+export declare function mul4(a: Mat4Like, b: Mat4Like): Float32Array;
+export declare function invert4(m: Mat4Like): Float32Array;
+/** Game world -> engine world: `s` PMX per unit, half a turn about Y. */
+export declare function gameToEngine(s: number): Float32Array;
+/** Engine world -> game world. */
+export declare function engineToGame(s: number): Float32Array;
+/** An engine point in the game's world. */
+export declare function gamePoint(p: ArrayLike<number>, s: number): [number, number, number];
+/** An engine direction in the game's world. */
+export declare function gameDir(d: ArrayLike<number>): [number, number, number];
+/** Uniform scale, as a column-major matrix. */
+export declare function scale4(s: number): Float32Array;
+/** The projection with clip y negated — undone by naga's own negation. */
+export declare function flipY(p: Mat4Like): Float32Array;
+/**
+ * The engine's folded SH9 (ibl.ts: c0 + c1·y + c2·z + c3·x + c4·xy + c5·yz +
+ * c6·(3z²−1) + c7·xz + c8·(x²−y²)) as Unity's seven shader constants —
+ * SHA = (x, y, z, constant), SHB = (xy, yz, z², zx), SHC = (x²−y²) — the same
+ * polynomial, regrouped.
+ */
+export declare function unitySH(sh: ArrayLike<number> | null, flat: [number, number, number]): Record<string, number[]>;
+/** Everything the frame sets, by name. */
+export declare function unityFrameGlobals(f: UnityFrameInput): Record<string, NativeValue>;
+//# sourceMappingURL=globals.d.ts.map

package/dist/unity/globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../../src/unity/globals.ts"],"names":[],"mappings":"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"}

package/dist/unity/globals.js

@@ -0,0 +1,340 @@
+// The game pipeline's per-frame globals, computed from the engine's scene.
+//
+// The game's shaders read what its render pipeline (UnityEngine.Rendering.
+// Replica / ReplicaExt, decompiled from GameAssembly.dll) sets before a camera
+// renders: the camera, the main light, the Forward+ light table and its bins,
+// the cascades, the ambient SH, fog, time. ag-rip's AGSimPipeline.cs and
+// AGSimShadows.cs reproduce those calls in Unity, method by method, and the
+// compare page proved them against the game's frames; this is that code again,
+// fed by the engine instead of by a Unity scene.
+//
+// SPACE. The game's shaders work in the game's world, and the engine's scene
+// is that world as ag-rip exports it to MMD: `scale` PMX units per game unit
+// (8: the one-scene-scale rule) and turned half round Y — game (x, y, z) is
+// PMX (-x, y, -z), the convention its camera and motion VMDs and its stages
+// share. Everything positional is handed over through that map (gameToEngine
+// and back) — the camera, the lights and their reach, the cascades — so a
+// shader's distances (outline widths, light ranges, fog) and directions mean
+// what they meant in the game. A half turn keeps handedness: both are
+// left-handed and Y-up.
+//
+// CLIP SPACE. naga negates y on the way out of every vertex shader (Vulkan to
+// WebGPU), so the projection handed to the shaders is the engine's with y
+// flipped: the two flips cancel and a native draw lands exactly where the
+// engine's own draw of the same triangle would, on the same depth.
+const PLUS_MAX = 255;
+/** Column-major 4x4 multiply. */
+export function mul4(a, b) {
+    const o = new Float32Array(16);
+    for (let c = 0; c < 4; c++)
+        for (let r = 0; r < 4; r++) {
+            let s = 0;
+            for (let k = 0; k < 4; k++)
+                s += a[k * 4 + r] * b[c * 4 + k];
+            o[c * 4 + r] = s;
+        }
+    return o;
+}
+export function invert4(m) {
+    const a = m;
+    const o = new Float32Array(16);
+    const a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3], a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7];
+    const a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11], a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+    const b00 = a00 * a11 - a01 * a10, b01 = a00 * a12 - a02 * a10, b02 = a00 * a13 - a03 * a10;
+    const b03 = a01 * a12 - a02 * a11, b04 = a01 * a13 - a03 * a11, b05 = a02 * a13 - a03 * a12;
+    const b06 = a20 * a31 - a21 * a30, b07 = a20 * a32 - a22 * a30, b08 = a20 * a33 - a23 * a30;
+    const b09 = a21 * a32 - a22 * a31, b10 = a21 * a33 - a23 * a31, b11 = a22 * a33 - a23 * a32;
+    let det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+    if (!det)
+        return Float32Array.from([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+    det = 1 / det;
+    o[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+    o[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+    o[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+    o[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+    o[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+    o[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+    o[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+    o[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+    o[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+    o[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+    o[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+    o[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+    o[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+    o[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+    o[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+    o[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
+    return o;
+}
+/** Game world -> engine world: `s` PMX per unit, half a turn about Y. */
+export function gameToEngine(s) {
+    return Float32Array.from([-s, 0, 0, 0, 0, s, 0, 0, 0, 0, -s, 0, 0, 0, 0, 1]);
+}
+/** Engine world -> game world. */
+export function engineToGame(s) {
+    return Float32Array.from([-1 / s, 0, 0, 0, 0, 1 / s, 0, 0, 0, 0, -1 / s, 0, 0, 0, 0, 1]);
+}
+/** An engine point in the game's world. */
+export function gamePoint(p, s) {
+    return [-p[0] / s, p[1] / s, -p[2] / s];
+}
+/** An engine direction in the game's world. */
+export function gameDir(d) {
+    return [-d[0], d[1], -d[2]];
+}
+/** Uniform scale, as a column-major matrix. */
+export function scale4(s) {
+    return Float32Array.from([s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1]);
+}
+/** The projection with clip y negated — undone by naga's own negation. */
+export function flipY(p) {
+    const o = Float32Array.from(p);
+    for (let c = 0; c < 4; c++)
+        o[c * 4 + 1] = -p[c * 4 + 1];
+    return o;
+}
+/**
+ * The engine's folded SH9 (ibl.ts: c0 + c1·y + c2·z + c3·x + c4·xy + c5·yz +
+ * c6·(3z²−1) + c7·xz + c8·(x²−y²)) as Unity's seven shader constants —
+ * SHA = (x, y, z, constant), SHB = (xy, yz, z², zx), SHC = (x²−y²) — the same
+ * polynomial, regrouped.
+ */
+export function unitySH(sh, flat) {
+    const out = {};
+    const ch = ["r", "g", "b"];
+    const c = (i, k) => (sh ? sh[i * 3 + k] : i === 0 ? flat[k] : 0);
+    for (let k = 0; k < 3; k++) {
+        out[`_Replica_SHA${ch[k]}`] = [c(3, k), c(1, k), c(2, k), c(0, k) - c(6, k)];
+        out[`_Replica_SHB${ch[k]}`] = [c(4, k), c(5, k), 3 * c(6, k), c(7, k)];
+    }
+    out._Replica_SHC = [c(8, 0), c(8, 1), c(8, 2), 1];
+    return out;
+}
+/** Everything the frame sets, by name. */
+export function unityFrameGlobals(f) {
+    const s = f.scale;
+    const g = {};
+    // ---- the camera (UnityPerFrame), in game units
+    // Unity's own pair, so what a shader rebuilds from them means what it did
+    // in the game: the view in game units, right-handed and looking down -Z;
+    // the projection on game-unit depths (the engine's, conjugated by the scale
+    // and the z flip, and divided through by s, which leaves the same NDC). Their
+    // product puts every vertex exactly where the engine's own draw of it lands.
+    const zFlip = Float32Array.from([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]);
+    const view = mul4(zFlip, mul4(scale4(1 / s), mul4(f.view, gameToEngine(s))));
+    const toEngineView = mul4(scale4(s), zFlip);
+    const proj = flipY(mul4(f.proj, toEngineView));
+    for (let i = 0; i < 16; i++)
+        proj[i] /= s;
+    const vp = mul4(proj, view);
+    const w = Math.max(1, f.width);
+    const h = Math.max(1, f.height);
+    const near = f.near / s;
+    const far = f.far / s;
+    g._WorldSpaceCameraPos = [...gamePoint(f.eye, s), 1];
+    g.unity_MatrixV = view;
+    g.unity_MatrixInvV = invert4(view);
+    g.unity_MatrixP = proj;
+    g.glstate_matrix_projection = proj;
+    g.unity_MatrixVP = vp;
+    g._NonJitteredViewProjMatrix = vp;
+    // x = -1: a flipped projection, as Unity's into a texture.
+    g._ProjectionParams = [-1, near, far, 1 / far];
+    g._ScreenParams = [w, h, 1 + 1 / w, 1 + 1 / h];
+    g._ScaledScreenParams = [w, h, 1 + 1 / w, 1 + 1 / h];
+    g._ZBufferParams = [-1 + far / near, 1, (-1 + far / near) / far, 1 / far];
+    g.unity_OrthoParams = [0, 0, 0, 0];
+    const t = f.time;
+    g._Time = [t / 20, t, t * 2, t * 3];
+    g._SinTime = [Math.sin(t / 8), Math.sin(t / 4), Math.sin(t / 2), Math.sin(t)];
+    g._CosTime = [Math.cos(t / 8), Math.cos(t / 4), Math.cos(t / 2), Math.cos(t)];
+    const dt = Math.max(f.dt, 1e-4);
+    g.unity_DeltaTime = [dt, 1 / dt, dt, 1 / dt];
+    // UpdateRenderSettings: sim_Time = (t - floor t, floor t)
+    g.sim_Time = [t - Math.floor(t), Math.floor(t), 0, 0];
+    g.identity_matrix = scale4(1);
+    // ---- LightingFeatures.SetupLightings / PlusLighting SetupMainLightConstants
+    if (f.sunDirection) {
+        const d = gameDir(f.sunDirection);
+        g.SimMainLightDir = [-d[0], -d[1], -d[2], 0];
+        g.SimMainLightColor = [...f.sunColor, 1];
+        g.SimMainLightColorNoInt = [...f.sunColor, 1];
+        // As the game's pipeline leaves it (recorded): the way the light travels.
+        g._MainLightPosition = [d[0], d[1], d[2], 0];
+        g.sim_ShadowLightDirection = [-d[0], -d[1], -d[2], 0];
+        g._MainLightColor = [...f.sunColor, 1];
+    }
+    else {
+        g.SimMainLightDir = [0, 0, 0, 0];
+        g.SimMainLightColor = [0, 0, 0, 0];
+        g.SimMainLightColorNoInt = [0, 0, 0, 0];
+        g._MainLightPosition = [0, 1, 0, 0];
+        g._MainLightColor = [0, 0, 0, 0];
+    }
+    // ---- ForwardFeature.SetupRenderFeature, UpdateRenderSettings: a scene
+    // with no stage of the game's has no settings of its own — the defaults the
+    // game's SceneSetting starts from.
+    g.SimSceneTint = [1, 1, 1, 1];
+    g._ReceiveSceneShadow = 1;
+    g.sim_FogRotation = 0;
+    g.sim_FogInverseRootRotationMatrix = scale4(1);
+    g.sim_FogColor = [0, 0, 0, 0];
+    g.sim_FogColor2 = [0, 0, 0, 0];
+    g.sim_FogParams = [0, 1, 0, 1];
+    g.sim_FogDirectionalColor = [0, 0, 0, 0];
+    g.sim_FogDirectionalDir = [0, 0, 1, 0];
+    g.sim_FogDirectionalFalloff = 0;
+    g.sim_DYN_FOG_LINEAR_Variable = 0;
+    g.sim_DynFogColor = [0, 0, 0, 0];
+    g.sim_DynFogParams = [0, 1, 0, 1];
+    g._ProbeLightingBase = [1, 1, 1, 1];
+    g._ProbeLightingScale = 0;
+    g._AcceptLightProbe = 0;
+    g.sim_VertexAmbientScale = 1;
+    g._EnableShadowScatter = 0;
+    g._ShadowScatterColor = [0, 0, 0, 0];
+    g._ShadowScatterRange = 0;
+    // realtimeShadowColor's default grey, made linear (ConvertSRGBToActiveColorSpace)
+    g._SubtractiveShadowColor = [0.2158605, 0.2158605, 0.2158605, 1];
+    g._AmbientOcclusionParam = [0, 0, 0, 0];
+    g.sim_EnvCubeScale = 0;
+    g.sim_EnvCube_BoxMin = [0, 0, 0, 0];
+    g.sim_EnvCube_BoxMax = [0, 0, 0, 0];
+    g.sim_EnvCube_ProbePosition = [0, 0, 0, 0];
+    // ---- SetupEnvironmentLighting: the scene's ambient SH
+    // The half turn negates x and z: the terms odd in either (z, x, xy, yz) flip.
+    const sh = f.ambientSH ? Array.from(f.ambientSH) : null;
+    if (sh)
+        for (const i of [2, 3, 4, 5])
+            for (let k = 0; k < 3; k++)
+                sh[i * 3 + k] = -sh[i * 3 + k];
+    Object.assign(g, unitySH(sh, f.ambientFlat));
+    // ---- a game stage's own settings over all of the above
+    if (f.settings)
+        Object.assign(g, f.settings);
+    // ---- PlusLightingFeature: the light table, one tile and one depth bin
+    // holding every light (binning only culls; the shader applies each range)
+    const n = Math.min(f.lights.length, PLUS_MAX);
+    const pos = [], col = [], att = [], dir = [];
+    const extra = [], w2l = [];
+    const simDir = [], simColorW = [];
+    const types = new Float32Array(PLUS_MAX);
+    const masks = new Uint32Array(PLUS_MAX);
+    const ident = scale4(1);
+    for (let i = 0; i < PLUS_MAX; i++) {
+        const l = f.lights[i];
+        if (i >= n || !l) {
+            pos.push([0, 0, 0, 0]);
+            col.push([0, 0, 0, 0]);
+            att.push([0, 1, 0, 1]);
+            dir.push([0, 0, 0, 0]);
+            extra.push([0, 0, 0, 0]);
+            w2l.push(ident);
+            continue;
+        }
+        const spot = l.aim[0] !== 0 || l.aim[1] !== 0 || l.aim[2] !== 0;
+        const r = l.radius / s;
+        const r2 = r * r;
+        // LightInfo.GetPunctualLightDistanceAttenuation / GetSpotAngleAttenuation
+        let z = 0;
+        let ww = 1;
+        if (spot) {
+            const inv = 1 / Math.max(l.cosInner - l.cosOuter, 0.001);
+            z = inv;
+            ww = -l.cosOuter * inv;
+        }
+        pos.push([...gamePoint(l.position, s), 1]);
+        // The engine's lamp brightness is per its own unit; the inverse square in
+        // game units is s² larger at the same place, so the colour carries 1/s².
+        col.push([l.color[0] / (s * s), l.color[1] / (s * s), l.color[2] / (s * s), 1]);
+        att.push([1 / Math.max(r2, 1e-4), -r2 / (r2 * 0.64 - r2), z, ww]);
+        const u = l.unity;
+        if (u) {
+            col[col.length - 1][3] = u.colorW;
+            dir.push(u.spotDir.slice(0, 4));
+            extra.push(u.extra.slice(0, 4));
+            w2l.push(u.worldToLight ? Float32Array.from(u.worldToLight) : ident);
+            simDir.push((u.simSpotDir ?? u.spotDir).slice(0, 4));
+            simColorW.push(u.simColorW ?? 1);
+            types[i] = u.lightType;
+        }
+        else {
+            // The pipeline's own defaults for a light it did not author: forward
+            // along the aim, w = 1 / the 0.1 sphere every game lamp of these stages has.
+            const a = gameDir(l.aim);
+            dir.push(spot ? [...a, 10] : [0, 0, 1, 10]);
+            extra.push([0, 0, 0, 0]);
+            w2l.push(ident);
+            simDir.push(spot ? [...a, 10] : [0, 0, 1, 10]);
+            simColorW.push(1);
+            types[i] = spot ? 0 : 2;
+        }
+        masks[i] = l.layers >>> 0;
+    }
+    g._AdditionalLightsPosition = pos;
+    g._AdditionalLightsColor = col;
+    g._AdditionalLightsAttenuation = att;
+    g._AdditionalLightsSpotDir = dir;
+    g._AdditionalLightsExtra = extra;
+    g._AdditionalLightsWorldToLights = w2l;
+    g._AdditionalLightsLightTypes = types;
+    g._AdditionalLightsLayerMasks = masks;
+    g._AdditionalLightsCookieEnableBits = new Float32Array(8);
+    const words = Math.max(1, Math.ceil(n / 32));
+    const zb = new Uint32Array(4096);
+    const tiles = new Uint32Array(16384);
+    zb[0] = n > 0 ? ((n - 1) << 16) >>> 0 : 0xffff;
+    for (let k = 0; k < words; k++) {
+        const bits = Math.min(Math.max(n - k * 32, 0), 32);
+        const m = bits >= 32 ? 0xffffffff : ((1 << bits) >>> 0) - 1;
+        zb[1 + k] = m >>> 0;
+        tiles[k] = m >>> 0;
+    }
+    // LightingFeatures' own copy for the per-vertex lights: the first 16, colour
+    // without the intensity in w.
+    g.SimAdditionalLightPosition = pos.slice(0, 16);
+    g.SimAdditionalLightColor = col
+        .slice(0, 16)
+        .map((c, i) => (c[0] || c[1] || c[2] ? [c[0], c[1], c[2], simColorW[i] ?? 1] : [0, 0, 0, 0]));
+    g.SimAdditionalLightAttenuation = att.slice(0, 16);
+    g.SimAdditionalLightSpotDir = simDir.slice(0, 16).concat(dir.slice(simDir.length, 16));
+    g._PlusLighting_ZBins = zb;
+    g._PlusLighting_Tiles = tiles;
+    g._PlusLightingParams0 = [0, 0, 1, words];
+    g._PlusLightingParams1 = [1000, 0, 0, 0];
+    // ---- the main light's cascades, sampled from the engine's atlas
+    if (f.shadow) {
+        const sh = f.shadow;
+        const unit = sh.tileSize / sh.atlasSize;
+        const w2s = [];
+        for (let i = 0; i < 4; i++) {
+            const vpe = sh.viewProj[i];
+            const tile = sh.tiles[i];
+            if (!vpe || !tile) {
+                w2s.push(scale4(0));
+                continue;
+            }
+            // ndc -> the tile's uv (y down, as the atlas is addressed), depth as drawn
+            const tx = tile[0] / sh.atlasSize;
+            const ty = tile[1] / sh.atlasSize;
+            const toTile = Float32Array.from([0.5 * unit, 0, 0, 0, 0, -0.5 * unit, 0, 0, 0, 0, 1, 0, 0.5 * unit + tx, 0.5 * unit + ty, 0, 1]);
+            w2s.push(mul4(toTile, mul4(vpe, gameToEngine(s))));
+        }
+        g._MainLightWorldToShadow = w2s;
+        for (let i = 0; i < 4; i++) {
+            const sp = sh.spheres[i];
+            g[`_CascadeShadowSplitSpheres${i}`] = sp ? [...gamePoint(sp.center, s), sp.radius / s] : [0, 0, 0, 0];
+        }
+        const r = (i) => (sh.spheres[i] ? (sh.spheres[i].radius / s) ** 2 : 0);
+        g._CascadeShadowSplitSphereRadii = [r(0), r(1), r(2), r(3)];
+        const half = 0.5 / sh.atlasSize;
+        g._MainLightShadowOffset0 = [-half, -half, half, -half];
+        g._MainLightShadowOffset1 = [-half, half, half, half];
+        g._MainLightShadowmapSize = [1 / sh.atlasSize, 1 / sh.atlasSize, sh.atlasSize, sh.atlasSize];
+        g._MainLightShadowParams = [f.sunShadow, 1, 0, 0];
+    }
+    else {
+        g._MainLightShadowParams = [0, 0, 0, 0];
+    }
+    return g;
+}