reze-engine 0.63.0 → 0.65.0

package/src/shaders/scene-light-api.ts

@@ -1,4 +1,4 @@
-import { SHADOW_CASCADES } from "../shadow-cascades"
+import { SHADOW_ATLAS_SIZE, SHADOW_CASCADES } from "../shadow-cascades"
 // The scene's own light, as an effect author sees it: the sun's shadow and the
 // world's ambient.
 //
@@ -51,31 +51,61 @@ fn rzWorldAmbientAvg() -> vec3f {
 `
 
 /**
- * 3×3 PCF over one cascade's map, for a point already in that cascade's NDC.
+ * The sun's shadow atlas, as every reader looks it up: `<p>Locate(q)` finds
+ * world point q in the first cascade whose box holds it and answers
+ * (atlas uv, depth, cascade) — cascade -1 outside them all — and `<p>Taps(a)`
+ * is the 3×3 PCF at that place.
  *
- * Shared with the materials, so an effect's shadow and her own shadow soften
- * alike. The sampler is linear-filtered, which makes each tap a 2×2 bilinear
- * compare. Unrolled — Safari's Metal backend doesn't unroll nested shadow
- * loops reliably. The body expects `ndc` in scope and returns.
+ * ONE implementation for the materials, the ground and effects, so a blade of
+ * grass and her own skin go dark at the same edge. `vp` names the cascades'
+ * view-projection array in the module that includes it.
+ *
+ * The box test keeps a margin (SHADOW_MARGIN of the tile's half-width) so the
+ * whole filter stays inside the tile: a tap that crossed into the neighbouring
+ * tile would compare against another cascade's depths. The sampler is linear,
+ * so each tap is itself a 2×2 compare. Unrolled — Safari's Metal backend
+ * doesn't unroll nested shadow loops reliably.
  */
-export const pcf9 = (map: string, ts: string, sampler = "shadowSampler") => /* wgsl */ `
-  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
-  let cmpZ = ndc.z - 0.001;
-  let ts = ${ts};
-  let s00 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, -ts), cmpZ);
-  let s10 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0, -ts), cmpZ);
-  let s20 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, -ts), cmpZ);
-  let s01 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, 0.0), cmpZ);
-  let s11 = textureSampleCompareLevel(${map}, ${sampler}, suv, cmpZ);
-  let s21 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, 0.0), cmpZ);
-  let s02 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts,  ts), cmpZ);
-  let s12 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0,  ts), cmpZ);
-  let s22 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts,  ts), cmpZ);
+export const SHADOW_MARGIN = 0.98
+
+export const sunShadowWgsl = (p: string, map: string, sampler: string, vp: string) => {
+  const n = SHADOW_CASCADES.length
+  const tiles = SHADOW_CASCADES.map((c) => `vec2f(${c.origin[0] / SHADOW_ATLAS_SIZE}, ${c.origin[1] / SHADOW_ATLAS_SIZE})`).join(", ")
+  const scale = SHADOW_CASCADES[0].mapSize / SHADOW_ATLAS_SIZE
+  return /* wgsl */ `
+const ${p}Tiles = array<vec2f, ${n}>(${tiles});
+
+fn ${p}Locate(q: vec3f) -> vec4f {
+  for (var i = 0u; i < ${n}u; i++) {
+    let c = ${vp}[i] * vec4f(q, 1.0);
+    let ndc = c.xyz / max(c.w, 1e-6);
+    if (all(abs(ndc.xy) < vec2f(${SHADOW_MARGIN})) && ndc.z > 0.0 && ndc.z < 1.0) {
+      let uv = ${p}Tiles[i] + vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5) * ${scale};
+      return vec4f(uv, ndc.z, f32(i));
+    }
+  }
+  return vec4f(0.0, 0.0, 0.0, -1.0);
+}
+
+fn ${p}Taps(a: vec4f) -> f32 {
+  let cmpZ = a.z - 0.001;
+  let ts = ${1 / SHADOW_ATLAS_SIZE};
+  let s00 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(-ts, -ts), cmpZ);
+  let s10 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(0.0, -ts), cmpZ);
+  let s20 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f( ts, -ts), cmpZ);
+  let s01 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(-ts, 0.0), cmpZ);
+  let s11 = textureSampleCompareLevel(${map}, ${sampler}, a.xy, cmpZ);
+  let s21 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f( ts, 0.0), cmpZ);
+  let s02 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(-ts,  ts), cmpZ);
+  let s12 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(0.0,  ts), cmpZ);
+  let s22 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f( ts,  ts), cmpZ);
   return (s00 + s10 + s20 + s01 + s11 + s21 + s02 + s12 + s22) * (1.0 / 9.0);
+}
 `
+}
 
 /** Bindings the real accessors take, from `binding` upward. */
