reze-engine 0.63.0 → 0.65.0

package/src/shaders/passes/composite.ts

@@ -13,7 +13,7 @@ import { castDistanceApi, CAST_FIELD_DIV } from "./cast-distance"
 import { lyricsApi, lyricsTextApi } from "../lyrics-api"
 import { midiApi } from "../midi-api"
 import { gridReadApi } from "./grid"
-// Composite: HDR scene + bloom pyramid → Filmic tone map → gamma → swapchain.
+// Composite: HDR scene + bloom → view transform (soft / neutral / aces / none) → gamma → swapchain.
 // Bloom tint/intensity applied at combine (EEVEE treats them as combine-stage params, not prefilter).
 //
 // The shader is a TEMPLATE: buildCompositeShader() emits either the base pass or
@@ -138,14 +138,6 @@ override APPLY_GAMMA: bool = true;
 // re-premultiply the tonemapped color for output so the premultiplied canvas
 // alphaMode composites the WebGPU surface over the page background correctly.
 @group(0) @binding(4) var maskTex: texture_2d<f32>;
-// Filmic tone curve baked to a WIDTH×1 r16float LUT (bakeFilmicLut on the CPU side).
-// Domain: log2(linear) mapped to [0,13]. Replaces the old array<f32,14> that was indexed
-// by a runtime u32 (a Metal-backend smell — dynamic local-array indexing lowers to a
-// per-invocation copy/switch) and interpolated piecewise-linearly (C0, so segment slope
-// discontinuities showed as Mach bands in smooth skin/shadow gradients). The LUT is a
-// monotone-cubic (Fritsch–Carlson) fit through the same 14 anchors — same values, C1
-// continuity kills the banding — sampled with hardware linear filtering.
-@group(0) @binding(5) var filmicLut: texture_2d<f32>;
 // viewU[0] = (exposure, invGamma, grain amount, grain seed);  viewU[1] = (tint.rgb, intensity)
 // viewU[2] = (background.rgb, mode) — display-space sRGB, composited UNDER the
 //            scene post-tonemap. BASE-layer mode: 0 transparent (DOM shows),
@@ -177,9 +169,6 @@ override APPLY_GAMMA: bool = true;
 //           track the camera radius. Cleared depth (1.0) inverts to the far
 //           plane, so empty sky reads as maximally defocused background.
 @group(0) @binding(9) var<uniform> dofU: array<vec4<f32>, 3>;
-// Blender's AgX, as the 57³ lookup it ships as rather than a reconstruction of
-// it. Sampled in the log-encoded E-Gamut space the cube expects — see agxTransform.
-@group(0) @binding(10) var agxLut: texture_3d<f32>;
 // The scene's own colour grade, as a cube — see _rzStageGrade. sRGB-encoded
 // storage, so what a sample returns is already linear.
 @group(0) @binding(12) var stageGradeLut: texture_3d<f32>;
@@ -215,8 +204,6 @@ override APPLY_GAMMA: bool = true;
 fn rzFieldMerge(top: vec4f, bot: vec4f) -> vec4f {
   return vec4f(top.rgb + bot.rgb * (1.0 - top.a), top.a + bot.a * (1.0 - top.a));
 }
