reze-engine 0.62.1 → 0.64.0

package/dist/shaders/passes/cull.js

@@ -129,10 +129,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/dist/shaders/passes/ground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAgFA;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,UAAQ,GAAG,MAAM,CAoWrD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AACxC,eAAO,MAAM,gBAAgB,QAAS,CAAA;AAEtC;;;oEAGoE;AACpE,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,+oCAiClC,CAAA"}
+{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAoFA;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,UAAQ,GAAG,MAAM,CAyUrD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AACxC,eAAO,MAAM,gBAAgB,QAAS,CAAA;AAEtC;;;oEAGoE;AACpE,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,+oCAiClC,CAAA"}

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/particles.d.ts

@@ -36,6 +36,15 @@ type ParticleSource = {
      *  where every stacked fragment is otherwise shaded in full; the prepass is
      *  the shape of that rejection, done by hand and cheaply. */
     cover: boolean;
+    /** The effect defines `particleOrient(p: Particle, id: u32) -> mat3x3f`: the
+     *  quad lies along its first two columns (right, up) instead of facing the
+     *  camera. A card that belongs to a surface — a raindrop's glow on a window,
+     *  a sheet of water standing in its fall — is flat on that surface and turns
+     *  with it, not with the eye: Unity's Local and World render alignments. The
+     *  particle's rotation still turns the corners within that plane, and a
+     *  stretched particle stretches along its velocity projected into it. `id`
+     *  is the particle's slot, so the axes can come from its emitter. */
+    orient?: boolean;
     /** The effect defines `particleCount() -> u32`: how many of the pool are
      *  live this frame, as a function of its dials. The step is dispatched and
      *  the quads drawn for that many slots and no more, through indirect
@@ -54,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;
@@ -79,6 +88,7 @@ export declare function particleEntryPoints(wgsl: string): {
     shade: boolean;
     cover: boolean;
     count: boolean;
+    orient: boolean;
 };
 /**
  * Spawn, age, recycle.

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

@@ -1 +1 @@
-{"version":3,"file":"particles.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/particles.ts"],"names":[],"mappings":"AAgCA,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAA;IACb;;mFAE+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAkCD,qDAAqD;AACrD;0EAC0E;AAC1E,KAAK,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAA;AAEpD,KAAK,cAAc,GAAG;IACpB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAA;IACpB,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAA;IACd;;+BAE2B;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;iEAK6D;IAC7D,KAAK,EAAE,OAAO,CAAA;IACd;;;;;;;kFAO8E;IAC9E,IAAI,EAAE,OAAO,CAAA;IACb;;;wEAGoE;IACpE,QAAQ,EAAE,MAAM,CAAA;IAChB;mDAC+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,0FAA0F;AAC1F,eAAO,MAAM,sBAAsB,KAAK,CAAA;AACxC,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC;;sDAEsD;AACtD,eAAO,MAAM,yBAAyB,KAAK,CAAA;AAC3C,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC;uCACuC;AACvC,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAC1C,eAAO,MAAM,gCAAgC,KAAK,CAAA;AAClD,eAAO,MAAM,6BAA6B,KAAK,CAAA;AAE/C,oEAAoE;AACpE,eAAO,MAAM,eAAe,KAAK,CAAA;AAwDjC;;2EAE2E;AAC3E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAQlI;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA6ExF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA6LvF"}
+{"version":3,"file":"particles.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/particles.ts"],"names":[],"mappings":"AAgCA,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAA;IACb;;mFAE+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAkCD,qDAAqD;AACrD;0EAC0E;AAC1E,KAAK,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,QAAQ,CAAA;AAEpD,KAAK,cAAc,GAAG;IACpB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAA;IACpB,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAA;IACd;;+BAE2B;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;iEAK6D;IAC7D,KAAK,EAAE,OAAO,CAAA;IACd;;;;;;;yEAOqE;IACrE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB;;;;;;;kFAO8E;IAC9E,IAAI,EAAE,OAAO,CAAA;IACb;;;wEAGoE;IACpE,QAAQ,EAAE,MAAM,CAAA;IAChB;mDAC+C;IAC/C,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,0FAA0F;AAC1F,eAAO,MAAM,sBAAsB,KAAK,CAAA;AACxC,iFAAiF;AACjF,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC;;sDAEsD;AACtD,eAAO,MAAM,yBAAyB,KAAK,CAAA;AAC3C,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC;uCACuC;AACvC,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAC1C,eAAO,MAAM,gCAAgC,KAAK,CAAA;AAClD,eAAO,MAAM,6BAA6B,KAAK,CAAA;AAE/C,oEAAoE;AACpE,eAAO,MAAM,eAAe,KAAK,CAAA;AAwDjC;;2EAE2E;AAC3E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CASnJ;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA6ExF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAiMvF"}

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;
@@ -114,6 +114,7 @@ fn rzCamPos() -> vec3f { return cam.camPos; }
  *  `count` is optional and bounds the frame's work — see particleCount. */
 export function particleEntryPoints(wgsl) {
     return {
+        orient: /\bfn\s+particleOrient\s*\(/.test(wgsl),
         init: /\bfn\s+particleInit\s*\(/.test(wgsl),
         step: /\bfn\s+particleStep\s*\(/.test(wgsl),
         shade: /\bfn\s+particleShade\s*\(/.test(wgsl),
@@ -283,9 +284,13 @@ fn vs(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> VSOut
     out.clip = vec4f(0.0, 0.0, -2.0, 1.0);
     return out;
   }
-  let right = vec3f(cam.view[0][0], cam.view[1][0], cam.view[2][0]);
-  let up = vec3f(cam.view[0][1], cam.view[1][1], cam.view[2][1]);
-  let s = sin(p.rot);
+  var right = vec3f(cam.view[0][0], cam.view[1][0], cam.view[2][0]);
+  var up = vec3f(cam.view[0][1], cam.view[1][1], cam.view[2][1]);
+${src.orient ? `  // the author's own plane (particleOrient): a card on a surface, not facing the eye
+  let o = particleOrient(p, ii);
+  right = o[0];
+  up = o[1];
+` : ""}  let s = sin(p.rot);
   let k = cos(p.rot);
   var r = vec2f(c.x * k - c.y * s, c.x * s + c.y * k);
   // Stretched along the direction of travel ON SCREEN — which is not the world

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

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

@@ -1,4 +1,4 @@
-import { SHADOW_CASCADES } from "../shadow-cascades";
+import { SHADOW_ATLAS_SIZE, SHADOW_CASCADES } from "../shadow-cascades";
 // The scene's own light, as an effect author sees it: the sun's shadow and the
 // world's ambient.
 //
@@ -49,30 +49,59 @@ fn rzWorldAmbientAvg() -> vec3f {
 }
 `;
 /**
- * 3×3 PCF over one cascade's map, for a point already in that cascade's NDC.
+ * The sun's shadow atlas, as every reader looks it up: `<p>Locate(q)` finds
+ * world point q in the first cascade whose box holds it and answers
+ * (atlas uv, depth, cascade) — cascade -1 outside them all — and `<p>Taps(a)`
+ * is the 3×3 PCF at that place.
  *
- * Shared with the materials, so an effect's shadow and her own shadow soften
- * alike. The sampler is linear-filtered, which makes each tap a 2×2 bilinear
- * compare. Unrolled — Safari's Metal backend doesn't unroll nested shadow
- * loops reliably. The body expects `ndc` in scope and returns.
+ * ONE implementation for the materials, the ground and effects, so a blade of
+ * grass and her own skin go dark at the same edge. `vp` names the cascades'
+ * view-projection array in the module that includes it.
+ *
+ * The box test keeps a margin (SHADOW_MARGIN of the tile's half-width) so the
+ * whole filter stays inside the tile: a tap that crossed into the neighbouring
+ * tile would compare against another cascade's depths. The sampler is linear,
+ * so each tap is itself a 2×2 compare. Unrolled — Safari's Metal backend
+ * doesn't unroll nested shadow loops reliably.
  */
-export const pcf9 = (map, ts, sampler = "shadowSampler") => /* wgsl */ `
-  let suv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
-  let cmpZ = ndc.z - 0.001;
-  let ts = ${ts};
-  let s00 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, -ts), cmpZ);
-  let s10 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0, -ts), cmpZ);
-  let s20 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, -ts), cmpZ);
-  let s01 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts, 0.0), cmpZ);
-  let s11 = textureSampleCompareLevel(${map}, ${sampler}, suv, cmpZ);
-  let s21 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts, 0.0), cmpZ);
-  let s02 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(-ts,  ts), cmpZ);
-  let s12 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f(0.0,  ts), cmpZ);
-  let s22 = textureSampleCompareLevel(${map}, ${sampler}, suv + vec2f( ts,  ts), cmpZ);
+export const SHADOW_MARGIN = 0.98;
+export const sunShadowWgsl = (p, map, sampler, vp) => {
+    const n = SHADOW_CASCADES.length;
+    const tiles = SHADOW_CASCADES.map((c) => `vec2f(${c.origin[0] / SHADOW_ATLAS_SIZE}, ${c.origin[1] / SHADOW_ATLAS_SIZE})`).join(", ");
+    const scale = SHADOW_CASCADES[0].mapSize / SHADOW_ATLAS_SIZE;
+    return /* wgsl */ `
+const ${p}Tiles = array<vec2f, ${n}>(${tiles});
+
+fn ${p}Locate(q: vec3f) -> vec4f {
+  for (var i = 0u; i < ${n}u; i++) {
+    let c = ${vp}[i] * vec4f(q, 1.0);
+    let ndc = c.xyz / max(c.w, 1e-6);
+    if (all(abs(ndc.xy) < vec2f(${SHADOW_MARGIN})) && ndc.z > 0.0 && ndc.z < 1.0) {
+      let uv = ${p}Tiles[i] + vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5) * ${scale};
+      return vec4f(uv, ndc.z, f32(i));
+    }
+  }
+  return vec4f(0.0, 0.0, 0.0, -1.0);
+}
+
+fn ${p}Taps(a: vec4f) -> f32 {
+  let cmpZ = a.z - 0.001;
+  let ts = ${1 / SHADOW_ATLAS_SIZE};
+  let s00 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(-ts, -ts), cmpZ);
+  let s10 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(0.0, -ts), cmpZ);
+  let s20 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f( ts, -ts), cmpZ);
+  let s01 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(-ts, 0.0), cmpZ);
+  let s11 = textureSampleCompareLevel(${map}, ${sampler}, a.xy, cmpZ);
+  let s21 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f( ts, 0.0), cmpZ);
+  let s02 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(-ts,  ts), cmpZ);
+  let s12 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f(0.0,  ts), cmpZ);
+  let s22 = textureSampleCompareLevel(${map}, ${sampler}, a.xy + vec2f( ts,  ts), cmpZ);
   return (s00 + s10 + s20 + s01 + s11 + s21 + s02 + s12 + s22) * (1.0 / 9.0);
+}
 `;
+};
 /** Bindings the real accessors take, from `binding` upward. */