-export const SCENE_LIGHT_API_BINDINGS = 5
+export const SCENE_LIGHT_API_BINDINGS = 4
 
 /**
  * `rzShadow(p)`: how much of the sun reaches world point `p` — 1 lit, 0 in a
@@ -84,12 +114,11 @@ export const SCENE_LIGHT_API_BINDINGS = 5
  * `rzWorldAmbient(n)`: the world's light arriving at a surface facing `n` —
  * the materials' own ambient, so an effect's shade can match hers.
  *
- * With `on`, declares five bindings from `binding`:
+ * With `on`, declares four bindings from `binding`:
  *   +0 the light uniform (ambient, the sun — direction, and in .w the shadow
  *      switch — and the HDRI's irradiance)
  *   +1 the cascade view-projections, then the caster sphere
- *   +2 the near cascade's map   +3 the far cascade's map
- *   +4 the comparison sampler
+ *   +2 the sun's shadow atlas   +3 the comparison sampler
  *
  * It takes a POINT and no normal. The materials' sampleShadow also rejects a
  * surface facing away from the sun, which is right for skin and wrong for a
@@ -114,17 +143,9 @@ struct _RzSceneLightU { ambientColor: vec4f, lights: array<_RzSceneLight, 4>, sh
 struct _RzShadowBlock { viewProj: array<mat4x4f, ${n}>, casters: vec4f, }
 @group(${group}) @binding(${binding}) var<uniform> _rzLight: _RzSceneLightU;
 @group(${group}) @binding(${binding + 1}) var<uniform> _rzShadowVP: _RzShadowBlock;
-@group(${group}) @binding(${binding + 2}) var _rzShadowNear: texture_depth_2d;
-@group(${group}) @binding(${binding + 3}) var _rzShadowFar: texture_depth_2d;
-@group(${group}) @binding(${binding + 4}) var _rzShadowCmp: sampler_comparison;
-
-fn _rzShadowNearTaps(ndc: vec3f) -> f32 {
-${pcf9("_rzShadowNear", `1.0 / ${SHADOW_CASCADES[0].mapSize}.0`, "_rzShadowCmp")}
-}
-
-fn _rzShadowFarTaps(ndc: vec3f) -> f32 {
-${pcf9("_rzShadowFar", `1.0 / ${SHADOW_CASCADES[n - 1].mapSize}.0`, "_rzShadowCmp")}
-}
+@group(${group}) @binding(${binding + 2}) var _rzShadowAtlas: texture_depth_2d;
+@group(${group}) @binding(${binding + 3}) var _rzShadowCmp: sampler_comparison;
+${sunShadowWgsl("_rzSun", "_rzShadowAtlas", "_rzShadowCmp", "_rzShadowVP.viewProj")}
 
 fn rzShadow(p: vec3f) -> f32 {
   // The scene's one shadow switch, on the sun — see sampleShadow.
@@ -142,18 +163,10 @@ fn rzShadow(p: vec3f) -> f32 {
     let perp = length(toCaster - toSun * along);
     if (along <= -cs.w || perp > cs.w) { return 1.0; }
   }
-  let q = p + toSun * 0.08;
-  let c0 = _rzShadowVP.viewProj[0] * vec4f(q, 1.0);
-  let n0 = c0.xyz / max(c0.w, 1e-6);
-  if (all(abs(n0.xy) < vec2f(0.98)) && n0.z > 0.0 && n0.z < 1.0) {
-    return mix(1.0, _rzShadowNearTaps(n0), castAmt);
-  }
-  let c1 = _rzShadowVP.viewProj[${n - 1}] * vec4f(q, 1.0);
-  let n1 = c1.xyz / max(c1.w, 1e-6);
-  if (all(abs(n1.xy) < vec2f(0.98)) && n1.z > 0.0 && n1.z < 1.0) {
-    return mix(1.0, _rzShadowFarTaps(n1), castAmt);
-  }
-  return 1.0;
+  let a = _rzSunLocate(p + toSun * 0.08);
+  // Outside every cascade there is no occlusion information: lit.
+  if (a.w < 0.0) { return 1.0; }
+  return mix(1.0, _rzSunTaps(a), castAmt);
 }
 ${worldAmbientWgsl("_rzLight")}`
 }

package/src/shadow-cascades.ts

@@ -3,36 +3,54 @@ import { Mat4, Vec3 } from "./math"
 /**
  * THE SUN'S SHADOW FOLLOWS THE CAMERA, the way Blender's does.
  *
- * Each cascade is fitted every frame to a slice of the view frustum: the near
- * one to the stretch around what the camera is looking at, the far one to the
- * whole of what it sees. Whatever is in view is in a cascade, and whatever
- * could throw a shadow onto it is in the cascade's depth range, which is fitted
- * to the scene's bounds along the light. A room forty metres across with its
- * window frames behind the camera shadows its floor as the game does; a lone
- * dancer on an empty floor keeps a crisp near map.
+ * Each cascade is fitted every frame to a slice of the view frustum: the
+ * innermost to the stretch around what the camera is looking at, the
+ * outermost to the whole of what it sees, two more between. Whatever is in
+ * view is in a cascade, and whatever could throw a shadow onto it is in the
+ * cascade's depth range, which is fitted to the scene's bounds along the
+ * light. A room forty metres across with its window frames behind the camera
+ * shadows its floor as the game does; a lone dancer on an empty floor keeps a
+ * crisp inner tile.
  *
- * The earlier shape was two fixed boxes around the camera target, 64 and 256
- * units across, and a stage reached past them: the floor near the windows lay
- * outside every box and was drawn lit, the shadows stopping at the box's edge
- * in a straight line.
+ * The earlier shapes were two fixed boxes around the camera target, then two
+ * fitted maps; the game's pipeline draws four cascades into one atlas, and so
+ * does this.
  *
- * INVARIANT the sampler and the cull both lean on: the outer cascade CONTAINS
- * the inner one. The sampler falls from cascade 0 to 1 at the box edge, which
- * is only seamless if 1 covers where 0 ends, and the cull tests the OUTERMOST
- * frustum alone. Both hold because the outer slice is the whole frustum, of
- * which the inner slice is a part, and both take the same depth range.
+ * INVARIANT the sampler and the cull both lean on: each cascade CONTAINS the
+ * ones inside it. The sampler takes the first box that holds a point, which
+ * is only seamless if the next covers where one ends, and the cull tests the
+ * OUTERMOST frustum alone. Both hold because every slice starts at the near
+ * plane and the outermost is the whole frustum, and all take the same depth
+ * range.
  * tests/shadow-cascades.test.mjs pins it.
  */
 export type ShadowCascade = {
-  /** Texels per side of this cascade's map — sets the snap quantum. */
+  /** Texels per side of this cascade's tile — sets the snap quantum. */
   mapSize: number
+  /** Where the tile sits in the atlas, in texels from its top-left corner. */
+  origin: readonly [number, number]
 }
 
