@ifc-lite/renderer 1.49.0 → 1.50.0

package/dist/shaders/main.wgsl.js

@@ -43,6 +43,89 @@ export const mainShaderSource = `
         }
         @binding(0) @group(1) var<uniform> env: Environment;
 
+        // Sun shadow map (#2670, Phase 2b) at group(1). The depth map, a
+        // comparison sampler, and the light matrix + params. Bound on every
+        // main-family pipeline; sampling is gated by shadowU.params.y (enabled),
+        // so when shadows are off this reads the 1×1 dummy and returns 1.0.
+        @binding(1) @group(1) var shadowMap: texture_depth_2d;
+        @binding(2) @group(1) var shadowCmp: sampler_comparison;
+        struct Shadow {
+          lightViewProj: mat4x4<f32>,
+          // x = texelSize (1/resolution), y = enabled (0/1),
+          // z = normalBias (world units), w = pcfRadius (texels).
+          params: vec4<f32>,
+          // x = depthBias (reverse-Z clip units, nudges toward lit).
+          params2: vec4<f32>,
+        }
+        @binding(3) @group(1) var<uniform> shadowU: Shadow;
+
+        // Fraction of the sun reaching this surface point (1 = lit, 0 = fully
+        // shadowed). Normal-offset + slope-scaled bias defeats acne without
+        // peter-panning; the penumbra is sampled with a 12-tap Poisson disk
+        // ROTATED per pixel (interleaved gradient noise). A fixed grid kernel
+        // undersamples a wide penumbra and breaks into discrete bands (the
+        // "tripled shadow" at high softness); a rotated disk turns that banding
+        // into fine dither that reads as smooth at any softness.
+        // textureSampleCompareLevel is used (not ...Compare) so it is legal in
+        // this non-uniform control flow.
+        const SHADOW_POISSON = array<vec2<f32>, 12>(
+          vec2<f32>(-0.326, -0.406), vec2<f32>(-0.840, -0.074), vec2<f32>(-0.696,  0.457),
+          vec2<f32>(-0.203,  0.621), vec2<f32>( 0.962, -0.195), vec2<f32>( 0.473, -0.480),
+          vec2<f32>( 0.519,  0.767), vec2<f32>( 0.185, -0.893), vec2<f32>( 0.507,  0.064),
+          vec2<f32>( 0.896,  0.412), vec2<f32>(-0.322, -0.933), vec2<f32>(-0.792, -0.598),
+        );
+
+        fn sunShadowFactor(worldPos: vec3<f32>, N: vec3<f32>, fragCoord: vec2<f32>) -> f32 {
+          if (shadowU.params.y < 0.5) { return 1.0; }
+          // The diffuse sun term is TWO-SIDED (abs(dot(N, sun)) in the shading
+          // below), so a face whose stabilized normal points away from the sun is
+          // still lit. Orient the normal toward the sun before biasing: otherwise
+          // the normal-offset push (params.z) moves the sample AWAY from the light
+          // (deeper behind the surface), and the slope term below collapses to its
+          // max (NdotL→0), together biasing the compare toward "lit" — which leaks
+          // direct sun onto interior faces the roof occludes (#2670 review).
+          let L = normalize(env.sunDirection);
+          let Ns = N * select(-1.0, 1.0, dot(N, L) >= 0.0);
+          let biased = worldPos + Ns * shadowU.params.z;
+          let clip = shadowU.lightViewProj * vec4<f32>(biased, 1.0);
+          let ndc = clip.xyz / clip.w;
+          let uv = vec2<f32>(ndc.x * 0.5 + 0.5, ndc.y * -0.5 + 0.5);
+          let inBounds = uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0 && ndc.z > 0.0;
+          if (!inBounds) { return 1.0; }
+          // Slope-scaled depth bias: at a grazing sun the receiver's light-space
+          // depth changes fast across the kernel, so a constant bias can't clear
+          // the whole footprint and the surface rings with moiré. Grow the bias
+          // as the surface tilts away from the sun (NdotL → 0) and with the
+          // kernel width. The hardware slope bias in the depth pass covers the
+          // occluder side; this covers the receiver side.
+          let NdotL = max(dot(Ns, L), 0.0);
+          let slope = clamp(sqrt(max(1.0 - NdotL * NdotL, 0.0)) / max(NdotL, 0.1), 1.0, 12.0);
+          let refDepth = ndc.z + shadowU.params2.x * slope * (1.0 + shadowU.params.w);
+          let radius = shadowU.params.x * shadowU.params.w;  // penumbra, uv units
+          // Per-pixel rotation (interleaved gradient noise) dithers the disk so
+          // the discrete taps never line up into bands.
+          let ign = fract(52.9829189 * fract(dot(fragCoord, vec2<f32>(0.06711056, 0.00583715))));
+          let ang = ign * 6.2831853;
+          let cr = cos(ang);
+          let sr = sin(ang);
+          var sum = 0.0;
+          for (var i = 0; i < 12; i = i + 1) {
+            let p = SHADOW_POISSON[i];
+            let off = vec2<f32>(p.x * cr - p.y * sr, p.x * sr + p.y * cr) * radius;
+            sum = sum + textureSampleCompareLevel(shadowMap, shadowCmp, uv + off, refDepth);
+          }
+          let pcf = sum / 12.0;
+          // Terminator fade. On a surface nearly PARALLEL to the sun rays
+          // (NdotL → 0, e.g. a vertical wall under a midday sun) the receiver
+          // straddles the shadow threshold, so the rotated-disk taps randomly
+          // pass/fail and the wall breaks into salt-and-pepper speckle. The
+          // direct sun term is near zero there anyway, so fade the cast shadow
+          // smoothly toward lit as the surface goes grazing: a clean gradient
+          // replaces the ripple (#2670).
+          let graze = smoothstep(0.0, 0.3, NdotL);
+          return mix(1.0, pcf, graze);
+        }
+
         struct VertexInput {
           @location(0) position: vec3<f32>,
           @location(1) normal: vec3<f32>,
@@ -388,10 +471,10 @@ export const mainShaderSource = `
           // Darken whites/grays more to reduce washed-out appearance
           baseColor = mix(baseColor, baseColor * 0.7, isWhiteish * 0.4);
 
