reze-engine 0.63.0 → 0.65.0

package/dist/shaders/passes/ground.js

@@ -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,
 // radial distance fade. Writes bloom mask = 0 (ground never bloom-bleeds).
@@ -33,6 +34,9 @@ const SOFT_MAX_SPREAD = 14;
  * normalised, so there is no `/ 9.0` left at the call site.
  */
 function pcfWgsl(map, uv, texel, z, acc, pad, soft) {
+    // 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.
     //
@@ -55,7 +59,7 @@ function pcfWgsl(map, uv, texel, z, acc, pad, soft) {
         `  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};`,
@@ -68,7 +72,7 @@ function pcfWgsl(map, uv, texel, z, acc, pad, soft) {
         // 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};`,
     ];
@@ -85,12 +89,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.
@@ -101,12 +103,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
@@ -140,7 +141,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 {
@@ -174,21 +175,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
@@ -197,11 +183,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
@@ -255,33 +239,26 @@ ${soft
   let ign = fract(52.9829189 * fract(dot(i.position.xy, vec2f(0.06711056, 0.00583715))));
   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/dist/shaders/passes/mirror.d.ts

@@ -1,6 +1,24 @@
 /** Bytes in MirrorMat below: mat4x4f + three 16-byte rows. */
 export declare const MIRROR_MAT_BYTES: number;
 export declare function mirrorShaderWgsl(): string;
+/**
+ * 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 declare const MIRROR_DOWNSAMPLE_WGSL = "\n@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {\n  let x = f32((vi & 1u) << 2u) - 1.0;\n  let y = f32((vi & 2u) << 1u) - 1.0;\n  return vec4f(x, y, 0.0, 1.0);\n}\n\n@group(0) @binding(0) var srcTex: texture_2d<f32>;\n@group(0) @binding(1) var srcSamp: sampler;\n\nfn samp(uv: vec2f, off: vec2f) -> vec3f {\n  return textureSampleLevel(srcTex, srcSamp, uv + off, 0.0).rgb;\n}\n\n@fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {\n  let srcDims = vec2f(textureDimensions(srcTex));\n  let t = 1.0 / srcDims;\n  // fragCoord.xy reports pixel centers (e.g. 0.5,0.5 for first pixel) \u2014 divide by dst dims directly.\n  let dstDims = srcDims * 0.5;\n  let uv = p.xy / max(dstDims, vec2f(1.0));\n  let A = samp(uv, t * vec2f(-2.0, -2.0));\n  let B = samp(uv, t * vec2f( 0.0, -2.0));\n  let C = samp(uv, t * vec2f( 2.0, -2.0));\n  let D = samp(uv, t * vec2f(-1.0, -1.0));\n  let E = samp(uv, t * vec2f( 1.0, -1.0));\n  let F = samp(uv, t * vec2f(-2.0,  0.0));\n  let G = samp(uv, t * vec2f( 0.0,  0.0));\n  let H = samp(uv, t * vec2f( 2.0,  0.0));\n  let I = samp(uv, t * vec2f(-1.0,  1.0));\n  let J = samp(uv, t * vec2f( 1.0,  1.0));\n  let K = samp(uv, t * vec2f(-2.0,  2.0));\n  let L = samp(uv, t * vec2f( 0.0,  2.0));\n  let M = samp(uv, t * vec2f( 2.0,  2.0));\n  var o = (D + E + I + J) * (0.5 / 4.0);\n  o = o + (A + B + G + F) * (0.125 / 4.0);\n  o = o + (B + C + H + G) * (0.125 / 4.0);\n  o = o + (F + G + L + K) * (0.125 / 4.0);\n  o = o + (G + H + M + L) * (0.125 / 4.0);\n  return vec4f(o, 1.0);\n}\n";
+/**
+ * Downsample for the reflection's COVERAGE chain.
+ *
+ * Colour and coverage are a premultiplied PAIR, and a blur has to move them
+ * together. Blurring colour alone drags it toward zero wherever it spreads into
+ * the empty part of the reflection, while a coverage still sampled sharp says
+ * "fully covered" — so the reflection simply got darker as the dial came up.
+ *
+ * One bilinear tap at the destination texel centre averages the source's 2x2
+ * exactly, which is the box filter this wants and the cheapest way to write it.
+ */
+export declare const MIRROR_MASK_DOWNSAMPLE_WGSL = "\n@group(0) @binding(0) var src: texture_2d<f32>;\n@group(0) @binding(1) var samp: sampler;\n\nstruct VSOut { @builtin(position) pos: vec4f, @location(0) uv: vec2f, };\n\n@vertex fn vs(@builtin(vertex_index) i: u32) -> VSOut {\n  var out: VSOut;\n  let x = f32(i32(i / 2u) * 4 - 1);\n  let y = f32(i32(i % 2u) * 4 - 1);\n  out.pos = vec4f(x, y, 0.0, 1.0);\n  out.uv = vec2f(x * 0.5 + 0.5, 0.5 - y * 0.5);\n  return out;\n}\n\n@fragment fn fs(in: VSOut) -> @location(0) vec4f {\n  return textureSampleLevel(src, samp, in.uv, 0.0);\n}\n";
 /**
  * The mirror in the SHADOW pass — the frame throwing shade on the floor.
  *
@@ -16,17 +34,5 @@ export declare function mirrorShaderWgsl(): string;
  * 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 COVERAGE chain.
- *
- * Colour and coverage are a premultiplied PAIR, and a blur has to move them
- * together. Blurring colour alone drags it toward zero wherever it spreads into
- * the empty part of the reflection, while a coverage still sampled sharp says
- * "fully covered" — so the reflection simply got darker as the dial came up.
- *
- * One bilinear tap at the destination texel centre averages the source's 2x2
- * exactly, which is the box filter this wants and the cheapest way to write it.
- */
-export declare const MIRROR_MASK_DOWNSAMPLE_WGSL = "\n@group(0) @binding(0) var src: texture_2d<f32>;\n@group(0) @binding(1) var samp: sampler;\n\nstruct VSOut { @builtin(position) pos: vec4f, @location(0) uv: vec2f, };\n\n@vertex fn vs(@builtin(vertex_index) i: u32) -> VSOut {\n  var out: VSOut;\n  let x = f32(i32(i / 2u) * 4 - 1);\n  let y = f32(i32(i % 2u) * 4 - 1);\n  out.pos = vec4f(x, y, 0.0, 1.0);\n  out.uv = vec2f(x * 0.5 + 0.5, 0.5 - y * 0.5);\n  return out;\n}\n\n@fragment fn fs(in: VSOut) -> @location(0) vec4f {\n  return textureSampleLevel(src, samp, in.uv, 0.0);\n}\n";
 export declare function mirrorShadowWgsl(cascades: number): string;
 //# sourceMappingURL=mirror.d.ts.map

package/dist/shaders/passes/mirror.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mirror.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/mirror.ts"],"names":[],"mappings":"AAqBA,8DAA8D;AAC9D,eAAO,MAAM,gBAAgB,QAAc,CAAA;AAE3C,wBAAgB,gBAAgB,IAAI,MAAM,CAiMzC;AAED;;;;;;;;;;;;;;GAcG;AACH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,2hBAkBvC,CAAA;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAuBzD"}
+{"version":3,"file":"mirror.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/mirror.ts"],"names":[],"mappings":"AAqBA,8DAA8D;AAC9D,eAAO,MAAM,gBAAgB,QAAc,CAAA;AAE3C,wBAAgB,gBAAgB,IAAI,MAAM,CAiMzC;AAED;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,2hDAwClC,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,2hBAkBvC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAuBzD"}

package/dist/shaders/passes/mirror.js

@@ -214,20 +214,51 @@ ${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.
  *
@@ -258,6 +289,21 @@ struct VSOut { @builtin(position) pos: vec4f, @location(0) uv: vec2f, };
   return textureSampleLevel(src, samp, in.uv, 0.0);
 }
 `;
+/**
+ * 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) {
     return /* wgsl */ `
 struct LightVP { viewProj: array<mat4x4f, ${cascades}>, };

package/dist/shaders/passes/outline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/outline.ts"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAE5C,wBAAgB,iBAAiB,IAAI,MAAM,CAoI1C"}
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/outline.ts"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAE5C,wBAAgB,iBAAiB,IAAI,MAAM,CA6L1C"}

package/dist/shaders/passes/outline.js

@@ -69,14 +69,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);
@@ -93,30 +118,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);
@@ -151,7 +204,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/dist/shaders/passes/particles.d.ts