-export const SHADOW_CASCADES: readonly ShadowCascade[] = [{ mapSize: 4096 }, { mapSize: 2048 }]
+/**
+ * ONE ATLAS, FOUR TILES, as the game's pipeline (and URP) lays its sun shadow
+ * out: one depth texture, cascade i in tile (i mod 2, i div 2). One texture
+ * means one binding for every reader — materials, ground, effects, particles —
+ * and room in the same scheme for the local lights' shadows later.
+ */
+export const SHADOW_ATLAS_SIZE = 4096
+
+const TILE = SHADOW_ATLAS_SIZE / 2
+
+export const SHADOW_CASCADES: readonly ShadowCascade[] = [0, 1, 2, 3].map((i) => ({
+  mapSize: TILE,
+  origin: [(i % 2) * TILE, Math.floor(i / 2) * TILE] as const,
+}))
 
-/** How far past the camera's point of interest the near cascade reaches, in
- *  world units: the dancer and the floor around her, at the near map's texel. */
-export const NEAR_REACH = 40
+/** How far past the camera's point of interest the inner cascade reaches, in
+ *  world units: the dancer and the floor around her. Half the old two-map
+ *  reach, which keeps her texel where it was at half the tile; the three
+ *  outer cascades carry the rest of the room. */
+export const NEAR_REACH = 20
 
 /** The view the cascades are fitted to: the camera's eye and basis (world
  *  space, left-handed, +Z forward as the projection is), its vertical field of
@@ -55,16 +73,18 @@ export type ShadowBounds = { min: [number, number, number]; max: [number, number
 
 type XYZ = { x: number; y: number; z: number }
 
-/**
- * Where each cascade's slice of the view starts and ends, as distances along
- * the view: [near, split] and [near, farFit]. The far end is where the scene
- * ends, so an empty floor with a dancer on it keeps a short, sharp frustum
- * rather than the camera's far plane.
- */
 /** The deepest a cascade reaches along the view, in world units — the far
  *  plane's old cap, which is where every stage's shadows were fitted before. */
 const SHADOW_FAR = 8000
 