-          // Combine all lighting. Keep the lighting term separate so the
-          // selection highlight can reuse it (re-light a blue albedo) without
-          // the base material colour bleeding through.
-          let lightTerm = ambient + env.sunColor * diffuseSun + vec3<f32>(diffuseFill + rim);
+          // Combine all lighting. Only the DIRECT sun term is occluded by cast
+          // shadows (#2670); ambient/fill/rim are indirect and stay unshadowed.
+          let sunShadow = sunShadowFactor(input.worldPos, N, input.position.xy);
+          let lightTerm = ambient + env.sunColor * (diffuseSun * sunShadow) + vec3<f32>(diffuseFill + rim);
           var color = baseColor * lightTerm;
 
           // flags.x is a bitfield:

package/dist/shaders/main.wgsl.js.map

@@ -1 +1 @@
-{"version":3,"file":"main.wgsl.js","sourceRoot":"","sources":["../../src/shaders/main.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkiBzB,CAAC"}
+{"version":3,"file":"main.wgsl.js","sourceRoot":"","sources":["../../src/shaders/main.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqnBzB,CAAC"}

package/dist/shaders/shadow.wgsl.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Sun shadow-map depth pre-pass shaders (issue #2670, Phase 2).
+ *
+ * Depth-only: each entry point transforms a vertex to the sun's light clip
+ * space and lets the depth test record the closest occluder. There is ONE
+ * entry point per geometry path, and each MUST reproduce the world-space
+ * position its main-shader counterpart computes, or that path silently stops
+ * casting (the divergence class #2670's acceptance test guards):
+ *
+ *   • vs_shadow_flat       ← vs_main            worldPos = model * position
+ *   • vs_shadow_quantized  ← vs_main_quantized  worldPos = model * dequant(q)
+ *   • vs_shadow_instanced  ← vs_instanced       worldPos = instMat * position
+ *   • vs_shadow_textured    ← textured vs_main    worldPos = model * position
+ *
+ * `lightViewProj` replaces the camera `viewProj`; `model`/`quantParams` come
+ * per-draw via a dynamic-offset uniform (unused by the instanced path, whose
+ * per-occurrence matrix arrives on vertex slot 1). The anti-z-fighting depth
+ * nudge from the main shaders is deliberately omitted — it perturbs camera
+ * clip depth for coplanar-face separation and has no meaning in light space.
+ *
+ * CLIPPING. Every entry point also passes world position to `fs_shadow_clip`,
+ * which re-applies the section plane and clip box exactly as `fs_main` does,
+ * so geometry a section cut removed from view stops casting too (otherwise the
+ * cut-away roof keeps shadowing the floor it no longer covers). The fragment
+ * stage is only attached when a clip is actually active — with no clipping the
+ * pipelines stay fragment-less, keeping the double-speed depth-only path — and
+ * the unused `worldPos` output on those pipelines costs an interpolator, not a
+ * shader stage.
+ */
+export declare const shadowShaderSource = "\n        struct Light {\n          lightViewProj: mat4x4<f32>,\n        }\n        @binding(0) @group(0) var<uniform> light: Light;\n\n        struct Draw {\n          model: mat4x4<f32>,\n          // xyz = lattice-aligned quantMin (batch-origin-relative), w = step.\n          // Read only by vs_shadow_quantized; zero for the other paths.\n          quantParams: vec4<f32>,\n        }\n        @binding(1) @group(0) var<uniform> draw: Draw;\n\n        struct Clip {\n          // xyz = plane normal, w = plane distance (world space).\n          sectionPlane: vec4<f32>,\n          clipBoxMin: vec4<f32>,\n          clipBoxMax: vec4<f32>,\n          // x packs: bit 0 = section enabled, bit 1 = section flipped,\n          //          bit 2 = clip box enabled. Mirrors main.wgsl's flags.y.\n          flags: vec4<u32>,\n        }\n        @binding(2) @group(0) var<uniform> clip: Clip;\n\n        struct FlatIn {\n          @location(0) position: vec3<f32>,\n        }\n\n        struct QuantIn {\n          @location(0) q: vec4<u32>,   // uint16x4: lattice x, y, z, packedOct\n        }\n\n        struct InstanceIn {\n          @location(3) m0: vec4<f32>,\n          @location(4) m1: vec4<f32>,\n          @location(5) m2: vec4<f32>,\n          @location(6) m3: vec4<f32>,\n          // Per-occurrence flags lane (bit 1 = hidden), same instance buffer the\n          // colour pass reads. Locations 7 (entityId) and 8 (rgba) are unused by\n          // the depth pass and left unbound.\n          @location(9) flags: u32,\n        }\n\n        struct ShadowOut {\n          @builtin(position) position: vec4<f32>,\n          @location(0) worldPos: vec3<f32>,\n        }\n\n        fn emit(worldPos: vec4<f32>) -> ShadowOut {\n          var out: ShadowOut;\n          out.position = light.lightViewProj * worldPos;\n          out.worldPos = worldPos.xyz;\n          return out;\n        }\n\n        @vertex\n        fn vs_shadow_flat(input: FlatIn) -> ShadowOut {\n          return emit(draw.model * vec4<f32>(input.position, 1.0));\n        }\n\n        @vertex\n        fn vs_shadow_quantized(input: QuantIn) -> ShadowOut {\n          let p = draw.quantParams.xyz\n            + vec3<f32>(f32(input.q.x), f32(input.q.y), f32(input.q.z)) * draw.quantParams.w;\n          return emit(draw.model * vec4<f32>(p, 1.0));\n        }\n\n        @vertex\n        fn vs_shadow_instanced(input: FlatIn, inst: InstanceIn) -> ShadowOut {\n          // A hidden / isolation-excluded occurrence (flags bit 1) must not cast:\n          // the colour pass discards it in fs_main, so collapse it to a zero-area\n          // triangle here (every vertex to one clip point) \u2014 the rasterizer drops\n          // it and it writes no depth. Mirrors main.wgsl's instSelected & 2u check.\n          if ((inst.flags & 2u) != 0u) {\n            var out: ShadowOut;\n            out.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);\n            out.worldPos = vec3<f32>(0.0, 0.0, 0.0);\n            return out;\n          }\n          let instMat = mat4x4<f32>(inst.m0, inst.m1, inst.m2, inst.m3);\n          return emit(instMat * vec4<f32>(input.position, 1.0));\n        }\n\n        @vertex\n        fn vs_shadow_textured(input: FlatIn) -> ShadowOut {\n          return emit(draw.model * vec4<f32>(input.position, 1.0));\n        }\n\n        // Clipped variant: discard before the depth write, so a clipped-away\n        // occluder leaves the shadow map untouched. Kept byte-for-byte in step\n        // with the fs_main section/clip-box branches.\n        @fragment\n        fn fs_shadow_clip(@location(0) worldPos: vec3<f32>) {\n          if ((clip.flags.x & 1u) == 1u) {\n            let side = select(1.0, -1.0, (clip.flags.x & 2u) == 2u);\n            let distToPlane = (dot(worldPos, clip.sectionPlane.xyz) - clip.sectionPlane.w) * side;\n            if (distToPlane > 0.0) {\n              discard;\n            }\n          }\n          if ((clip.flags.x & 4u) != 0u) {\n            if (any(worldPos < clip.clipBoxMin.xyz) || any(worldPos > clip.clipBoxMax.xyz)) {\n              discard;\n            }\n          }\n        }\n";
+//# sourceMappingURL=shadow.wgsl.d.ts.map

package/dist/shaders/shadow.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow.wgsl.d.ts","sourceRoot":"","sources":["../../src/shaders/shadow.wgsl.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB,4hIA2G9B,CAAC"}

package/dist/shaders/shadow.wgsl.js

@@ -0,0 +1,141 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Sun shadow-map depth pre-pass shaders (issue #2670, Phase 2).
+ *
+ * Depth-only: each entry point transforms a vertex to the sun's light clip
+ * space and lets the depth test record the closest occluder. There is ONE
+ * entry point per geometry path, and each MUST reproduce the world-space
+ * position its main-shader counterpart computes, or that path silently stops
+ * casting (the divergence class #2670's acceptance test guards):
+ *
+ *   • vs_shadow_flat       ← vs_main            worldPos = model * position
+ *   • vs_shadow_quantized  ← vs_main_quantized  worldPos = model * dequant(q)
+ *   • vs_shadow_instanced  ← vs_instanced       worldPos = instMat * position
+ *   • vs_shadow_textured    ← textured vs_main    worldPos = model * position
+ *
+ * `lightViewProj` replaces the camera `viewProj`; `model`/`quantParams` come
+ * per-draw via a dynamic-offset uniform (unused by the instanced path, whose
+ * per-occurrence matrix arrives on vertex slot 1). The anti-z-fighting depth
+ * nudge from the main shaders is deliberately omitted — it perturbs camera
+ * clip depth for coplanar-face separation and has no meaning in light space.
+ *
+ * CLIPPING. Every entry point also passes world position to `fs_shadow_clip`,
+ * which re-applies the section plane and clip box exactly as `fs_main` does,
+ * so geometry a section cut removed from view stops casting too (otherwise the
+ * cut-away roof keeps shadowing the floor it no longer covers). The fragment
+ * stage is only attached when a clip is actually active — with no clipping the
+ * pipelines stay fragment-less, keeping the double-speed depth-only path — and
+ * the unused `worldPos` output on those pipelines costs an interpolator, not a
+ * shader stage.
+ */
+export const shadowShaderSource = `
+        struct Light {
+          lightViewProj: mat4x4<f32>,
+        }
+        @binding(0) @group(0) var<uniform> light: Light;
+
+        struct Draw {
+          model: mat4x4<f32>,
+          // xyz = lattice-aligned quantMin (batch-origin-relative), w = step.
+          // Read only by vs_shadow_quantized; zero for the other paths.
+          quantParams: vec4<f32>,
+        }
+        @binding(1) @group(0) var<uniform> draw: Draw;
+
+        struct Clip {
+          // xyz = plane normal, w = plane distance (world space).
+          sectionPlane: vec4<f32>,
+          clipBoxMin: vec4<f32>,
+          clipBoxMax: vec4<f32>,
+          // x packs: bit 0 = section enabled, bit 1 = section flipped,
+          //          bit 2 = clip box enabled. Mirrors main.wgsl's flags.y.
+          flags: vec4<u32>,
+        }
+        @binding(2) @group(0) var<uniform> clip: Clip;
+
+        struct FlatIn {
+          @location(0) position: vec3<f32>,
+        }
+
+        struct QuantIn {
+          @location(0) q: vec4<u32>,   // uint16x4: lattice x, y, z, packedOct
+        }
+
+        struct InstanceIn {
+          @location(3) m0: vec4<f32>,
+          @location(4) m1: vec4<f32>,
+          @location(5) m2: vec4<f32>,
+          @location(6) m3: vec4<f32>,
+          // Per-occurrence flags lane (bit 1 = hidden), same instance buffer the
+          // colour pass reads. Locations 7 (entityId) and 8 (rgba) are unused by
+          // the depth pass and left unbound.
+          @location(9) flags: u32,
+        }
+
+        struct ShadowOut {
+          @builtin(position) position: vec4<f32>,
+          @location(0) worldPos: vec3<f32>,
+        }
+
+        fn emit(worldPos: vec4<f32>) -> ShadowOut {
+          var out: ShadowOut;
+          out.position = light.lightViewProj * worldPos;
+          out.worldPos = worldPos.xyz;
+          return out;
+        }
+
+        @vertex
+        fn vs_shadow_flat(input: FlatIn) -> ShadowOut {
+          return emit(draw.model * vec4<f32>(input.position, 1.0));
+        }
+
+        @vertex
+        fn vs_shadow_quantized(input: QuantIn) -> ShadowOut {
+          let p = draw.quantParams.xyz
+            + vec3<f32>(f32(input.q.x), f32(input.q.y), f32(input.q.z)) * draw.quantParams.w;
+          return emit(draw.model * vec4<f32>(p, 1.0));
+        }
+
+        @vertex
+        fn vs_shadow_instanced(input: FlatIn, inst: InstanceIn) -> ShadowOut {
+          // A hidden / isolation-excluded occurrence (flags bit 1) must not cast:
+          // the colour pass discards it in fs_main, so collapse it to a zero-area
+          // triangle here (every vertex to one clip point) — the rasterizer drops
+          // it and it writes no depth. Mirrors main.wgsl's instSelected & 2u check.
+          if ((inst.flags & 2u) != 0u) {
+            var out: ShadowOut;
+            out.position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
+            out.worldPos = vec3<f32>(0.0, 0.0, 0.0);
+            return out;
+          }
+          let instMat = mat4x4<f32>(inst.m0, inst.m1, inst.m2, inst.m3);
+          return emit(instMat * vec4<f32>(input.position, 1.0));
+        }
+
+        @vertex
+        fn vs_shadow_textured(input: FlatIn) -> ShadowOut {
+          return emit(draw.model * vec4<f32>(input.position, 1.0));
+        }
+
+        // Clipped variant: discard before the depth write, so a clipped-away
+        // occluder leaves the shadow map untouched. Kept byte-for-byte in step
+        // with the fs_main section/clip-box branches.
+        @fragment
+        fn fs_shadow_clip(@location(0) worldPos: vec3<f32>) {
+          if ((clip.flags.x & 1u) == 1u) {
+            let side = select(1.0, -1.0, (clip.flags.x & 2u) == 2u);
+            let distToPlane = (dot(worldPos, clip.sectionPlane.xyz) - clip.sectionPlane.w) * side;
+            if (distToPlane > 0.0) {
+              discard;
+            }
+          }
+          if ((clip.flags.x & 4u) != 0u) {
+            if (any(worldPos < clip.clipBoxMin.xyz) || any(worldPos > clip.clipBoxMax.xyz)) {
+              discard;
+            }
+          }
+        }
+`;
+//# sourceMappingURL=shadow.wgsl.js.map

package/dist/shaders/shadow.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow.wgsl.js","sourceRoot":"","sources":["../../src/shaders/shadow.wgsl.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2GjC,CAAC"}

package/dist/shadow-light-matrix.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Sun shadow-map light matrix (issue #2670, Phase 2).
+ *
+ * Builds the orthographic light-view-projection the sun shadow depth pass
+ * renders occluders through. A directional sun is an orthographic camera:
+ * the frustum is a box whose axis is the (negated) sun direction, and whose
+ * cross-section must cover everything that can cast into the view.
+ *
+ * Fitting policy: by default the lateral (x/y) extent is fitted to the whole
+ * model AABB — a single, well-conditioned cascade that is correct at
+ * building scale. A caller MAY instead pass `focusCorners` (e.g. the camera
+ * frustum clipped to the model, for a site-scale view-fitted map, maintainer
+ * constraint #1 on #2670) and the lateral fit tightens to those; that path is
+ * a documented follow-up and needs a proper cascade to be robust against a
+ * reverse-Z / infinite-far camera, so the live renderer uses the bounds fit.
+ *
+ * The DEPTH range is deliberately NOT fitted to the focus alone: an occluder
+ * BEHIND the visible region along the sun axis (a roof over the room you are
+ * looking at) still has to be in the map to cast into it, so the near plane is
+ * pushed back to enclose the whole model along the light direction while the
+ * lateral (x/y) extent stays fitted to the focus.
+ *
+ * Everything here is pure and framework-free so it can be unit-tested without
+ * a GPU; the depth pass (`shadow-pass.ts`) consumes {@link SunLightFit}.
+ */
+import type { Mat4, Vec3 } from './types.js';
+export interface SunLightFitParams {
+    /**
+     * Unit vector TOWARD the sun in viewer/world space (Y-up), matching the
+     * shading path's `env.sunDirection` convention. Normalized defensively; a
+     * non-finite or zero vector falls back to straight-down sun (Y-up).
+     */
+    sunDirection: readonly [number, number, number];
+    /** World-space model AABB min corner. */
+    boundsMin: readonly [number, number, number];
+    /** World-space model AABB max corner. */
+    boundsMax: readonly [number, number, number];
+    /**
+     * Eight corners of the camera frustum clipped to the model bounds, world
+     * space. When provided the lateral fit uses these (tight, view-fitted map);
+     * when omitted or shorter than 4 the model AABB corners are used instead.
+     */
+    focusCorners?: readonly Vec3[];
+    /**
+     * Fractional slack added around the fitted lateral extent so a PCF/normal
+     * -offset kernel near the map edge still has neighbours to sample. Default
+     * 0.05 (5%). Clamped to [0, 1].
+     */
+    lateralPadding?: number;
+}
+export interface SunLightFit {
+    /** Column-major light view-projection (`ortho * lightView`), reverse-Z. */
+    lightViewProj: Mat4;
+    /** Light view matrix on its own (world → light view space). */
+    lightView: Mat4;
+    /** Fitted ortho half-width in world units (light-space x). */
+    orthoHalfWidth: number;
+    /** Fitted ortho half-height in world units (light-space y). */
+    orthoHalfHeight: number;
+    /** Near→far depth span along the sun axis, world units. */
+    depthRange: number;
+}
+/**
+ * Fit the sun's orthographic shadow frustum. Pure; see the file header for the
+ * fitting policy. The returned matrix maps world space straight to the shadow
+ * map's clip space (reverse-Z, depth 1 at near → 0 at far), so the depth pass
+ * uses it exactly where the main pass uses the camera `viewProj`.
+ */
+export declare function fitSunLightMatrix(params: SunLightFitParams): SunLightFit;
+export interface CameraFrustumParams {
+    /** Camera eye (world). */
+    eye: Vec3;
+    /** Unit view direction (eye → target). */
+    forward: Vec3;
+    /** Unit screen-right. */
+    right: Vec3;
+    /** Unit screen-up. */
+    up: Vec3;
+    /** Vertical FOV in radians (perspective). */
+    fovY: number;
+    /** Viewport width / height. */
+    aspect: number;
+    /** Orthographic projection? Then `orthoHalfHeight` sizes the frustum. */
+    ortho: boolean;
+    /** Half-height of the ortho view volume, world units (ortho only). */
+    orthoHalfHeight: number;
+    boundsMin: readonly [number, number, number];
+    boundsMax: readonly [number, number, number];
+    /** Lateral expansion so a caster just off-screen still reaches the map. */
+    margin?: number;
+}
+/**
+ * Eight corners of the camera frustum, clipped to the model AABB — the region
+ * the camera can actually see (maintainer constraint #1 on #2670). Passing
+ * these to {@link fitSunLightMatrix} as `focusCorners` concentrates the shadow
+ * map on visible geometry instead of a site-scale model's whole footprint,
+ * which is what makes distant terrain steal all the resolution.
+ *
+ * Unlike unprojecting the clip cube, this builds the frustum from the camera
+ * BASIS at finite near/far distances derived from where the model sits along
+ * the view axis, so it never depends on a reverse-Z / infinite-far plane.
+ * Returns `null` when the model is entirely behind the camera (no usable
+ * focus — the caller falls back to a whole-bounds fit).
+ */
+export declare function cameraFrustumFocusCorners(p: CameraFrustumParams): Vec3[] | null;
+//# sourceMappingURL=shadow-light-matrix.d.ts.map

package/dist/shadow-light-matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-light-matrix.d.ts","sourceRoot":"","sources":["../src/shadow-light-matrix.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAG7C,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,YAAY,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAChD,yCAAyC;IACzC,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,yCAAyC;IACzC,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C;;;;OAIG;IACH,YAAY,CAAC,EAAE,SAAS,IAAI,EAAE,CAAC;IAC/B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,aAAa,EAAE,IAAI,CAAC;IACpB,+DAA+D;IAC/D,SAAS,EAAE,IAAI,CAAC;IAChB,8DAA8D;IAC9D,cAAc,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,eAAe,EAAE,MAAM,CAAC;IACxB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,CAAC;CACpB;AAwCD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,WAAW,CA0FxE;AAED,MAAM,WAAW,mBAAmB;IAClC,0BAA0B;IAC1B,GAAG,EAAE,IAAI,CAAC;IACV,0CAA0C;IAC1C,OAAO,EAAE,IAAI,CAAC;IACd,yBAAyB;IACzB,KAAK,EAAE,IAAI,CAAC;IACZ,sBAAsB;IACtB,EAAE,EAAE,IAAI,CAAC;IACT,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,+BAA+B;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,KAAK,EAAE,OAAO,CAAC;IACf,sEAAsE;IACtE,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,mBAAmB,GAAG,IAAI,EAAE,GAAG,IAAI,CAoC/E"}

package/dist/shadow-light-matrix.js

@@ -0,0 +1,185 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+import { MathUtils } from './math.js';
+const DEFAULT_SUN = { x: 0, y: 1, z: 0 };
+/** Unit sun direction, falling back to straight down-up for unusable input. */
+function resolveSun(dir) {
+    const x = dir[0], y = dir[1], z = dir[2];
+    const lenSq = x * x + y * y + z * z;
+    // Finiteness matters as much as length (#2489): an Infinity component makes
+    // the length Infinity and the divide below NaN, so guard both ends.
+    if (!(lenSq > 1e-12 && lenSq < Infinity))
+        return DEFAULT_SUN;
+    const inv = 1 / Math.sqrt(lenSq);
+    return { x: x * inv, y: y * inv, z: z * inv };
+}
+/** The eight corners of an axis-aligned box. */
+function aabbCorners(min, max) {
+    const corners = [];
+    for (let i = 0; i < 8; i++) {
+        corners.push({
+            x: (i & 1) ? max[0] : min[0],
+            y: (i & 2) ? max[1] : min[1],
+            z: (i & 4) ? max[2] : min[2],
+        });
+    }
+    return corners;
+}
+/** Transform a world point by a column-major Mat4 (w = 1), returning xyz. */
+function transformPoint(m, p) {
+    return {
+        x: m[0] * p.x + m[4] * p.y + m[8] * p.z + m[12],
+        y: m[1] * p.x + m[5] * p.y + m[9] * p.z + m[13],
+        z: m[2] * p.x + m[6] * p.y + m[10] * p.z + m[14],
+    };
+}
+/**
+ * Fit the sun's orthographic shadow frustum. Pure; see the file header for the
+ * fitting policy. The returned matrix maps world space straight to the shadow
+ * map's clip space (reverse-Z, depth 1 at near → 0 at far), so the depth pass
+ * uses it exactly where the main pass uses the camera `viewProj`.
+ */
+export function fitSunLightMatrix(params) {
+    const sun = resolveSun(params.sunDirection);
+    const modelCorners = aabbCorners(params.boundsMin, params.boundsMax);
+    // Lateral fit target: the view-clipped frustum corners when usable, else the
+    // whole model. Depth always encloses the whole model (see header).
+    const lateralPts = params.focusCorners && params.focusCorners.length >= 4
+        ? params.focusCorners
+        : modelCorners;
+    // Centre the light view on the lateral focus so the fitted x/y box is
+    // symmetric around the region of interest.
+    let cx = 0, cy = 0, cz = 0;
+    for (const p of lateralPts) {
+        cx += p.x;
+        cy += p.y;
+        cz += p.z;
+    }
+    const n = lateralPts.length;
+    const center = { x: cx / n, y: cy / n, z: cz / n };
+    // Light view: eye one unit up-sun of the centre, looking down the sun axis
+    // (forward = -sun). The eye offset only shifts light-space z uniformly; near
+    // /far below are derived from the transformed points, so its magnitude is
+    // immaterial. `up` comes from viewBasis's degeneracy handling for the
+    // straight-overhead sun where any fixed up would be parallel.
+    const eye = {
+        x: center.x + sun.x,
+        y: center.y + sun.y,
+        z: center.z + sun.z,
+    };
+    // A world-Y up hint, swapped to world-Z when the sun is near-vertical, keeps
+    // the basis well-conditioned; viewBasis substitutes its own hint if this is
+    // still parallel, so the result is always finite.
+    const upHint = Math.abs(sun.y) > 0.99 ? { x: 0, y: 0, z: 1 } : { x: 0, y: 1, z: 0 };
+    const lightView = MathUtils.lookAt(eye, center, upHint);
+    const lv = lightView.m;
+    // Lateral (x/y) extent from the focus points.
+    let minX = Infinity, maxX = -Infinity;
+    let minY = Infinity, maxY = -Infinity;
+    for (const p of lateralPts) {
+        const v = transformPoint(lv, p);
+        if (v.x < minX)
+            minX = v.x;
+        if (v.x > maxX)
+            maxX = v.x;
+        if (v.y < minY)
+            minY = v.y;
+        if (v.y > maxY)
+            maxY = v.y;
+    }
+    // Depth (z) extent from the WHOLE model, so occluders behind the focus still
+    // cast into it. In lookAt view space the camera looks down -Z, so scene
+    // points have negative z and their distance from the eye is -z.
+    let minZ = Infinity, maxZ = -Infinity;
+    for (const p of modelCorners) {
+        const vz = lv[2] * p.x + lv[6] * p.y + lv[10] * p.z + lv[14];
+        if (vz < minZ)
+            minZ = vz;
+        if (vz > maxZ)
+            maxZ = vz;
+    }
+    // Pad the lateral box so an edge texel's kernel still has neighbours.
+    const pad = Math.min(Math.max(params.lateralPadding ?? 0.05, 0), 1);
+    const halfW = Math.max((maxX - minX) * 0.5, 1e-4);
+    const halfH = Math.max((maxY - minY) * 0.5, 1e-4);
+    const midX = (minX + maxX) * 0.5;
+    const midY = (minY + maxY) * 0.5;
+    const padW = halfW * (1 + pad);
+    const padH = halfH * (1 + pad);
+    const left = midX - padW;
+    const right = midX + padW;
+    const bottom = midY - padH;
+    const top = midY + padH;
+    // Distances along the view direction. In lookAt view space scene points have
+    // negative z, so distance = -z: the nearest point (largest z) sets `near`,
+    // the farthest (smallest z) sets `far`. `near` is NOT clamped to 0 — the eye
+    // sits just up-sun of the FOCUS centre, so model geometry further up-sun is
+    // behind it (positive z ⇒ negative near), and clamping would push those
+    // occluders out of the depth range so they stopped casting. A small epsilon
+    // pads both ends against precision and a zero-thickness (flat) frustum.
+    const zEps = Math.max((maxZ - minZ) * 1e-3, 1e-3);
+    const near = -maxZ - zEps;
+    const far = -minZ + zEps;
+    const ortho = MathUtils.orthographicReverseZ(left, right, bottom, top, near, far);
+    const lightViewProj = MathUtils.multiply(ortho, lightView);
+    return {
+        lightViewProj,
+        lightView,
+        orthoHalfWidth: padW,
+        orthoHalfHeight: padH,
+        depthRange: far - near,
+    };
+}
+/**
+ * Eight corners of the camera frustum, clipped to the model AABB — the region
+ * the camera can actually see (maintainer constraint #1 on #2670). Passing
+ * these to {@link fitSunLightMatrix} as `focusCorners` concentrates the shadow
+ * map on visible geometry instead of a site-scale model's whole footprint,
+ * which is what makes distant terrain steal all the resolution.
+ *
+ * Unlike unprojecting the clip cube, this builds the frustum from the camera
+ * BASIS at finite near/far distances derived from where the model sits along
+ * the view axis, so it never depends on a reverse-Z / infinite-far plane.
+ * Returns `null` when the model is entirely behind the camera (no usable
+ * focus — the caller falls back to a whole-bounds fit).
+ */
+export function cameraFrustumFocusCorners(p) {
+    const corners = aabbCorners(p.boundsMin, p.boundsMax);
+    // Depth span of the model along the view axis, relative to the eye.
+    let nearD = Infinity;
+    let farD = -Infinity;
+    for (const c of corners) {
+        const d = (c.x - p.eye.x) * p.forward.x + (c.y - p.eye.y) * p.forward.y + (c.z - p.eye.z) * p.forward.z;
+        if (d < nearD)
+            nearD = d;
+        if (d > farD)
+            farD = d;
+    }
+    if (!(farD > 1e-3))
+        return null; // model behind the camera
+    nearD = Math.max(nearD, 0.01);
+    const margin = Math.min(Math.max(p.margin ?? 0.15, 0), 2);
+    const half = (d) => {
+        const h = (p.ortho ? p.orthoHalfHeight : d * Math.tan(p.fovY / 2)) * (1 + margin);
+        return { w: h * p.aspect, h };
+    };
+    const out = [];
+    for (const d of [nearD, farD]) {
+        const { w, h } = half(d);
+        for (const sx of [-1, 1]) {
+            for (const sy of [-1, 1]) {
+                const x = p.eye.x + p.forward.x * d + p.right.x * (sx * w) + p.up.x * (sy * h);
+                const y = p.eye.y + p.forward.y * d + p.right.y * (sx * w) + p.up.y * (sy * h);
+                const z = p.eye.z + p.forward.z * d + p.right.z * (sx * w) + p.up.z * (sy * h);
+                out.push({
+                    x: Math.min(Math.max(x, p.boundsMin[0]), p.boundsMax[0]),
+                    y: Math.min(Math.max(y, p.boundsMin[1]), p.boundsMax[1]),
+                    z: Math.min(Math.max(z, p.boundsMin[2]), p.boundsMax[2]),
+                });
+            }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=shadow-light-matrix.js.map

package/dist/shadow-light-matrix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-light-matrix.js","sourceRoot":"","sources":["../src/shadow-light-matrix.ts"],"names":[],"mappings":"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"}