reze-engine 0.62.1 → 0.64.0

package/src/graph/compile.ts

@@ -344,9 +344,11 @@ export function compileGraph(graph: ShaderGraph, opts: CompileOptions = {}): Com
   }
 
   const lines: string[] = []
+  let nodeTakesLight = false
   for (const id of order) {
     const node = nodes.get(id)!
     const s = spec(node)
+    if (s.takesLight) nodeTakesLight = true
     if (s.contextOutputs) continue
     const args: Record<string, Resolved> = {}
     for (const [socket, input] of Object.entries(s.inputs)) args[socket] = resolveInput(node, socket, input.type)
@@ -360,7 +362,7 @@ export function compileGraph(graph: ShaderGraph, opts: CompileOptions = {}): Com
   const fsBody = lines.join("\n")
   // A graph takes light when its body reads any: the four shading nodes all
   // pass `sun, amb`, and a hand-written node reaching for the lamps names them.
-  const takesLight = /\bsun\b|\bamb\b|rzLight|rzLamp/.test(fsBody)
+  const takesLight = nodeTakesLight || /\bsun\b|\bamb\b|rzLight|rzLamp/.test(fsBody)
   const wgsl = assembleModule(opts.renderClass ?? "auto", opts.alphaMode ?? "opaque", fsBody, usesStyle.current, !!opacity, opts.blend ?? "over", takesLight)
   return { ok: true, wgsl, fsBody, slotMap, diagnostics, prunedNodes }
 }

package/src/graph/registry.ts

@@ -26,6 +26,9 @@ export type NodeSpec = {
   contextOutputs?: Record<string, string>
   /** Swizzle applied to the node's variable per output socket (default: none). */
   outputSelect?: Record<string, string>
+  /** The node shades by the scene's light without naming it: its graph takes
+   *  the lamps and the fog as the four shading nodes' graphs do. */
+  takesLight?: boolean
 }
 
 // ─── Literal formatting ───────────────────────────────────────────────
@@ -125,6 +128,54 @@ function foldSpecular(ior: string, level: string): string {
   return fmtFloat(Number(((r * r * 2 * Math.max(l, 0)) / 0.08).toPrecision(9)))
 }
 