-// Must match FILMIC_LUT_WIDTH in engine.ts (bakeFilmicLut).
-const FILMIC_LUT_W: f32 = 256.0;
 
 fn linearDepth(coord: vec2<i32>) -> f32 {
   let z = textureLoad(depthTex, coord, 0);
@@ -249,67 +236,138 @@ fn sceneSample(coord: vec2<i32>, fullSzI: vec2<i32>, fullSz: vec2f) -> vec4f {
   return vec4f((sHdr + sBloom) * sAlpha, sAlpha);
 }
 
-fn filmic(x: f32) -> f32 {
-  // Reference checkpoints (Blender 3.6 Filmic MHC, sobotka/filmic-blender
-  // look_medium-high-contrast.spi1d): linear 0.18 → ~0.395, linear 1.0 → ~0.83.
-  // NOTE: version-pinned to Blender 3.6 — 4.x defaults to AgX, not Filmic.
-  let t = clamp(log2(max(x, 1e-10)) + 10.0, 0.0, 13.0);
-  // Map t∈[0,13] to the texel-center of baked sample j = t·(W-1)/13.
-  let u = (t * (FILMIC_LUT_W - 1.0) / 13.0 + 0.5) / FILMIC_LUT_W;
-  // textureSampleLevel (explicit LOD, no derivatives) is legal in non-uniform flow.
-  return textureSampleLevel(filmicLut, bloomSamp, vec2f(u, 0.5), 0.0).r;
-}
-
-/** The sRGB display encoding — Blender's "Standard" view transform, which is what
- *  NPR work uses: no film curve at all, so the colours a graph computes are the
- *  colours that land. Not a 2.2 power law; sRGB has a linear toe. */
+/** The sRGB display encoding — "none": no tone curve at all, so the colours a
+ *  graph computes are the colours that land. Not a 2.2 power law; sRGB has a
+ *  linear toe. Every transform below ends in it. */
 fn srgb_encode(x: f32) -> f32 {
   let c = max(x, 0.0);
   return select(1.055 * pow(c, 1.0 / 2.4) - 0.055, c * 12.92, c <= 0.0031308);
 }
 
 /**
- * AgX, the chain config.ocio states for "AgX Base Rec.1886" on an sRGB display:
- *
- *   scene-linear Rec.709 → 3x3 into FilmLight E-Gamut
- *   → log2 across 25 stops, [-12.47393, +12.5261] → 0..1
- *   → the 57³ cube
- *   → Rec.1886 (pure γ2.4) decoded, then re-encoded as sRGB for the swapchain
- *
- * The last step is not pedantry: Rec.1886 is a pure power law and sRGB has a
- * linear toe, so skipping it lifts the darkest few code values.
- *
- * Blender interpolates the cube tetrahedrally and a GPU sampler is trilinear.
- * The difference is small and confined to saturated gradients; if it ever shows,
- * tetrahedral is a dozen lines here.
+ * "soft" — Aether Gazer's own curve, from its final pass
+ * (Hidden/SimPipeline/Final, decompiled): (1 - e^(-exposure x))^contrast, at the
+ * 2.5 and 1.4 its scenes set, into a linear target the swapchain then encodes.
+ * The game's ACES branch is off in every scene measured.
+ */
+fn softTransform(c: vec3f) -> vec3f {
+  let t = pow(max(vec3f(1.0) - exp(-2.5 * max(c, vec3f(0.0))), vec3f(0.0)), vec3f(1.4));
+  return vec3f(srgb_encode(t.r), srgb_encode(t.g), srgb_encode(t.b));
+}
+
+fn _rzSrgbEncode3(c: vec3f) -> vec3f {
+  return vec3f(srgb_encode(c.r), srgb_encode(c.g), srgb_encode(c.b));
+}
+
+/**
+ * "neutral" — Unity URP's Neutral tonemapper as the Khronos PBR Neutral
+ * operator, to the published formula: below the start of compression colour
+ * passes through (less a small toe offset); above it the peak rolls off toward
+ * 1 and desaturates in proportion to how much it lost.
  */
-fn agxTransform(c: vec3f) -> vec3f {
-  let m = mat3x3<f32>(
-    vec3f(0.55937113, 0.07622071, 0.06552670),
-    vec3f(0.30478326, 0.78797183, 0.16454675),
-    vec3f(0.13584556, 0.13580748, 0.76992653),
-  );
-  let e = m * max(c, vec3f(0.0));
-  // The cube's domain: an unlit pixel would take log2 to -inf, so floor it at
-  // the bottom stop rather than sampling outside the LUT.
-  let t = clamp((log2(max(e, vec3f(1e-10))) + vec3f(12.47393)) / 25.0, vec3f(0.0), vec3f(1.0));
-  // Half-texel inset, so the end stops are the cube's own values and not a blend
-  // with the clamp-to-edge border.
-  let n = 57.0;
-  let uvw = t * ((n - 1.0) / n) + (0.5 / n);
-  let formed = textureSampleLevel(agxLut, bloomSamp, uvw, 0.0).rgb;
-  let linear = pow(max(formed, vec3f(0.0)), vec3f(2.4));
-  return vec3f(srgb_encode(linear.r), srgb_encode(linear.g), srgb_encode(linear.b));
+fn neutralTransform(color: vec3f) -> vec3f {
+  let startCompression = 0.8 - 0.04;
+  let desaturation = 0.15;
+  var c = max(color, vec3f(0.0));
+  let x = min(c.r, min(c.g, c.b));
+  let offset = select(0.04, x - 6.25 * x * x, x < 0.08);
+  c = c - vec3f(offset);
+  let peak = max(c.r, max(c.g, c.b));
+  if (peak >= startCompression) {
+    let d = 1.0 - startCompression;
+    let newPeak = 1.0 - d * d / (peak + d - startCompression);
+    c = c * (newPeak / peak);
+    let g = 1.0 - 1.0 / (desaturation * (peak - newPeak) + 1.0);
+    c = mix(c, vec3f(newPeak), g);
+  }
+  return _rzSrgbEncode3(clamp(c, vec3f(0.0), vec3f(1.0)));
+}
+
+// "aces" — Unity URP's ACES: unity_to_ACES then AcesTonemap, both from the Core
+// RP's Color.hlsl (the branch URP compiles, not full ACES): the RRT's glow and
+// red modifier and global desaturation, the luminance fit of RRT +
+// ODT.Academy.RGBmonitor_100nits_dim, the dim-surround gamma, the ODT
+// desaturation, then AP1 → XYZ → D60→D65 → Rec.709, saturated as URP's
+// ApplyTonemap does. HLSL's row-major matrices are written as rows here.
+fn _rzRows(r0: vec3f, r1: vec3f, r2: vec3f, v: vec3f) -> vec3f {
+  return vec3f(dot(r0, v), dot(r1, v), dot(r2, v));
+}
+fn _rzAp1ToXyz(v: vec3f) -> vec3f {
+  return _rzRows(vec3f(0.6624541811, 0.1340042065, 0.1561876870),
+                 vec3f(0.2722287168, 0.6740817658, 0.0536895174),
+                 vec3f(-0.0055746495, 0.0040607335, 1.0103391003), v);
+}
+fn _rzAp1Luma(v: vec3f) -> f32 {
+  return dot(v, vec3f(0.272229, 0.674082, 0.0536895));
+}
+fn acesTransform(color: vec3f) -> vec3f {
+  // unity_to_ACES: linear sRGB → AP0.
+  var aces = _rzRows(vec3f(0.4397010, 0.3829780, 0.1773350),
+                     vec3f(0.0897923, 0.8134230, 0.0967616),
+                     vec3f(0.0175440, 0.1115440, 0.8707040), max(color, vec3f(0.0)));
+  // Glow module.
+  let mi = min(aces.r, min(aces.g, aces.b));
+  let ma = max(aces.r, max(aces.g, aces.b));
+  let saturation = (max(ma, 1e-4) - max(mi, 1e-4)) / max(ma, 1e-2);
+  let k = max(aces.b * (aces.b - aces.g) + aces.g * (aces.g - aces.r) + aces.r * (aces.r - aces.b), 0.0);
+  let ycIn = (aces.b + aces.g + aces.r + 1.75 * sqrt(k)) / 3.0;
+  let sx = (saturation - 0.4) / 0.2;
+  let st = max(1.0 - abs(sx / 2.0), 0.0);
+  let s = (1.0 + select(-1.0, 1.0, sx >= 0.0) * (1.0 - st * st)) / 2.0;
+  let glowGain = 0.05 * s;
+  let glowMid = 0.08;
+  var glow = glowGain * (glowMid / max(ycIn, 1e-6) - 0.5);
+  if (ycIn <= 2.0 / 3.0 * glowMid) { glow = glowGain; }
+  if (ycIn >= 2.0 * glowMid) { glow = 0.0; }
+  aces = aces * (1.0 + glow);
+  // Red modifier.
+  var hue = 0.0;
+  if (!(aces.r == aces.g && aces.g == aces.b)) {
+    hue = degrees(atan2(sqrt(3.0) * (aces.g - aces.b), 2.0 * aces.r - aces.g - aces.b));
+  }
+  if (hue < 0.0) { hue = hue + 360.0; }
+  var centered = hue;
+  if (centered < -180.0) { centered = centered + 360.0; } else if (centered > 180.0) { centered = centered - 360.0; }
+  var hueWeight = smoothstep(0.0, 1.0, 1.0 - abs(2.0 * centered / 135.0));
+  hueWeight = hueWeight * hueWeight;
+  aces.r = aces.r + hueWeight * saturation * (0.03 - aces.r) * (1.0 - 0.82);
+  // AP0 → AP1 (ACEScg), then the RRT's global desaturation.
+  var cg = max(_rzRows(vec3f(1.4514393161, -0.2365107469, -0.2149285693),
+                       vec3f(-0.0765537734, 1.1762296998, -0.0996759264),
+                       vec3f(0.0083161484, -0.0060324498, 0.9977163014), aces), vec3f(0.0));
+  cg = mix(vec3f(_rzAp1Luma(cg)), cg, vec3f(0.96));
+  // The luminance fit of RRT + ODT.Academy.RGBmonitor_100nits_dim.
+  let post = (cg * (2.785085 * cg + 0.107772)) / (cg * (2.936045 * cg + 0.887122) + 0.806889);
+  // Dark → dim surround: Y^0.9811, in xyY.
+  var xyz = _rzAp1ToXyz(post);
+  let div = max(xyz.x + xyz.y + xyz.z, 1e-4);
+  let xyY = vec3f(xyz.x / div, xyz.y / div, pow(clamp(xyz.y, 0.0, 65504.0), 0.9811));
+  let m = xyY.z / max(xyY.y, 1e-4);
+  xyz = vec3f(xyY.x * m, xyY.z, (1.0 - xyY.x - xyY.y) * m);
+  var lin = _rzRows(vec3f(1.6410233797, -0.3248032942, -0.2364246952),
+                    vec3f(-0.6636628587, 1.6153315917, 0.0167563477),
+                    vec3f(0.0117218943, -0.0082844420, 0.9883948585), xyz);
+  // The ODT's desaturation, then to the display's primaries.
+  lin = mix(vec3f(_rzAp1Luma(lin)), lin, vec3f(0.93));
+  xyz = _rzRows(vec3f(0.98722400, -0.00611327, 0.0159533),
+                vec3f(-0.00759836, 1.00186000, 0.0053302),
+                vec3f(0.00307257, -0.00509595, 1.0816800), _rzAp1ToXyz(lin));
+  let rec709 = _rzRows(vec3f(3.2409699419, -1.5373831776, -0.4986107603),
+                       vec3f(-0.9692436363, 1.8759675015, 0.0415550574),
+                       vec3f(0.0556300797, -0.2039769589, 1.0569715142), xyz);
+  return _rzSrgbEncode3(clamp(rec709, vec3f(0.0), vec3f(1.0)));
 }
 
-/** Which display transform, chosen per frame at viewU[6].y (0 filmic, 1 standard, 2 agx).
- *  A uniform branch rather than a pipeline variant: switching is rare, and both
- *  arms are cheap enough that specialising the pipeline would buy nothing. */
+/** Which display transform, chosen per frame at viewU[6].y (0 soft, 1 none,
+ *  2 neutral, 3 aces). A uniform branch rather than a pipeline variant: switching
+ *  is rare, and every arm is cheap enough that specialising the pipeline would
+ *  buy nothing. */
 fn viewTransform(c: vec3f) -> vec3f {
   let mode = viewU[6].y;
-  if (mode > 1.5) { return agxTransform(c); }
-  if (mode > 0.5) { return vec3f(srgb_encode(c.r), srgb_encode(c.g), srgb_encode(c.b)); }
-  return vec3f(filmic(c.r), filmic(c.g), filmic(c.b));
+  if (mode > 2.5) { return acesTransform(c); }
+  if (mode > 1.5) { return neutralTransform(c); }
+  if (mode > 0.5) { return _rzSrgbEncode3(c); }
+  return softTransform(c);
 }
 
 fn _rzSrgbDecode(x: f32) -> f32 {

package/src/shaders/passes/cull.ts

@@ -130,10 +130,14 @@ fn cs(@builtin(global_invocation_id) gid: vec3<u32>) {
   // a hidden material is not culled, it is switched off, and answering "is this
   // gone because of culling?" requires the two to stay separable.
   let off = frusta.counts.y == 0u;
-  let shown = hidden[i] == 0u;
+  // hidden: bit 0 switched off; bit 1 drawn by the native-material host
+  // (unity/host.ts) rather than by its graph — no camera or mirror draw here,
+  // and still its shadow, which the engine's pass casts for every material.
+  let shown = (hidden[i] & 1u) == 0u;
+  let graph = (hidden[i] & 2u) == 0u;
   let castsShadow = (dm.flags & DRAW_CASTS_SHADOW) != 0u;
-  cameraArgs[i * 5u + 1u] = select(0u, 1u, (inCamera || off) && shown);
+  cameraArgs[i * 5u + 1u] = select(0u, 1u, (inCamera || off) && shown && graph);
   shadowArgs[i * 5u + 1u] = select(0u, 1u, ((inLight && castsShadow) || off) && shown);
-  mirrorArgs[i * 5u + 1u] = select(0u, 1u, (inMirror || off) && shown);
+  mirrorArgs[i * 5u + 1u] = select(0u, 1u, (inMirror || off) && shown && graph);
 }
 `

package/src/shaders/passes/ground.ts

@@ -1,6 +1,7 @@
 import { sceneFsOutWgsl, sceneIdWriteWgsl } from "./scene-contract"
 import { lightsApi } from "../lights"
-import { SHADOW_CASCADES } from "../../shadow-cascades"
+import { SHADOW_ATLAS_SIZE, SHADOW_CASCADES } from "../../shadow-cascades"
+import { SHADOW_MARGIN } from "../scene-light-api"
 import { WORLD_AMBIENT_WGSL } from "../lights"
 
 // Ground shadow-catcher: receives directional shadow, grid lines, frosted noise,
@@ -36,6 +37,9 @@ const SOFT_MAX_SPREAD = 14
  * normalised, so there is no `/ 9.0` left at the call site.
  */
 function pcfWgsl(map: string, uv: string, texel: string, z: string, acc: string, pad: string, soft: boolean): string {
+  // Every tap stays inside the cascade's own tile (tileLo..tileHi, in scope at
+  // the call): the soft disk reaches further than the selection margin, and a
+  // tap in the neighbouring tile compares against another cascade's depths.
   const golden = 2.39996323
   // ONE BRANCH IS COMPILED, NOT BOTH.
   //
@@ -58,7 +62,7 @@ function pcfWgsl(map: string, uv: string, texel: string, z: string, acc: string,
     `  for (var x = -1; x <= 1; x++) {`,
     // ...Level, not the implicit-derivative form: identical on a single-mip
     // shadow map, and legal inside a branch.
-    `    ${acc} += textureSampleCompareLevel(${map}, shadowSampler, ${uv} + vec2f(f32(x), f32(y)) * st, ${z});`,
+    `    ${acc} += textureSampleCompareLevel(${map}, shadowSampler, clamp(${uv} + vec2f(f32(x), f32(y)) * st, tileLo, tileHi), ${z});`,
     `  }`,
     `}`,
     `${acc} *= ${1 / 9};`,
@@ -71,7 +75,7 @@ function pcfWgsl(map: string, uv: string, texel: string, z: string, acc: string,
     // keeps successive taps from lining up into spokes.
     `  let r = sqrt((fs + 0.5) * ${1 / SOFT_TAPS});`,
     `  let a = fs * ${golden} + rot;`,
-    `  ${acc} += textureSampleCompareLevel(${map}, shadowSampler, ${uv} + vec2f(cos(a), sin(a)) * (r * radius), ${z});`,
+    `  ${acc} += textureSampleCompareLevel(${map}, shadowSampler, clamp(${uv} + vec2f(cos(a), sin(a)) * (r * radius), tileLo, tileHi), ${z});`,
     `}`,
     `${acc} *= ${1 / SOFT_TAPS};`,
   ]
@@ -89,12 +93,10 @@ struct Light { direction: vec4f, color: vec4f, };
 struct LightUniforms { ambientColor: vec4f, lights: array<Light, 4>, sh: array<vec4f, 9>, };
 struct GroundShadowMat {
   diffuseColor: vec3f, fadeStart: f32,
-  fadeEnd: f32, shadowStrength: f32, pcfTexel: f32, gridSpacing: f32,
+  fadeEnd: f32, shadowStrength: f32, _pad6: f32, gridSpacing: f32,
   gridLineWidth: f32, gridLineOpacity: f32, noiseStrength: f32, opacity: f32,
   gridLineColor: vec3f, mirror: f32,
-  // farCascade: 1 while a stage is loaded, 0 otherwise. See the branch below —
-  // with no stage the far map is never drawn into, so its taps are known.
-  mirrorBlur: f32, farCascade: f32, shadowSoftness: f32, groundY: f32,
+  mirrorBlur: f32, _pad17: f32, shadowSoftness: f32, groundY: f32,
   // Every shadow caster in one sphere, refreshed per frame. w = radius; 0 means
   // nothing casts, negative means "do not use this" (a rigid caster has no
   // sphere, so a scene with a stage keeps the taps). See rzShadowPossible.
@@ -105,12 +107,11 @@ struct GroundShadowMat {
 struct LightVP { viewProj: array<mat4x4f, ${SHADOW_CASCADES.length}>, };
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
 @group(0) @binding(1) var<uniform> light: LightUniforms;
-@group(0) @binding(2) var shadowMap: texture_depth_2d;
+// The sun's shadow atlas — see shadow-cascades.ts.
+@group(0) @binding(2) var shadowAtlas: texture_depth_2d;
 @group(0) @binding(3) var shadowSampler: sampler_comparison;
 @group(0) @binding(4) var<uniform> material: GroundShadowMat;
 @group(0) @binding(5) var<uniform> lightVP: LightVP;
-// The far cascade's map, binding 7 as in the materials' layout.
-@group(0) @binding(7) var shadowMapFar: texture_depth_2d;
 // The floor mirror (step 7D): the reflection target, the camera that rendered
 // it, and an ordinary sampler — the two shadow bindings above are comparison.
 // params = (projA, projB, _, _) — the depth-linearisation pair of the SHARED
@@ -144,7 +145,7 @@ struct MirrorVP { viewProj: mat4x4f, params: vec4f, };
 struct MirrorClip { plane: vec4f, on: f32, _p0: f32, _p1: f32, _p2: f32, };
 @group(0) @binding(14) var<uniform> clip: MirrorClip;
 ${WORLD_AMBIENT_WGSL}
-${lightsApi(0, 6)}
+${lightsApi(0, 6, "1u")}
 
 struct VO { @builtin(position) position: vec4f, @location(0) worldPos: vec3f, @location(1) normal: vec3f, };
 @vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f) -> VO {
@@ -178,21 +179,6 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
     return out;
   }
 
-  // Outside a cascade's frustum there IS no shadow information — the clamped
-  // border samples compare against unrelated depths and read "shadowed",
-  // darkening the whole far plane with a visible band at the frustum edge
-  // (masked by the opaque surface normally, glaring in green-screen mode where
-  // only the shadow-catcher term renders). So each cascade fades out near its
-  // border — the near one INTO the far one's answer, the far one into lit.
-  let l0 = lightVP.viewProj[0] * vec4f(i.worldPos, 1.0);
-  let ndc = l0.xyz / max(l0.w, 1e-6);
-  let inZ = select(0.0, 1.0, ndc.z > 0.0 && ndc.z < 1.0);
-  let frustum = (1.0 - smoothstep(0.88, 0.96, abs(ndc.x))) * (1.0 - smoothstep(0.88, 0.96, abs(ndc.y))) * inZ;
-  let l1 = lightVP.viewProj[1] * vec4f(i.worldPos, 1.0);
-  let ndc1 = l1.xyz / max(l1.w, 1e-6);
-  let inZ1 = select(0.0, 1.0, ndc1.z > 0.0 && ndc1.z < 1.0);
-  let frustum1 = (1.0 - smoothstep(0.88, 0.96, abs(ndc1.x))) * (1.0 - smoothstep(0.88, 0.96, abs(ndc1.y))) * inZ1;
-
   // THE cost of this shader, measured: a full-screen ground ran 25 shadow
   // comparisons per pixel, and each one is hardware-bilinear, so ~100 depth
   // samples per pixel. Gutting the rest of the shader changed nothing; cutting
@@ -201,11 +187,9 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   // 3x3 at two-texel spacing covers the same +/-2 texel penumbra the 5x5 at
   // one-texel spacing did — that kernel was oversampled, its taps overlapping
   // almost entirely once the comparison sampler's own 2x2 filter is counted.
-  // Nine taps instead of twenty-five for the same blur radius.
+  // Nine taps instead of twenty-five for the same blur radius, and one
+  // cascade's worth per pixel: the first that holds it.
   //
-  // The far cascade's taps run ONLY where the near one is fading or absent
-  // (frustum < 1), so a pixel in the near core costs exactly what it did with
-  // one cascade — and that core is where the camera usually looks.
   // Can anything cast a shadow ONTO this point at all?
   //
   // The ground is vastly larger than what stands on it, and the answer for most
@@ -261,33 +245,26 @@ ${
   let rot = ign * 6.28318530718;`
       : ""
   }