-export const SCENE_LIGHT_API_BINDINGS = 5;
+export const SCENE_LIGHT_API_BINDINGS = 4;
 /**
  * `rzShadow(p)`: how much of the sun reaches world point `p` — 1 lit, 0 in a
  * caster's shadow, soft in between.
@@ -80,12 +109,11 @@ export const SCENE_LIGHT_API_BINDINGS = 5;
  * `rzWorldAmbient(n)`: the world's light arriving at a surface facing `n` —
  * the materials' own ambient, so an effect's shade can match hers.
  *
- * With `on`, declares five bindings from `binding`:
+ * With `on`, declares four bindings from `binding`:
  *   +0 the light uniform (ambient, the sun — direction, and in .w the shadow
  *      switch — and the HDRI's irradiance)
  *   +1 the cascade view-projections, then the caster sphere
- *   +2 the near cascade's map   +3 the far cascade's map
- *   +4 the comparison sampler
+ *   +2 the sun's shadow atlas   +3 the comparison sampler
  *
  * It takes a POINT and no normal. The materials' sampleShadow also rejects a
  * surface facing away from the sun, which is right for skin and wrong for a
@@ -110,17 +138,9 @@ struct _RzSceneLightU { ambientColor: vec4f, lights: array<_RzSceneLight, 4>, sh
 struct _RzShadowBlock { viewProj: array<mat4x4f, ${n}>, casters: vec4f, }
 @group(${group}) @binding(${binding}) var<uniform> _rzLight: _RzSceneLightU;
 @group(${group}) @binding(${binding + 1}) var<uniform> _rzShadowVP: _RzShadowBlock;
-@group(${group}) @binding(${binding + 2}) var _rzShadowNear: texture_depth_2d;
-@group(${group}) @binding(${binding + 3}) var _rzShadowFar: texture_depth_2d;
-@group(${group}) @binding(${binding + 4}) var _rzShadowCmp: sampler_comparison;
-
-fn _rzShadowNearTaps(ndc: vec3f) -> f32 {
-${pcf9("_rzShadowNear", `1.0 / ${SHADOW_CASCADES[0].mapSize}.0`, "_rzShadowCmp")}
-}
-
-fn _rzShadowFarTaps(ndc: vec3f) -> f32 {
-${pcf9("_rzShadowFar", `1.0 / ${SHADOW_CASCADES[n - 1].mapSize}.0`, "_rzShadowCmp")}
-}
+@group(${group}) @binding(${binding + 2}) var _rzShadowAtlas: texture_depth_2d;
+@group(${group}) @binding(${binding + 3}) var _rzShadowCmp: sampler_comparison;
+${sunShadowWgsl("_rzSun", "_rzShadowAtlas", "_rzShadowCmp", "_rzShadowVP.viewProj")}
 
 fn rzShadow(p: vec3f) -> f32 {
   // The scene's one shadow switch, on the sun — see sampleShadow.
@@ -138,18 +158,10 @@ fn rzShadow(p: vec3f) -> f32 {
     let perp = length(toCaster - toSun * along);
     if (along <= -cs.w || perp > cs.w) { return 1.0; }
   }
-  let q = p + toSun * 0.08;
-  let c0 = _rzShadowVP.viewProj[0] * vec4f(q, 1.0);
-  let n0 = c0.xyz / max(c0.w, 1e-6);
-  if (all(abs(n0.xy) < vec2f(0.98)) && n0.z > 0.0 && n0.z < 1.0) {
-    return mix(1.0, _rzShadowNearTaps(n0), castAmt);
-  }
-  let c1 = _rzShadowVP.viewProj[${n - 1}] * vec4f(q, 1.0);
-  let n1 = c1.xyz / max(c1.w, 1e-6);
-  if (all(abs(n1.xy) < vec2f(0.98)) && n1.z > 0.0 && n1.z < 1.0) {
-    return mix(1.0, _rzShadowFarTaps(n1), castAmt);
-  }
-  return 1.0;
+  let a = _rzSunLocate(p + toSun * 0.08);
+  // Outside every cascade there is no occlusion information: lit.
+  if (a.w < 0.0) { return 1.0; }
+  return mix(1.0, _rzSunTaps(a), castAmt);
 }
 ${worldAmbientWgsl("_rzLight")}`;
 }

package/dist/shadow-cascades.d.ts

@@ -1,34 +1,47 @@
+import { Vec3 } from "./math";
 /**
  * THE SUN'S SHADOW FOLLOWS THE CAMERA, the way Blender's does.
  *
- * Each cascade is fitted every frame to a slice of the view frustum: the near
- * one to the stretch around what the camera is looking at, the far one to the
- * whole of what it sees. Whatever is in view is in a cascade, and whatever
- * could throw a shadow onto it is in the cascade's depth range, which is fitted
- * to the scene's bounds along the light. A room forty metres across with its
- * window frames behind the camera shadows its floor as the game does; a lone
- * dancer on an empty floor keeps a crisp near map.
+ * Each cascade is fitted every frame to a slice of the view frustum: the
+ * innermost to the stretch around what the camera is looking at, the
+ * outermost to the whole of what it sees, two more between. Whatever is in
+ * view is in a cascade, and whatever could throw a shadow onto it is in the
+ * cascade's depth range, which is fitted to the scene's bounds along the
+ * light. A room forty metres across with its window frames behind the camera
+ * shadows its floor as the game does; a lone dancer on an empty floor keeps a
+ * crisp inner tile.
  *
- * The earlier shape was two fixed boxes around the camera target, 64 and 256
- * units across, and a stage reached past them: the floor near the windows lay
- * outside every box and was drawn lit, the shadows stopping at the box's edge
- * in a straight line.
+ * The earlier shapes were two fixed boxes around the camera target, then two
+ * fitted maps; the game's pipeline draws four cascades into one atlas, and so
+ * does this.
  *
- * INVARIANT the sampler and the cull both lean on: the outer cascade CONTAINS
- * the inner one. The sampler falls from cascade 0 to 1 at the box edge, which
- * is only seamless if 1 covers where 0 ends, and the cull tests the OUTERMOST
- * frustum alone. Both hold because the outer slice is the whole frustum, of
- * which the inner slice is a part, and both take the same depth range.
+ * INVARIANT the sampler and the cull both lean on: each cascade CONTAINS the
+ * ones inside it. The sampler takes the first box that holds a point, which
+ * is only seamless if the next covers where one ends, and the cull tests the
+ * OUTERMOST frustum alone. Both hold because every slice starts at the near
+ * plane and the outermost is the whole frustum, and all take the same depth
+ * range.
  * tests/shadow-cascades.test.mjs pins it.
  */
 export type ShadowCascade = {
-    /** Texels per side of this cascade's map — sets the snap quantum. */
+    /** Texels per side of this cascade's tile — sets the snap quantum. */
     mapSize: number;
+    /** Where the tile sits in the atlas, in texels from its top-left corner. */
+    origin: readonly [number, number];
 };