+const uberNode = (slot: number): NodeSpec => ({
+  inputs: {
+    base: C([1, 1, 1], true),
+    metallic: F(0),
+    roughness: F(0.6),
+    occlusion: F(1),
+    normal: { type: "vector", contextDefault: "n" },
+    direction: { type: "vector", requiresLink: true },
+    // Unity's v into the ramp: the property map's alpha, which picks a
+    // surface's band (skin 0.702, hair and pale cloth 0.506).
+    row: F(0.702),
+    receive_shadow: F(1),
+    rim_mask: F(1),
+    rim_mid: F(0.448),
+    rim_width: F(0.11),
+    rim_tint: C([0.9623, 0.9214, 0.9214]),
+    rim_intensity: F(1),
+    rim_albedo: F(0.9),
+    rim_in_light: F(1),
+    emission: C([0, 0, 0]),
+    reflection: F(1),
+    // A face's SDF shade (ag_face_sdf); left at -1, the material reads N·L.
+    shade: F(-1),
+    // 1: the game's FACE_MODE — no GGX, the environment at a flat 0.0157.
+    face: F(0),
+  },
+  outputs: { color: "color" },
+  emit: (a) =>
+    `ag_uber(${slot}u, ${a.base}, ${a.metallic}, ${a.roughness}, ${a.occlusion}, ${a.normal}, ${a.direction}, ${a.row}, ${a.receive_shadow}, ` +
+    `${a.rim_mask}, ${a.rim_mid}, ${a.rim_width}, ${a.rim_tint}, ${a.rim_intensity}, ${a.rim_albedo}, ${a.rim_in_light}, ${a.emission}, ${a.reflection}, ${a.shade}, ${a.face}, input.worldPos, v)`,
+  takesLight: true,
+})
+const UBER_NODES: Record<string, NodeSpec> = Object.fromEntries([0, 1, 2, 3].map((s) => [`ag_uber/${s}`, uberNode(s)]))
+// The face's SDF shade, the image on the slot the type names — 104903's face
+// template (SDF_04_shaonv) by default in the AG pack.
+const faceSdfNode = (slot: number): NodeSpec => ({
+  inputs: {
+    uv: { type: "vector", contextDefault: "vec3f(input.uv, 0.0)" },
+    direction: { type: "vector", requiresLink: true },
+    normal: { type: "vector", contextDefault: "n" },
+    smoothness: F(0.1),
+    invert: F(0),
+  },
+  outputs: { value: "float" },
+  emit: (a) => `ag_face_sdf(${slot}u, ${a.uv}.xy, ${a.direction}, ${a.normal}, ${a.smoothness}, ${a.invert})`,
+})
+const FACE_SDF_NODES: Record<string, NodeSpec> = Object.fromEntries([0, 1, 2, 3].map((s) => [`ag_face_sdf/${s}`, faceSdfNode(s)]))
+
 export const NODE_REGISTRY: Record<string, NodeSpec> = {
   // ── Context inputs (template locals; no emission) ──
   texture: {
@@ -454,6 +505,97 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
     emit: (a) => `group_tex3(${a.uv}.xy)`,
   },
 
+  // ── Aether Gazer's character shading ──
+  // The game's character shader (SimPipeline/Character/Debug, which most of its
+  // characters wear), taken apart into the steps it runs — see ag_* in
+  // nodes.ts for each step's derivation from the decompiled pass. A graph
+  // composes them as the game did: a ramp lookup driven by the key light, a
+  // matcap, a reflection, the rim and the fill, with the ramp and matcap
+  // images on the style group's slots.
+
+  // The key light: CharacterEffect's direction, held in a frame that turns
+  // with the camera about the vertical (sim_TowardMatrix) — the game lights a
+  // character from where the viewer is, not from the scene's sun.
+  ag_key_light: {
+    inputs: { inclination: F(24), azimuth: F(-28) },
+    outputs: { direction: "vector" },
+    emit: (a) => `ag_key_light(${a.inclination}, ${a.azimuth})`,
+  },
+  // Where on the shadow ramp this point falls: N·L under the mask's occlusion,
+  // and the sun's cast shadow on top when the character receives it.
+  ag_shade_term: {
+    inputs: {
+      normal: { type: "vector", contextDefault: "n" },
+      direction: { type: "vector", requiresLink: true },
+      occlusion: F(1),
+      occlusion_scale: F(1),
+      receive_shadow: F(1),
+    },
+    outputs: { value: "float" },
+    emit: (a) => `ag_shade_term(${a.normal}, ${a.direction}, ${a.occlusion}, ${a.occlusion_scale}, ${a.receive_shadow}, input.worldPos)`,
+    takesLight: true,
+  },
+  // A ramp image's coordinate: u from the shade term, v the ramp's row (the
+  // game's property map picks it per texel; a PMX carries one per material).
+  ag_ramp_uv: {
+    inputs: { value: F(0), row: F(0.5) },
+    outputs: { uv: "vector" },
+    emit: (a) => `ag_ramp_uv(${a.value}, ${a.row})`,
+  },
+  // The view-space reflection the matcap, the reflection map, the rim and the
+  // fill all read: its uv into a sphere image, and how much it faces the eye.
+  ag_view_reflection: {
+    inputs: { normal: { type: "vector", contextDefault: "n" } },
+    outputs: { uv: "vector", facing: "float" },
+    outputSelect: { uv: ".xyz", facing: ".w" },
+    emit: (a) => `ag_view_reflection(${a.normal}, v)`,
+  },
+  // The matcap's lift: a metal's shine, at least 1, where the mask says.
+  ag_matcap: {
+    inputs: { color: C([1, 1, 1], true), matcap: C([1, 1, 1]), strength: F(1), mask: F(1) },
+    outputs: { color: "color" },
+    emit: (a) => `ag_matcap(${a.color}, ${a.matcap}, ${a.strength}, ${a.mask})`,
+  },
+  // The rim: the two fixed screen-side directions CharacterEffect sets, cut to
+  // the silhouette, laid on as a colour dodge where the mask allows.
+  ag_rim: {
+    inputs: {
+      color: C([1, 1, 1], true),
+      facing: F(1),
+      uv: { type: "vector", requiresLink: true },
+      rim_color: C([0.8584906, 0.8584906, 0.8584906]),
+      threshold: F(0.1),
+      fade: F(0.113),
+      range: F(0.444),
+      inclination: F(0),
+      azimuth1: F(0.8499963),
+      azimuth2: F(1),
+      mask: F(1),
+    },
+    outputs: { color: "color" },
+    emit: (a) =>
+      `ag_rim(${a.color}, ${a.facing}, ${a.uv}, ${a.rim_color}, ${a.threshold}, ${a.fade}, ${a.range}, ${a.inclination}, ${a.azimuth1}, ${a.azimuth2}, ${a.mask})`,
+  },
+  // The fill: a colour laid toward the silhouette, inner to outer.
+  ag_fill: {
+    inputs: {
+      color: C([1, 1, 1], true),
+      facing: F(1),
+      inner: C([0, 0, 0]),
+      outer: C([0, 0, 0]),
+      amount: F(0),
+      softness: F(0),
+    },
+    outputs: { color: "color" },
+    emit: (a) => `ag_fill(${a.color}, ${a.facing}, ${a.inner}, ${a.outer}, ${a.amount}, ${a.softness})`,
+  },
+
+  // Aether Gazer's current character shading (PBR/Uber) as one closure, the way
+  // Principled is one: the ramp image on the group slot named by the type.
+  // Defaults are 104903's skin.
+  ...UBER_NODES,
+  ...FACE_SDF_NODES,
+
   // ── Blender 5.2 colour utilities ──
   separate_color: {
     inputs: { color: C([1, 1, 1], true) },

package/src/graph/schema.ts

@@ -66,6 +66,15 @@ export type ShaderGraph = {
    *  matching (e.g. ["hair"]). Ignored by the compiler; round-tripped. A graph is pure
    *  shading — pass integration lives on the style group's renderClass, not here. */
   tags?: string[]
+  /**
+   * The images this look samples on `tex_image/0`…`tex_image/3`, by URL —
+   * a ramp, a matcap, the maps a game's look is built on. They belong to the
+   * LOOK, not to the model it is put on: they are read at coordinates the
+   * shading computes (a light amount, a reflection), never at the mesh's uvs,
+   * so one graph carries them to any model. A style group that brings its own
+   * images keeps those.
+   */
+  images?: ({ url: string; srgb?: boolean } | null)[]
 }
 
 export type Diagnostic = {

package/src/graph/slots.ts

@@ -137,20 +137,17 @@ ${discard}
   var n = safe_normal(input.normal);
   let v = normalize(camera.viewPos - input.worldPos);${flip}
 ${gate}
-  let l = -light.lights[0].direction.xyz;
-  let sun = select(light.lights[0].color.xyz * light.lights[0].color.w, modelLight.sun.rgb, modelLight.sun.w > 0.5);
+  // The key: the directional light this draw's layers take — the sun unless a
+  // light on its own layer stands in. The shadow stays the sun's atlas, as the
+  // game keeps the scene's shadow under a character's own key.
+  let rz_key = rzMainLight();
+  let l = -light.lights[rz_key].direction.xyz;
+  let sun = light.lights[rz_key].color.xyz * light.lights[rz_key].color.w;
   let shadow = sampleShadow(input.worldPos, n);
-  // The world: flat colour, or the HDRI's irradiance at this normal — which
-  // is what makes a loaded sky actually light her instead of only backing her.
-  // The model's fill is NOT here: see the epilogue.
-  //
-  // A model given a flat sky (setModelFlatSky - the cast, for an anime look)
-  // takes the sky's AVERAGE instead: its colour and brightness from every
-  // direction alike. The directional sky shaded a face like PBR - soft
-  // realistic gradients the toon ramp never drew - where the game gives its
-  // characters one flat base light. A flat World is its own average, so a
-  // scene without an HDRI renders exactly as before.
-  let amb = select(rzWorldAmbient(n), rzWorldAmbientAvg(), modelLight.opts.x > 0.5);
+  // The ambient: this object's own where loaded data gave it one — the game
+  // gives every renderer its own — else the world's flat colour or the HDRI's
+  // irradiance at this normal.
+  let amb = rzObjectAmbient(n);
   let tex_color = tex_s.rgb;
   // The normal the lamps' diffuse layer is lit by, for a principled walk to
   // compute it on the way (rzLightsDiffuseOnce). n is final from here on.
@@ -194,13 +191,7 @@ function epilogue(renderClass: RenderClass, alphaMode: AlphaMode, hasOpacity: bo
   // painted sheet — is Blender's Emission shader, which no lamp reaches; adding
   // the lamps to it turned X340's floor shadow, a white-RGB picture at a soft
   // alpha, into a glowing disc under the spot above it.
-  //
-  // The model's fill (Engine.setModelFill) rides here too, as brightness: the
-  // surface colour times the fill, on every pixel of her alike. It used to
-  // enter the graph's ambient, where an NPR ramp read it as LIGHT — sliding it
-  // moved her shadows, and under a hard step flipped whole regions at once.
-  // After the graph it lifts her evenly and leaves every shadow where it is.
-  const LIT = takesLight ? ` + (rzLightsDiffuseOnce(input.worldPos, n) + modelLight.fill.rgb) * albedo` : ""
+  const LIT = takesLight ? ` + rzLightsDiffuseOnce(input.worldPos, n) * albedo` : ""
 
   const ALBEDO = `  let albedo = tex_color;
 `

package/src/index.ts

@@ -19,6 +19,8 @@ export {
   type MaterialPresetMap,
   type ModelTransform,
   type SceneLight,
+  RENDERING_LAYER_DEFAULT,
+  RENDERING_LAYER_CHARACTER,
   type ModelAttachment,
   type GizmoDragEvent,
   type GizmoDragCallback,
@@ -215,3 +217,12 @@ export {
  */
 export { EFFECT_MATH_API, PARTICLE_STRUCT_WGSL } from "./shaders/passes/hosted-api"
 export type { EyeTrackingOptions } from "./model"
+
+/**
+ * The game's own materials (src/unity): a stage package drawn by its translated
+ * shaders (Engine.setNativeStage) and a model dressed in a native look
+ * (Engine.setModelNativeLook) — the shapes their files take.
+ */
+export type { NativeStagePackage, NativeStageReader } from "./unity/stage"
+export type { NativeLook, NativeMaterialSpec, NativeTexture } from "./unity/looks"
+export type { NativeShader, NativeShaderInfo } from "./unity/host"

package/src/shaders/lights.ts

@@ -28,7 +28,8 @@ import { subjectMaskApi } from "./cast-api"
 //   [0..2] position, world space               [3] radius
 //   [4..6] colour PREMULTIPLIED by intensity   [7] type
 //   [8..10] aim, unit, pointing away from the light   [11] cos of the outer angle
-//   [12] cos of the inner angle                [13..15] spare
+//   [12] cos of the inner angle
+//   [13] the rendering layers it does NOT reach (u32 bits)   [14..15] spare
 //
 // then the grid: LIGHT_MASK_WORDS words of lamp bits per cell.
 //
@@ -40,6 +41,12 @@ import { subjectMaskApi } from "./cast-api"
 // branchless: it stores aim (0,0,0) and both cosines at -1, which makes the
 // cone term below saturate to exactly 1. `type` says which a light is for
 // anyone reading the buffer; the shading never asks.
+//
+// LAYERS, as the game's pipeline (URP's rendering layers) gates its lights: a
+// draw carries layer bits, and a light reaches it only where its own mask
+// shares one. Stored INVERTED — the layers a light does not reach — so the
+// zero every writer that predates layers leaves in [13] reaches everything,
+// which is what an effect's lamp and a plain document light mean.
 
 import { castDistanceStub } from "./passes/cast-distance"
 import { audioApi } from "./audio-api"
@@ -243,8 +250,9 @@ fn lightEmitMain(@builtin(global_invocation_id) gid: vec3u) {
 `
 }
 
-/** The rz*Light accessors, with the buffer declared at the given binding. */
-export function lightsApi(group: number, binding: number): string {
+/** The rz*Light accessors, with the buffer declared at the given binding.
+ *  `layers` is the WGSL expression for the drawing's rendering-layer bits. */
+export function lightsApi(group: number, binding: number, layers: string): string {
   const R = LIGHT_HEADER / 4
   const S = LIGHT_STRIDE / 4
   return /* wgsl */ `
@@ -286,6 +294,10 @@ fn rzLightAim(i: u32) -> vec3f { return _rzLightVec(i, 2u).xyz; }
  *  light stores (-1, -1), which saturates the cone term to 1. */
 fn rzLightCone(i: u32) -> vec2f { return vec2f(_rzLightVec(i, 2u).w, _rzLightVec(i, 3u).x); }
 
+/** Does light i reach this drawing's rendering layers? Read as bits, never as
+ *  a float — see the layout. */
+fn _rzLightReaches(i: u32) -> bool { return ((${layers}) & ~_rzLights[${R}u + i * ${S}u + 3u].y) != 0u; }
+
 /** The document lamps that can reach p: its grid cell's bits, or the outside
  *  mask beyond the grid. Written so a NaN position fails the inside test. */
 fn _rzLightCellMask(p: vec3f) -> vec4u {
@@ -312,6 +324,7 @@ fn _rzLightCellMask(p: vec3f) -> vec4u {
  * writes in candela over 683.
  */
 fn _rzLightOne(i: u32, p: vec3f, n: vec3f) -> vec3f {
+  if (!_rzLightReaches(i)) { return vec3f(0.0); }
   let pr = _rzLightVec(i, 0u);
   let d = pr.xyz - p;
   let dist = length(d);

package/src/shaders/materials/common.ts

@@ -1,7 +1,7 @@
 import { sceneFsOutWgsl } from "../passes/scene-contract"
 import { lightsApi } from "../lights"
 import { SHADOW_CASCADES } from "../../shadow-cascades"
-import { pcf9 } from "../scene-light-api"
+import { sunShadowWgsl } from "../scene-light-api"
 import { WORLD_AMBIENT_WGSL } from "../lights"
 
 // Shared WGSL blocks concatenated by every material shader.
@@ -61,6 +61,9 @@ struct LightUniforms {
    *  amount 0 is off. Then the view-projection its map was drawn with. */
   castShadow: vec4f,
   castVP: mat4x4f,
+  /** The rendering layers each directional light reaches, slot by slot — a
+   *  draw is lit by the first whose bits it shares (rzMainLight). */
+  dirLayers: vec4u,
 };
 
 // Per-material uniforms. Every material binds this layout even if it ignores fields;
@@ -148,13 +151,10 @@ 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 diffuseSampler: sampler;
-@group(0) @binding(3) var shadowMap: texture_depth_2d;
+// The sun's shadow atlas: every cascade in its own tile — see shadow-cascades.ts.
+@group(0) @binding(3) var shadowAtlas: texture_depth_2d;
 @group(0) @binding(4) var shadowSampler: sampler_comparison;
 @group(0) @binding(5) var<uniform> lightVP: LightVP;
-// The far cascade's map — coarser texels over a much wider box, so the stage
-// keeps its shadows when the crisp near volume ends. Binding 7: 6 is the
-// positional lights, 9 the BRDF LUT.
-@group(0) @binding(7) var shadowMapFar: texture_depth_2d;
 // The world's own sky, for a surface that REFLECTS it rather than merely being
 // lit by it. Equirect, in the same layout and the same linear radiance the
 // composite draws the dome from, and mipped — a rough surface reads a coarser
@@ -188,14 +188,37 @@ fn _rzCastShadow(wp: vec3f) -> f32 {
 }
 // binding(9) brdfLut is declared inside NODES_WGSL (nodes.ts).
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
-// The light this model takes apart from the scene's — see Engine.setModelFill
-// and Engine.setModelSun. fill brightens it after its graph (fill ×
-// surface colour, graph/slots.ts), zero for a model nobody gave one; sun replaces the scene's sun colour while its w is set,
-// which is how a stage keeps the daylight its game lit it by while the cast
-// keeps the key the scene set for them. opts.x (Engine.setModelFlatSky) gives
-// it the sky's average in place of its shape - see graph/slots.ts.
-struct ModelLight { fill: vec4f, sun: vec4f, opts: vec4f }
-@group(1) @binding(1) var<uniform> modelLight: ModelLight;
+// What this object's lighting is, apart from the scene's, as the game's
+// pipeline gives each renderer its own:
+//   layers.x  its rendering-layer bits, which decide the lights that reach it —
+//             a stage's daylight and the cast's key are two lights on two
+//             layers, as the game lights them;
+//   ambient.x 1 while it has an ambient of its own (Engine.setModelAmbient),
+//             0 for the world's;
+//   sh        that ambient's irradiance, folded as the world's (ibl.ts).
+struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9> }
+@group(1) @binding(1) var<uniform> objectLight: ObjectLight;
+
+/** The light arriving at a surface of this object facing n: its own ambient
+ *  where loaded data gave it one (a stage's probes, a character's), else the
+ *  world's. The same polynomial rzWorldAmbient evaluates. */
+fn rzObjectAmbient(n: vec3f) -> vec3f {
+  if (objectLight.ambient.x < 0.5) { return rzWorldAmbient(n); }
+  let s = objectLight.sh;
+  let c = s[0].xyz + s[1].xyz * n.y + s[2].xyz * n.z + s[3].xyz * n.x
+    + s[4].xyz * (n.x * n.y) + s[5].xyz * (n.y * n.z) + s[6].xyz * (3.0 * n.z * n.z - 1.0)
+    + s[7].xyz * (n.x * n.z) + s[8].xyz * (n.x * n.x - n.y * n.y);
+  return max(c, vec3f(0.0));
+}
+
+/** The directional light slot that lights this draw: the first whose layers
+ *  it shares, else the sun's. */
+fn rzMainLight() -> u32 {
+  for (var k = 0u; k < 4u; k++) {
+    if ((light.dirLayers[k] & objectLight.layers.x) != 0u) { return k; }
+  }
+  return 0u;
+}
 @group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
 @group(2) @binding(1) var<uniform> material: MaterialUniforms;
 // Reserved for future sphere/toon graph nodes; graphs that don't read them get the
@@ -226,58 +249,41 @@ fn safe_normal(nIn: vec3f) -> vec3f {
 `;
 
 // ─── Shadow sampler (3×3 PCF, cascade-selected) ─────────────────────
-// Normal-bias 0.08, depth-bias 0.001 NDC; the kernel is pcf9 in scene-light-api.ts,
-// shared with effects. Texel sizes are interpolated
-// from SHADOW_CASCADES so they cannot go stale the way the hardcoded 1/2048
-// once did (PCF taps landed TWO texels apart after the map grew to 4096,
-// quantizing self-shadow edges into crawling gray squares).
+// Normal-bias 0.08, depth-bias 0.001 NDC; the lookup is sunShadowWgsl in
+// scene-light-api.ts, shared with the ground and effects.
 //
-// Selection: the crisp near cascade wherever its box covers the point — with a
-// margin that keeps the whole PCF kernel inside the map, so selection never
-// mixes maps mid-kernel — else the far cascade, else LIT. Lit is a fix, not
-// merely a default: the old single-volume path clamped, and past the light's
-// far plane the comparison failed against every stored depth, silently
-// shadowing any stage deeper than the box.
-
+// Selection: the first cascade whose box covers the point — with a margin that
+// keeps the whole PCF kernel inside its tile — else LIT. Lit is a fix, not
+// merely a default: past every cascade there is no occlusion information, and
+// comparing against unrelated depths would silently shadow any stage deeper
+// than the boxes.
 
 const SAMPLE_SHADOW_WGSL = /* wgsl */ `
+${sunShadowWgsl("_rzSun", "shadowAtlas", "shadowSampler", "lightVP.viewProj")}
 
-fn sampleShadowNear(ndc: vec3f) -> f32 {
-${pcf9("shadowMap", `1.0 / ${SHADOW_CASCADES[0].mapSize}.0`)}
-}
-
-fn sampleShadowFar(ndc: vec3f) -> f32 {
-${pcf9("shadowMapFar", `1.0 / ${SHADOW_CASCADES[SHADOW_CASCADES.length - 1].mapSize}.0`)}
+/** The sun's cast shadow alone, without sampleShadow's facing test: what a
+ *  character's ramp is min'd with (its own N·L carries the terminator). */
+fn rzSunOcclusion(worldPos: vec3f, n: vec3f) -> f32 {
+  let castAmt = light.lights[0].direction.w;
+  if (castAmt <= 0.0) { return 1.0; }
+  let a = _rzSunLocate(worldPos + n * 0.08);
+  if (a.w < 0.0) { return 1.0; }
+  return mix(1.0, _rzSunTaps(a), castAmt);
 }
 
 fn sampleShadow(worldPos: vec3f, n: vec3f) -> f32 {
   // THE SCENE'S ONE SHADOW SWITCH, and it lives on the sun because the sun is
-  // the only thing that casts. Positional lamps are diffuse-only — rzLightsDiffuse
-  // has no shadow term at all — so turning this off turns off every shadow there
-  // is, on the ground and on the cast alike. Gated here rather than by not
-  // rendering the map: the map is also what the ground catcher reads, and a host
-  // that wants a figure lit with no shadow still wants everything else about the
-  // frame unchanged.
-  //
-  // Lit is the answer when it is off. Returning 0 would be "fully shadowed",
-  // which is the opposite of what a disabled shadow means.
+  // the only thing that casts. Lit is the answer when it is off: returning 0
+  // would be "fully shadowed", the opposite of what a disabled shadow means.
   let castAmt = light.lights[0].direction.w;
   if (castAmt <= 0.0) { return 1.0; }
-  if (dot(n, -light.lights[0].direction.xyz) <= 0.0) { return 0.0; }
-  let biasedPos = worldPos + n * 0.08;
-  let c0 = lightVP.viewProj[0] * vec4f(biasedPos, 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, sampleShadowNear(n0), castAmt);
-  }
-  let c1 = lightVP.viewProj[1] * vec4f(biasedPos, 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, sampleShadowFar(n1), castAmt);
-  }
-  // Outside every cascade there is no occlusion information; lit is the only
-  // honest answer.
-  return 1.0;
+  // A surface turned from the sun is in its own shade — when the sun is what
+  // keys it. Under a key of its own layer the atlas is only the occluders'
+  // shadow, and the key's N·L decides its terminator.
+  if (rzMainLight() == 0u && dot(n, -light.lights[0].direction.xyz) <= 0.0) { return 0.0; }
+  let a = _rzSunLocate(worldPos + n * 0.08);
+  if (a.w < 0.0) { return 1.0; }
+  return mix(1.0, _rzSunTaps(a), castAmt);
 }
 
 `;
@@ -499,4 +505,4 @@ fn rz_dissolve_threshold(restPos: vec3f) -> f32 {
 // The FSOut struct is NOT in here any more — see commonFsOutWgsl above. Every
 // consumer of this constant appends it immediately, which is where it was.
 export const COMMON_MATERIAL_PRELUDE_WGSL =
-  COMMON_BINDINGS_WGSL + WORLD_AMBIENT_WGSL + lightsApi(0, 6) + SAMPLE_SHADOW_WGSL + COMMON_VS_WGSL
+  COMMON_BINDINGS_WGSL + WORLD_AMBIENT_WGSL + lightsApi(0, 6, "objectLight.layers.x") + SAMPLE_SHADOW_WGSL + COMMON_VS_WGSL