+/**
+ * Where each cascade's slice of the view starts and ends, as distances along
+ * the view, inner to outer: every slice starts at the near plane and they
+ * nest, the innermost ending just past the point of interest and the
+ * outermost where the scene ends, the two between spaced evenly in ratio.
+ * Nested rather than abutting so the invariant above holds: the outermost
+ * box contains all of them, and the sampler takes the first that holds a point.
+ */
 export function cascadeSlices(view: ShadowView, bounds: ShadowBounds): [number, number][] {
   let farFit = view.near + 200
   if (bounds) {
@@ -81,11 +101,14 @@ export function cascadeSlices(view: ShadowView, bounds: ShadowBounds): [number,
   // a kilometre out is in the scene's bounds, and fitting the far cascade to it
   // would spread the stage's shadow map across the sky.
   farFit = Math.min(view.far, SHADOW_FAR, Math.max(view.near + 1, farFit))
-  const split = Math.min(farFit, Math.max(view.near + 8, view.focus + NEAR_REACH))
-  return [
-    [view.near, split],
-    [view.near, farFit],
-  ]
+  const first = Math.min(farFit, Math.max(view.near + 8, view.focus + NEAR_REACH))
+  const n = SHADOW_CASCADES.length
+  const out: [number, number][] = []
+  for (let i = 0; i < n; i++) {
+    const end = i === n - 1 ? farFit : first * Math.pow(farFit / first, i / (n - 1))
+    out.push([view.near, end])
+  }
+  return out
 }
 
 /** The bounding sphere of a frustum slice: on the view axis, at the depth that
@@ -188,6 +211,12 @@ export function fitShadowVP(
   return out
 }
 
+/** Every cascade's bounding sphere (centre, radius), inner to outer — the
+ *  split spheres a game shader picks its cascade by (_CascadeShadowSplitSpheres). */
+export function cascadeSpheres(view: ShadowView, bounds: ShadowBounds): { center: Vec3; radius: number }[] {
+  return cascadeSlices(view, bounds).map(([n, f]) => sliceSphere(view, n, f))
+}
+
 /** Every cascade's view-projection in a row, inner to outer. */
 export function buildShadowCascades(view: ShadowView, sunDirection: XYZ, bounds: ShadowBounds, out: Float32Array): Float32Array {
   const slices = cascadeSlices(view, bounds)

package/src/unity/character.ts

@@ -0,0 +1,169 @@
+// 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 type { NativeValue } from "./host"
+import { gameToEngine, invert4, mul4 } from "./globals"
+
+/** 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]
+}
+
+const srgbToLinear = (c: number) => (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: [number, number, number],
+  equator: [number, number, number],
+  ground: [number, number, number],
+): number[][] {
+  const out: number[][] = []
+  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: number[][]): Record<string, number[]> {
+  const ch = ["r", "g", "b"]
+  const o: Record<string, number[]> = {}
+  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: [number, number, number]): Float32Array {
+  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: number): number {
+  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: CharacterRig,
+  head: ArrayLike<number> | null,
+  headRest: [number, number, number],
+  scale: number,
+): Record<string, NativeValue> {
+  const o: Record<string, NativeValue> = {}
+  // _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
+}