-  // The far cascade's taps, skipped entirely when nothing ever drew into it.
-  //
-  // This branch is the expensive one on a wide floor: it runs wherever the NEAR
-  // cascade does not reach, and the near cascade is a 64-unit box around the
-  // camera target, so a floor receding to the horizon takes it almost
-  // everywhere. Nine comparison taps, per pixel, on the largest draw in the
-  // frame — against a map that is cleared unless a stage is in the scene.
-  //
-  // Cleared depth compares as "no occluder", so the skipped path leaves vis at
-  // 1.0, which is exactly what the taps returned. Free, not cheaper.
-  if (material.farCascade > 0.0 && frustum < 1.0 && frustum1 > 0.0) {
-    let suv1 = vec2f(ndc1.x * 0.5 + 0.5, 0.5 - ndc1.y * 0.5);
-    let suv1_c = clamp(suv1, vec2f(0.02), vec2f(0.98));
-    let compareZ1 = ndc1.z - 0.0035;
-    var acc1 = 0.0;
-${pcfWgsl("shadowMapFar", "suv1_c", `${1 / SHADOW_CASCADES[SHADOW_CASCADES.length - 1].mapSize}`, "compareZ1", "acc1", "    ", soft)}
-    vis = mix(1.0, acc1, frustum1);
-  }
-  if (frustum > 0.0) {
-    let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
-    let suv_c = clamp(suv, vec2f(0.02), vec2f(0.98));
+  // The first cascade whose box holds the point, as the materials pick it.
+  // Outside a cascade's box there IS no shadow information — the clamped
+  // border samples compare against unrelated depths and read "shadowed",
+  // darkening the far floor with a band at the edge — so the outermost one
+  // fades into lit near its border. Inner cascades hand over to the next.
+  let n = ${SHADOW_CASCADES.length}u;
+  for (var ci = 0u; ci < n; ci++) {
+    let lc = lightVP.viewProj[ci] * vec4f(i.worldPos, 1.0);
+    let ndc = lc.xyz / max(lc.w, 1e-6);
+    if (!(all(abs(ndc.xy) < vec2f(${SHADOW_MARGIN})) && ndc.z > 0.0 && ndc.z < 1.0)) { continue; }
+    let frustum = select(1.0, (1.0 - smoothstep(0.88, 0.96, abs(ndc.x))) * (1.0 - smoothstep(0.88, 0.96, abs(ndc.y))), ci == n - 1u);
+    let tile = vec2f(f32(ci % 2u), f32(ci / 2u)) * ${SHADOW_CASCADES[0].mapSize / SHADOW_ATLAS_SIZE};
+    let tileLo = tile + vec2f(${0.5 / SHADOW_ATLAS_SIZE});
+    let tileHi = tile + vec2f(${(SHADOW_CASCADES[0].mapSize - 0.5) / SHADOW_ATLAS_SIZE});
+    let suv = tile + vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5) * ${SHADOW_CASCADES[0].mapSize / SHADOW_ATLAS_SIZE};
     let compareZ = ndc.z - 0.0035;
     var acc = 0.0;
-${pcfWgsl("shadowMap", "suv_c", "material.pcfTexel", "compareZ", "acc", "    ", soft)}
-    // The base is whatever the far cascade decided, so the near border blends
-    // cascade to cascade rather than snapping to lit mid-floor.
-    vis = mix(vis, acc, frustum);
+${pcfWgsl("shadowAtlas", "suv", `${1 / SHADOW_ATLAS_SIZE}`, "compareZ", "acc", "    ", soft)}
+    vis = mix(1.0, acc, frustum);
+    break;
   }
   }
 