@@ -63,7 +63,7 @@ type ParticleSource = {
      *  N > 0 — see texture-api.ts. Omitted = 0. */
     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 declare const PARTICLE_LIGHT_BINDING = 10;
 /** The effect's named points (`#points`), in both stages — see points-api.ts. */
 export declare const PARTICLE_POINTS_BINDING = 15;

package/dist/shaders/passes/particles.js

@@ -43,7 +43,7 @@ fn _rzCastLive() -> i32 {
         trailSlotsApi(cast.trailCount) +
         anchorAliasWgsl(cast.alias));
 }
-/** 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;

package/dist/shaders/scene-light-api.d.ts

@@ -8,16 +8,25 @@
  */
 export declare const worldAmbientWgsl: (u: string) => string;
 /**
- * 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 declare const pcf9: (map: string, ts: string, sampler?: string) => string;
+export declare const SHADOW_MARGIN = 0.98;
+export declare const sunShadowWgsl: (p: string, map: string, sampler: string, vp: string) => string;
 /** Bindings the real accessors take, from `binding` upward. */
-export declare const SCENE_LIGHT_API_BINDINGS = 5;
+export declare 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.
@@ -25,12 +34,11 @@ export declare 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

package/dist/shaders/scene-light-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene-light-api.d.ts","sourceRoot":"","sources":["../../src/shaders/scene-light-api.ts"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,WAwBzC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,GAAI,KAAK,MAAM,EAAE,IAAI,MAAM,EAAE,gBAAyB,WActE,CAAA;AAED,+DAA+D;AAC/D,eAAO,MAAM,wBAAwB,IAAI,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA2DjF"}
+{"version":3,"file":"scene-light-api.d.ts","sourceRoot":"","sources":["../../src/shaders/scene-light-api.ts"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,WAwBzC,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,OAAO,CAAA;AAEjC,eAAO,MAAM,aAAa,GAAI,GAAG,MAAM,EAAE,KAAK,MAAM,EAAE,SAAS,MAAM,EAAE,IAAI,MAAM,WAkChF,CAAA;AAED,+DAA+D;AAC/D,eAAO,MAAM,wBAAwB,IAAI,CAAA;AAEzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CA2CjF"}