reze-engine 0.63.0 → 0.65.0

package/dist/shaders/scene-light-api.js

@@ -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.
 //
@@ -49,30 +49,59 @@ 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, ts, 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, map, sampler, vp) => {
+    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
  * caster's shadow, soft in between.
@@ -80,12 +109,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
@@ -110,17 +138,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.
@@ -138,18 +158,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/dist/shadow-cascades.d.ts

@@ -1,34 +1,47 @@
+import { 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];
 };
+/**
+ * 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 declare const SHADOW_ATLAS_SIZE = 4096;
 export declare const SHADOW_CASCADES: readonly ShadowCascade[];
-/** 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 declare 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 declare 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
  *  view, aspect and clip planes, and how far away the thing it looks at is. */
@@ -70,6 +83,14 @@ type XYZ = {
     y: number;
     z: number;
 };
+/**
+ * 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 declare function cascadeSlices(view: ShadowView, bounds: ShadowBounds): [number, number][];
 /** The eight corners of a slice, for tests and for the fit's own checks. */
 export declare function sliceCorners(view: ShadowView, n: number, f: number): XYZ[];
@@ -83,6 +104,12 @@ export declare function sliceCorners(view: ShadowView, n: number, f: number): XY
  * Writes the 16 floats into `out` at `offset` and returns `out`.
  */
 export declare function fitShadowVP(view: ShadowView, slice: [number, number], sunDirection: XYZ, bounds: ShadowBounds, cascade: ShadowCascade, out: Float32Array, offset: number): Float32Array;
+/** Every cascade's bounding sphere (centre, radius), inner to outer — the
+ *  split spheres a game shader picks its cascade by (_CascadeShadowSplitSpheres). */
+export declare function cascadeSpheres(view: ShadowView, bounds: ShadowBounds): {
+    center: Vec3;
+    radius: number;
+}[];
 /** Every cascade's view-projection in a row, inner to outer. */
 export declare function buildShadowCascades(view: ShadowView, sunDirection: XYZ, bounds: ShadowBounds, out: Float32Array): Float32Array;
 export {};

package/dist/shadow-cascades.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadow-cascades.d.ts","sourceRoot":"","sources":["../src/shadow-cascades.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,SAAS,aAAa,EAA2C,CAAA;AAE/F;iFACiF;AACjF,eAAO,MAAM,UAAU,KAAK,CAAA;AAE5B;;+EAE+E;AAC/E,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACxC,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1C,EAAE,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACvC,OAAO,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC5C,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,2EAA2E;AAC3E,MAAM,MAAM,YAAY,GAAG;IAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CAAA;AAElG,KAAK,GAAG,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAY9C,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAqBxF;AAwBD,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAc1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,YAAY,EAAE,GAAG,EACjB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,YAAY,EACjB,MAAM,EAAE,MAAM,GACb,YAAY,CA0Cd;AAED,gEAAgE;AAChE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY,GAAG,YAAY,CAI9H"}
+{"version":3,"file":"shadow-cascades.d.ts","sourceRoot":"","sources":["../src/shadow-cascades.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,IAAI,EAAE,MAAM,QAAQ,CAAA;AAEnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAA;IACf,4EAA4E;IAC5E,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAIrC,eAAO,MAAM,eAAe,EAAE,SAAS,aAAa,EAGjD,CAAA;AAEH;;;iDAGiD;AACjD,eAAO,MAAM,UAAU,KAAK,CAAA;AAE5B;;+EAE+E;AAC/E,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACxC,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1C,EAAE,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACvC,OAAO,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC5C,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,2EAA2E;AAC3E,MAAM,MAAM,YAAY,GAAG;IAAE,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CAAA;AAElG,KAAK,GAAG,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAM9C;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAwBxF;AAwBD,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAc1E;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,YAAY,EAAE,GAAG,EACjB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,aAAa,EACtB,GAAG,EAAE,YAAY,EACjB,MAAM,EAAE,MAAM,GACb,YAAY,CA0Cd;AAED;qFACqF;AACrF,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,GAAG;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,CAEzG;AAED,gEAAgE;AAChE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY,GAAG,YAAY,CAI9H"}

package/dist/shadow-cascades.js

@@ -1,17 +1,32 @@
 import { Mat4, Vec3 } from "./math";
-export const SHADOW_CASCADES = [{ mapSize: 4096 }, { mapSize: 2048 }];
-/** 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;
 /**
- * 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.
+ * 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 = [0, 1, 2, 3].map((i) => ({
+    mapSize: TILE,
+    origin: [(i % 2) * TILE, Math.floor(i / 2) * TILE],
+}));
+/** 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 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, bounds) {
     let farFit = view.near + 200;
     if (bounds) {
@@ -28,11 +43,14 @@ export function cascadeSlices(view, bounds) {
     // 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 = [];
+    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
  *  balances the near and far rectangles' corners. */
@@ -113,6 +131,11 @@ export function fitShadowVP(view, slice, sunDirection, bounds, cascade, out, off
     out.set(proj.multiply(viewM).values, offset);
     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, bounds) {
+    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, sunDirection, bounds, out) {
     const slices = cascadeSlices(view, bounds);

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