package/src/shaders/passes/mirror.ts

@@ -218,20 +218,52 @@ ${sceneIdPadWgsl("out")}
 }
 
 /**
- * The mirror in the SHADOW pass — the frame throwing shade on the floor.
- *
- * Its own shader because the mirror has no vertex buffer and no skeleton: the
- * quad is six generated vertices and the model matrix is the whole of it, while
- * the ordinary shadow shader is built for skinned geometry with an alpha test.
- *
- * Depth only, no fragment stage. The pane is opaque across its whole rectangle
- * — glass included, because this glass is not see-through — so there is nothing
- * to alpha-test and nothing to colour.
- *
- * The cascade index arrives in its own tiny uniform rather than as a dynamic
- * offset: the cascade matrices sit 64 bytes apart in one array, and a dynamic
- * uniform offset has to be 256-aligned.
+ * Downsample for the reflection's COLOUR chain, one pass per mip level: the
+ * Jimenez/COD 13-tap dual box — five weighted 2x2 averages, which rejects the
+ * nyquist ringing a plain box would leave in a blurred reflection.
  */
+export const MIRROR_DOWNSAMPLE_WGSL = /* wgsl */ `
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
+  let x = f32((vi & 1u) << 2u) - 1.0;
+  let y = f32((vi & 2u) << 1u) - 1.0;
+  return vec4f(x, y, 0.0, 1.0);
+}
+
+@group(0) @binding(0) var srcTex: texture_2d<f32>;
+@group(0) @binding(1) var srcSamp: sampler;
+
+fn samp(uv: vec2f, off: vec2f) -> vec3f {
+  return textureSampleLevel(srcTex, srcSamp, uv + off, 0.0).rgb;
+}
+
+@fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {
+  let srcDims = vec2f(textureDimensions(srcTex));
+  let t = 1.0 / srcDims;
+  // fragCoord.xy reports pixel centers (e.g. 0.5,0.5 for first pixel) — divide by dst dims directly.
+  let dstDims = srcDims * 0.5;
+  let uv = p.xy / max(dstDims, vec2f(1.0));
+  let A = samp(uv, t * vec2f(-2.0, -2.0));
+  let B = samp(uv, t * vec2f( 0.0, -2.0));
+  let C = samp(uv, t * vec2f( 2.0, -2.0));
+  let D = samp(uv, t * vec2f(-1.0, -1.0));
+  let E = samp(uv, t * vec2f( 1.0, -1.0));
+  let F = samp(uv, t * vec2f(-2.0,  0.0));
+  let G = samp(uv, t * vec2f( 0.0,  0.0));
+  let H = samp(uv, t * vec2f( 2.0,  0.0));
+  let I = samp(uv, t * vec2f(-1.0,  1.0));
+  let J = samp(uv, t * vec2f( 1.0,  1.0));
+  let K = samp(uv, t * vec2f(-2.0,  2.0));
+  let L = samp(uv, t * vec2f( 0.0,  2.0));
+  let M = samp(uv, t * vec2f( 2.0,  2.0));
+  var o = (D + E + I + J) * (0.5 / 4.0);
+  o = o + (A + B + G + F) * (0.125 / 4.0);
+  o = o + (B + C + H + G) * (0.125 / 4.0);
+  o = o + (F + G + L + K) * (0.125 / 4.0);
+  o = o + (G + H + M + L) * (0.125 / 4.0);
+  return vec4f(o, 1.0);
+}
+`
+
 /**
  * Downsample for the reflection's COVERAGE chain.
  *
@@ -263,6 +295,21 @@ struct VSOut { @builtin(position) pos: vec4f, @location(0) uv: vec2f, };
 }
 `
 
+/**
+ * The mirror in the SHADOW pass — the frame throwing shade on the floor.
+ *
+ * Its own shader because the mirror has no vertex buffer and no skeleton: the
+ * quad is six generated vertices and the model matrix is the whole of it, while
+ * the ordinary shadow shader is built for skinned geometry with an alpha test.
+ *
+ * Depth only, no fragment stage. The pane is opaque across its whole rectangle
+ * — glass included, because this glass is not see-through — so there is nothing
+ * to alpha-test and nothing to colour.
+ *
+ * The cascade index arrives in its own tiny uniform rather than as a dynamic
+ * offset: the cascade matrices sit 64 bytes apart in one array, and a dynamic
+ * uniform offset has to be 256-aligned.
+ */
 export function mirrorShadowWgsl(cascades: number): string {
   return /* wgsl */ `
 struct LightVP { viewProj: array<mat4x4f, ${cascades}>, };

package/src/shaders/passes/outline.ts

@@ -73,14 +73,39 @@ struct VertexOutput {
   /** The triangle's own threshold, flat — see the material VertexOutput. The
    *  hull traces the body's faces, so it has to lose the same ones. */
   @location(2) @interpolate(flat) faceT: f32,
+  /** How much of a pixel-wide line this one really is (1 = all of it): a line
+   *  held at the minimum width fades by what it was short. */
+  @location(3) coverage: f32,
 };
 
+/**
+ * Half the frame height (engine units, at the subject) below which a line keeps
+ * its constant screen width; wider than that it thins as a world-size line.
+ * 12.5 = a frame 25 units tall — a full figure (an MMD model is ~20) with
+ * room around her.
+ *
+ * Not the game's own break (w = 1 game unit = 8 engine units). The game's
+ * near width is ~3× MMD's 2·edgeSize px; its world-size line comes down to
+ * MMD's width only at a full-figure framing, so that is where the break goes:
+ * close-ups and full figures keep today's width, and past that the game's rule
+ * holds — NDC offset ∝ 1/w, scaled by the zoom as its projection._m11 scales
+ * it. At the game's 8 the demo's own camera (33 units) drew a quarter of
+ * today's width, which put every line on the faded minimum.
+ */
+const RZ_OUTLINE_FULL_FIGURE = 12.5;
+/** The thinnest a line is drawn, in pixels at 1080p (and never under this many
+ *  device pixels). A line due to be thinner is drawn this wide and faded by
+ *  the shortfall, so far lines thin out without aliasing into dashes. */
+const RZ_OUTLINE_MIN_PX = 1.5;
+
 @vertex fn vs(
   @location(0) position: vec3f,
   @location(1) normal: vec3f,
   @location(2) uv: vec2f,
   @location(3) joints0: vec4<u32>,
-  @location(4) weights0: vec4<f32>
+  @location(4) weights0: vec4<f32>,
+  /** xyz: the smoothed rest normal (outline-normals.ts), w: PMX edge scale. */
+  @location(5) outlineNormal: vec4f
 ) -> VertexOutput {
   var output: VertexOutput;
   let pos4 = vec4f(position, 1.0);
@@ -97,30 +122,58 @@ struct VertexOutput {
     let m = skinMats[j];
     skinnedPos += (m * pos4) * w;
     let r3 = mat3x3f(m[0].xyz, m[1].xyz, m[2].xyz);
-    skinnedNrm += (r3 * normal) * w;
+    skinnedNrm += (r3 * outlineNormal.xyz) * w;
   }
   let worldPos = skinnedPos.xyz;
   let worldNormal = normalize(skinnedNrm);
 
   let clipPos = camera.projection * camera.view * vec4f(worldPos, 1.0);
 
-  // babylon-mmd: screenNormal = normalize((view * worldNormal).xy)
+  // The push direction is the view-space normal's XY, NOT renormalized — the
+  // game's: full length at the silhouette, where the normal lies across the
+  // view, and shrinking on surfaces turned toward the camera, so creases
+  // facing her draw finer than the rim. Skinned exactly as the colour pass
+  // skins the normal, from the smoothed rest normal, so every vertex sharing a
+  // position pushes the same way and the hull stays closed over hard edges
+  // and UV seams.
   let viewNormal = (camera.view * vec4f(worldNormal, 0.0)).xyz;
-  let snLen = length(viewNormal.xy);
-  let screenNormal = select(vec2f(0.0, 0.0), viewNormal.xy / snLen, snLen > 1e-5);
 
   // Reference-height normalization (babylon-mmd ships this variant commented
-  // out as \`renderHeight = 1080\`): thickness is a constant FRACTION of the
-  // frame — 2·edgeSize px at 1080p — so retina DPR and 4K export don't thin
-  // the rims to sub-pixel. Width follows the projection aspect.
+  // out as \`renderHeight = 1080\`): the near width is a constant FRACTION of
+  // the frame — 2·edgeSize px at 1080p — so retina DPR and 4K export don't
+  // thin the rims to sub-pixel. Width follows the projection aspect.
   // projection[1][1]/projection[0][0] = width/height for a symmetric frustum.
   let aspect = camera.projection[1][1] / camera.projection[0][0];
-  let viewport = vec2f(1080.0 * aspect, 1080.0);
+  let refViewport = vec2f(1080.0 * aspect, 1080.0);
+  let deviceViewport = vec2f(camera.viewportHeight * aspect, camera.viewportHeight);
+
+  // The game's width (Character/Debug.shader, pass "Outline"): the clip offset
+  // is the near offset × min(w, break depth). Up close the ×w cancels the
+  // perspective divide — constant screen width; past the break it stops
+  // growing, so the NDC offset falls as 1/w like a line of fixed world width.
+  // The break is the depth at which the frame is a full figure tall, so a
+  // zoomed lens moves it out (see RZ_OUTLINE_FULL_FIGURE). Under an
+  // orthographic camera w is 1 and the same min() makes the line world-size
+  // once the frame is taller than a figure. The PMX per-vertex edge scale
+  // multiplies it all, as vertex colour alpha does in the game.
+  let w = max(clipPos.w, 1e-4);
+  let breakDepth = RZ_OUTLINE_FULL_FIGURE * camera.projection[1][1];
+  let nearNdc = viewNormal.xy * (material.edgeSize * outlineNormal.w * 4.0 / refViewport);
+  var ndc = nearNdc * (min(w, breakDepth) / w);
 
-  // NDC offset = edgeSize · 4/viewport, ×w so the perspective divide cancels:
-  // constant screen thickness at any distance (babylon-mmd parity).
-  let offset = screenNormal * (material.edgeSize * 4.0 / viewport) * clipPos.w;
-  output.position = vec4f(clipPos.xy + offset, clipPos.z, clipPos.w);
+  // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
+  // width and faded by the shortfall, never thinner. The game fades by
+  // sqrt(coverage.x · coverage.y), per axis; for one width that is the ratio
+  // itself.
+  let px = length(ndc * deviceViewport * 0.5);
+  let minPx = RZ_OUTLINE_MIN_PX * max(1.0, camera.viewportHeight / 1080.0);
+  var coverage = 1.0;
+  if (px < minPx) {
+    coverage = px / minPx;
+    ndc = select(vec2f(0.0), ndc * (minPx / px), px > 1e-6);
+  }
+  output.coverage = coverage;
+  output.position = vec4f(clipPos.xy + ndc * w, clipPos.z, clipPos.w);
   output.uv = uv;
   output.restPos = position;
   output.faceT = rz_dissolve_threshold(position);
@@ -155,7 +208,11 @@ ${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
     discard;
   }
   var out: FSOut;
-  out.color = vec4f(material.edgeColor.rgb, material.edgeColor.a * texA);
+  // Blended, not alpha-to-coverage: this pass already blends (the texture
+  // alpha above), it is drawn right after the surface it traces so what lies
+  // under a faded line is already there, and 4× MSAA would quantize a fade to
+  // four steps.
+  out.color = vec4f(material.edgeColor.rgb, material.edgeColor.a * texA * input.coverage);
   out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
 ${sceneIdPadWgsl("out")}  return out;
 }

package/src/shaders/passes/particles.ts

@@ -130,7 +130,7 @@ type ParticleSource = {
   textures?: number
 }
 
-/** Where the shading stage's five scene-light bindings start — see scene-light-api.ts. */
+/** Where the shading stage's four scene-light bindings start — see scene-light-api.ts. */
 export const PARTICLE_LIGHT_BINDING = 10
 /** The effect's named points (`#points`), in both stages — see points-api.ts. */
 export const PARTICLE_POINTS_BINDING = 15