+/**
+ * ONE ATLAS, FOUR TILES, as the game's pipeline (and URP) lays its sun shadow
+ * out: one depth texture, cascade i in tile (i mod 2, i div 2). One texture
+ * means one binding for every reader — materials, ground, effects, particles —
+ * and room in the same scheme for the local lights' shadows later.
+ */
+export declare const SHADOW_ATLAS_SIZE = 4096;
 export declare const SHADOW_CASCADES: readonly ShadowCascade[];
-/** How far past the camera's point of interest the near cascade reaches, in
- *  world units: the dancer and the floor around her, at the near map's texel. */
-export declare const NEAR_REACH = 40;
+/** How far past the camera's point of interest the inner cascade reaches, in
+ *  world units: the dancer and the floor around her. Half the old two-map
+ *  reach, which keeps her texel where it was at half the tile; the three
+ *  outer cascades carry the rest of the room. */
+export declare const NEAR_REACH = 20;
 /** The view the cascades are fitted to: the camera's eye and basis (world
  *  space, left-handed, +Z forward as the projection is), its vertical field of
  *  view, aspect and clip planes, and how far away the thing it looks at is. */
@@ -70,6 +83,14 @@ type XYZ = {
     y: number;
     z: number;
 };
+/**
+ * Where each cascade's slice of the view starts and ends, as distances along
+ * the view, inner to outer: every slice starts at the near plane and they
+ * nest, the innermost ending just past the point of interest and the
+ * outermost where the scene ends, the two between spaced evenly in ratio.
+ * Nested rather than abutting so the invariant above holds: the outermost
+ * box contains all of them, and the sampler takes the first that holds a point.
+ */
 export declare function cascadeSlices(view: ShadowView, bounds: ShadowBounds): [number, number][];
 /** The eight corners of a slice, for tests and for the fit's own checks. */
 export declare function sliceCorners(view: ShadowView, n: number, f: number): XYZ[];
@@ -83,6 +104,12 @@ export declare function sliceCorners(view: ShadowView, n: number, f: number): XY
  * Writes the 16 floats into `out` at `offset` and returns `out`.
  */
 export declare function fitShadowVP(view: ShadowView, slice: [number, number], sunDirection: XYZ, bounds: ShadowBounds, cascade: ShadowCascade, out: Float32Array, offset: number): Float32Array;
+/** Every cascade's bounding sphere (centre, radius), inner to outer — the
+ *  split spheres a game shader picks its cascade by (_CascadeShadowSplitSpheres). */
+export declare function cascadeSpheres(view: ShadowView, bounds: ShadowBounds): {
+    center: Vec3;
+    radius: number;
+}[];
 /** Every cascade's view-projection in a row, inner to outer. */
 export declare function buildShadowCascades(view: ShadowView, sunDirection: XYZ, bounds: ShadowBounds, out: Float32Array): Float32Array;
 export {};

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

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