reze-engine 0.62.1 → 0.64.0

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
+}