reze-engine 0.63.0 → 0.65.0

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,39 @@ 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);
+//   fill.rgb  its fill (Engine.setModelFill), added after its graph times its
+//             surface colour — zero for a model that has none.
+struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f }
+@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 +251,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 +507,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

package/src/shaders/materials/nodes.ts

@@ -348,6 +348,215 @@ fn rzWorldSpecularLod(dir: vec3f, roughness: f32, unity: f32) -> vec3f {
   return textureSampleLevel(worldEnvTexture, diffuseSampler, vec2f(u, v), lod).rgb * light.ambientColor.w;
 }
 
+// ── Aether Gazer's character shading, step by step ──
+// From the decompiled ForwardBase pass of SimPipeline/Character/Debug. Its
+// spaces are the game's: a view space looking down -Z (Unity's camera space),
+// which the engine's +Z-forward view is turned into by negating z.
+
+/** CharacterEffect's key light, in sim_TowardMatrix's frame: the camera's
+ *  backward direction flattened to the ground (d), up, and up × d. The
+ *  direction points toward the light. */
+fn ag_key_light(inclination: f32, azimuth: f32) -> vec3f {
+  let f = vec3f(camera.view[0].z, camera.view[1].z, camera.view[2].z);
+  let flat = vec3f(-f.x, 0.0, -f.z);
+  let len = length(flat);
+  let d = select(vec3f(0.0, 0.0, 1.0), flat / max(len, 1e-5), len > 1e-5);
+  let incl = radians(inclination);
+  let az = radians(-azimuth);
+  let c = cos(incl);
+  let k = vec3f(sin(az) * -c, sin(incl), cos(az) * c);
+  return normalize(vec3f(d.z, 0.0, -d.x) * k.x + vec3f(0.0, 1.0, 0.0) * k.y + d * k.z);
+}
+
+/** u on the shadow ramp: N·L, darkened by the mask's occlusion
+ *  (1 - min((1 - ao) * scale, 1)), and min'd with the sun's cast shadow. */
+fn ag_shade_term(n: vec3f, l: vec3f, ao: f32, aoScale: f32, receive: f32, wp: vec3f) -> f32 {
+  let ndl = max(dot(n, l), 0.0);
+  var t = (1.0 - min((1.0 - ao) * aoScale, 1.0)) * ndl;
+  if (receive > 0.5) { t = min(t, rzSunOcclusion(wp, n)); }
+  return t;
+}
+
+/** A ramp image's uv, kept off the image's edge texels so a repeating sampler
+ *  does not blend the far end in. The row is Unity's v, which runs up from the
+ *  image's bottom row; the image is uploaded top row first. */
+fn ag_ramp_uv(value: f32, row: f32) -> vec3f {
+  return vec3f(clamp(value, 0.002, 0.998), clamp(1.0 - row, 0.002, 0.998), 0.0);
+}
+
+/** The view-space reflection, as the game builds it: the view ray mirrored on
+ *  the normal, into camera space, halved and pushed half a unit toward the
+ *  eye, normalised. xy*0.5+0.5 is the sphere image's uv (xyz here, z unused),
+ *  and z how much it faces the eye (w). */
+fn ag_view_reflection(n: vec3f, v: vec3f) -> vec4f {
+  let r = reflect(-v, n);
+  let rv = vec3f(
+    camera.view[0].x * r.x + camera.view[1].x * r.y + camera.view[2].x * r.z,
+    camera.view[0].y * r.x + camera.view[1].y * r.y + camera.view[2].y * r.z,
+    -(camera.view[0].z * r.x + camera.view[1].z * r.y + camera.view[2].z * r.z),
+  );
+  let m = normalize(rv * 0.5 + vec3f(0.0, 0.0, 0.5));
+  // A sphere image is addressed as Unity reads it, v up: flipped for the
+  // top-row-first upload.
+  return vec4f(m.x * 0.5 + 0.5, 0.5 - m.y * 0.5, 0.0, m.z);
+}
+
+/** The matcap's lift: max(mask * (matcap * strength - 1) + 1, 1). */
+fn ag_matcap(color: vec3f, matcap: vec3f, strength: f32, mask: f32) -> vec3f {
+  return color * max(mask * (matcap * strength - vec3f(1.0)) + vec3f(1.0), vec3f(1.0));
+}
+
+/** The rim: smoothstep'd to the silhouette by facing, limited to the two rim
+ *  directions (CharacterEffect: (cos a·s, sin a·s, z), a = azimuth·π,
+ *  s = sqrt(1 - z²)), laid on as a colour dodge: min(max(c, 2), c / (1 - 2·rim)). */
+fn ag_rim(color: vec3f, facing: f32, uvw: vec3f, rimColor: vec3f, threshold: f32, fade: f32, range: f32,
+          inclination: f32, azimuth1: f32, azimuth2: f32, mask: f32) -> vec3f {
+  let m = vec3f(uvw.x * 2.0 - 1.0, 1.0 - uvw.y * 2.0, facing);
+  let t = saturate((facing - (threshold + fade)) / (threshold - (threshold + fade)));
+  let edge = t * t * (3.0 - 2.0 * t);
+  let s = sqrt(max(1.0 - inclination * inclination, 0.0));
+  let a1 = azimuth1 * 3.1415927;
+  let a2 = azimuth2 * 3.1415927;
+  let d1 = vec3f(cos(a1) * s, sin(a1) * s, inclination);
+  let d2 = vec3f(cos(a2) * s, sin(a2) * s, inclination);
+  let along = saturate(max(dot(m, d1), dot(m, d2)) + range);
+  let rim = min(edge, along) * rimColor;
+  let f = min(rim * mask * 2.0, vec3f(0.99));
+  return min(max(color, vec3f(2.0)), color / (vec3f(1.0) - f));
+}
+
+/** The fill: inner to outer by pow(1 - facing², softness + 2), laid over by
+ *  its amount. */
+fn ag_fill(color: vec3f, facing: f32, inner: vec3f, outer: vec3f, amount: f32, softness: f32) -> vec3f {
+  let k = pow(max(1.0 - facing * facing, 0.0), softness + 2.0);
+  return mix(color, mix(inner, outer, k), amount);
+}
+
+// ── Aether Gazer's PBR character shading (SimPipeline/Character/PBR/Uber) ──
+// The ForwardBase pass of the game's current character shader, decompiled and
+// written back out step by step. Its ramp image carries the whole tone of the
+// look in rows: the diffuse ramp in the row the material picks, the specular
+// ramp at 0.95, the environment's floor at 0.85.
+
+/** A ramp image on a group slot, read at a computed coordinate — mip 0 only,
+ *  as the game reads it, and so legal wherever the shading branches. */
+fn _ag_ramp(slot: u32, uv: vec2f) -> vec4f {
+  // Unity's v runs up from the bottom row; the image is uploaded top row first.
+  let c = clamp(vec2f(uv.x, 1.0 - uv.y), vec2f(0.002), vec2f(0.998));
+  switch slot {
+    case 1u: { return textureSampleLevel(groupTexture1, diffuseSampler, c, 0.0); }
+    case 2u: { return textureSampleLevel(groupTexture2, diffuseSampler, c, 0.0); }
+    case 3u: { return textureSampleLevel(groupTexture3, diffuseSampler, c, 0.0); }
+    default: { return textureSampleLevel(groupTexture0, diffuseSampler, c, 0.0); }
+  }
+}
+
+/**
+ * The whole lighting of one Uber material under the character's key light:
+ *   diffuse = base·(1−metal) · ramp(min(shadow, occlusion·N·L), row)
+ *   specular = GGX through the ramp's 0.95 row, × F0, plus the rim, × the
+ *              shade term
+ *   ambient = the object's SH at n × diffuse
+ *   reflection = the scene's environment along the reflected view, at a
+ *              roughness mip, × the mobile environment-BRDF fit
+ *              (F0·A + ramp(N·L·B, 0.85))
+ * Lamps and fog are the engine's, laid on after.
+ */
+fn ag_uber(slot: u32, base: vec3f, metallic: f32, roughness: f32, occlusion: f32, n: vec3f, l: vec3f,
+           row: f32, receive: f32, rimMask: f32, rimMid: f32, rimWidth: f32, rimTint: vec3f,
+           rimIntensity: f32, rimAlbedo: f32, rimInLight: f32, emissive: vec3f, reflection: f32,
+           shade: f32, face: f32, wp: vec3f, v: vec3f) -> vec3f {
+  let diffuse = base * (1.0 - metallic);
+  let f0 = mix(vec3f(0.04), base, metallic);
+  let pr = clamp(roughness, 0.0, 1.0);
+  let r = max(pr * pr, 0.0078125);
+  let a2 = r * r;
+  let h = normalize(v + l);
+  let ndl = saturate(dot(n, l));
+  let ndv = saturate(dot(v, n));
+  let ndh = saturate(dot(n, h));
+  let vdh = saturate(dot(v, h));
+  let ldh = saturate(dot(l, h));
+
+  // where on the ramp: N·L under occlusion, and the sun's cast shadow
+  var shadow = 1.0;
+  if (receive > 0.5) { shadow = rzSunOcclusion(wp, n); }
+  // A face replaces N·L with its SDF shade; anything else reads N·L.
+  let u = min(shadow, occlusion * select(ndl, shade, shade >= 0.0));
+  let ramp = _ag_ramp(slot, vec2f(u, row)).rgb;
+
+  // GGX, as the pass writes it, then through the ramp's specular row
+  let dd = ndh * ndh * (a2 - 1.0) + 1.0;
+  let D = select(a2 / (dd * dd), 1.0, dd * dd == a2);
+  let vis = min(0.5 / (ndl * (ndv * (1.0 - r) + r) + ndv * (ndl * (1.0 - r) + r)), 1.0);
+  let vis2 = min(0.5 / (ldh * (vdh * (1.0 - r) + r) + vdh * (ldh * (1.0 - r) + r)), 1.0);
+  let x = saturate(D * vis * a2 / vis2);
+  let specRamp = _ag_ramp(slot, vec2f(x, 0.95)).rgb;
+  let spec = clamp(vis * specRamp * min(1.0 / a2, 2048.0), vec3f(0.0), vec3f(10.0));
+
+  // the rim: toward the silhouette on the lit side, tinted toward the albedo
+  let lit = select(0.0, 1.0, u > 0.001);
+  let t = saturate(((ndl * 0.25 + 0.75) * (1.0 - ndv) * lit - (rimMid - rimWidth)) / max(2.0 * rimWidth, 1e-4));
+  let edge = t * t * (3.0 - 2.0 * t);
+  let tint = min(rimTint * rimIntensity * mix(vec3f(1.0), base, rimAlbedo) * 2.0 * rimMask, vec3f(0.99));
+  let rim = tint * edge * (1.0 + rimInLight * (u - 1.0));
+
+  // A face (FACE_MODE) takes no GGX: its light is the ramp, the rim and its
+  // optional SDF highlight (off unless _FaceSpecular).
+  let isFace = face > 0.5;
+  let direct = (select(spec * f0, vec3f(0.0), isFace) + rim) * u + diffuse * ramp;
+
+  // the environment, with the game's fit of the split-sum
+  let a004 = min((1.0 - pr) * (1.0 - pr), exp2(-9.28 * ndv)) * (1.0 - pr) + (0.0425 - 0.0275 * pr);
+  let A = -a004 * 1.04 + (1.04 - 0.572 * pr);
+  let ns = saturate(dot(n, mix(reflect(-l, n), h, 0.8)));
+  let B = _ag_ramp(slot, vec2f(ns * (a004 * 1.04 + (0.022 * pr - 0.04)), 0.85)).r;
+  let env = rzWorldSpecularLod(reflect(-v, n), pr, 1.0) * reflection;
+
+  // ... and the environment at a flat 0.0157 rather than through the BRDF fit.
+  let envTerm = select((f0 * A + B) * env, env * 0.0157, isFace);
+  return emissive + rzObjectAmbient(n) * diffuse + envTerm + direct;
+}
+
+
+/**
+ * The face's shade from its SDF image (Uber FACE_MODE, _SDFType 0), in place of
+ * N·L: the key light taken into the face's frame and flattened, the field read
+ * at the uv and at its mirror, the side the light is on choosing which, both
+ * compared against the light's front-to-back angle with _BlendSmoothness, then
+ * softened by how level the light is and a half-Lambert. The face frame is the
+ * head bone's, turned to the game's convention (x to the face's right, z out of
+ * it). An SDF is painted in the face's uvs, so it belongs to models that share
+ * the game's face layout; a white slot reads as a face lit evenly until the
+ * light goes behind it.
+ */
+fn ag_face_sdf(slot: u32, uv: vec2f, l: vec3f, n: vec3f, smoothness: f32, invert: f32) -> f32 {
+  let hb = skinMats[u32(max(material.headBoneIndex, 0.0))];
+  let fx = -normalize(hb[0].xyz);
+  let fy = normalize(hb[1].xyz);
+  let fz = -normalize(hb[2].xyz);
+  let lf = normalize(vec3f(dot(l, fx), dot(l, fy), dot(l, fz)));
+  let fl = lf.xz * inverseSqrt(max(dot(lf.xz, lf.xz), 1.1754944e-38));
+  let u0 = mix(uv.x, 1.0 - uv.x, invert);
+  let s1 = _ag_ramp(slot, vec2f(u0, 1.0 - uv.y));
+  let s2 = _ag_ramp(slot, vec2f(1.0 - u0, 1.0 - uv.y));
+  let left = fl.x < 0.0;
+  let a = select(s2.x, s1.x, left);
+  let b = select(s1.x, s2.x, left);
+  let flag = select(0.0, 1.0, s1.w > 0.5);
+  let k = max(smoothness, 0.001);
+  let th = fl.y * -0.5 + 0.5;
+  let w = 1.0 - th;
+  var m1 = max(saturate((a - th) / k + 0.5), saturate((b - w - 1.0) / k + 0.5));
+  m1 = min(m1, min(saturate((2.0 - a - w) / k + 0.5), saturate((2.0 - b - w) / k + 0.5)));
+  var m2 = max(saturate((b - th - 1.0) / k + 0.5), saturate((a - w) / k + 0.5));
+  m2 = min(m2, min(saturate((a + w) / k + 0.5), saturate((b + w) / k + 0.5)));
+  var r = flag * (m1 - m2) + m2;
+  r *= (1.0 - abs(lf.z)) * 0.5 + 0.5;
+  r *= saturate(dot(n, l)) * 0.5 + 0.5;
+  return r;
+}
+
 fn group_tex0(uv: vec2f) -> vec4f { return textureSample(groupTexture0, diffuseSampler, uv); }
 fn group_tex1(uv: vec2f) -> vec4f { return textureSample(groupTexture1, diffuseSampler, uv); }
 fn group_tex2(uv: vec2f) -> vec4f { return textureSample(groupTexture2, diffuseSampler, uv); }
@@ -1056,6 +1265,7 @@ struct _RzLampPair { d: vec3f, s: vec3f };
 
 fn _rzLampOne(i: u32, p: vec3f, n: vec3f, v: vec3f, ndv: f32, roughness: f32, unity: f32) -> _RzLampPair {
   var out = _RzLampPair(vec3f(0.0), vec3f(0.0));
+  if (!_rzLightReaches(i)) { return out; }
   let pr = _rzLightVec(i, 0u);
   let d = pr.xyz - p;
   let dist = length(d);

package/src/shaders/passes/bloom.ts

@@ -1,7 +1,7 @@
-// EEVEE 3.6 bloom pyramid: blit (Karis prefilter) → 13-tap downsamples → 9-tap tent upsamples.
-// Mirrors source/blender/draw/engines/eevee/shaders/effect_bloom_frag.glsl. Firefly suppression
-// lives in the blit (Karis luminance-weighted 4-tap average). A single-pass Gaussian cannot
-// reproduce this — hot pixels dominate and produce the sparkle halo.
+// Bloom — Aether Gazer's own chain (AGSimPostFX.Bloom, URP-style): a soft-knee
+// prefilter to half size, a separable Gaussian down to a few pixels, then back
+// up level by level, each blend leaning toward the coarser level by `scatter`.
+// The composite adds the result × tint × intensity before the view transform.
 
 const FULLSCREEN_VS = /* wgsl */ `
 @vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
@@ -11,114 +11,86 @@ const FULLSCREEN_VS = /* wgsl */ `
 }
 `
 
-// Full-res HDR → half-res. Karis 4-tap firefly average + EEVEE quadratic knee threshold + clamp.
-export const BLOOM_BLIT_SHADER_WGSL = `${FULLSCREEN_VS}
+// Full-res HDR → half-res. The game takes ONE bilinear sample at the half-res
+// pixel's centre, which is the 2×2 box of the block under it; here the four
+// texels are loaded so each can be un-premultiplied (the scene target is
+// premultiplied; its alpha lives in the aux target's .g) and gated by the bloom
+// mask (.r) first.
+export const BLOOM_PREFILTER_SHADER_WGSL = `${FULLSCREEN_VS}
 @group(0) @binding(0) var hdrTex: texture_2d<f32>;
-@group(0) @binding(1) var<uniform> prefilter: vec4<f32>; // threshold, knee, clamp, _unused
+@group(0) @binding(1) var<uniform> params: vec4<f32>; // threshold, knee, clamp, scatter
 @group(0) @binding(2) var maskTex: texture_2d<f32>;
 
-fn luminance(c: vec3f) -> f32 {
-  return dot(max(c, vec3f(0.0)), vec3f(0.2126, 0.7152, 0.0722));
-}
-fn fetch(c: vec2<i32>, clampV: f32) -> vec3f {
+fn fetch(c: vec2<i32>) -> vec3f {
   let d = vec2<i32>(textureDimensions(hdrTex));
   let cc = clamp(c, vec2<i32>(0), d - vec2<i32>(1));
-  let s = textureLoad(hdrTex, cc, 0);
-  // hdrTex is rg11b10ufloat (no alpha channel). Alpha lives in maskTex.g, written
-  // alongside the bloom mask in .r by the scene pass. Scene uses src-alpha blend
-  // with clear alpha 0 → hdr rgb is premultiplied; divide by the aux alpha to
-  // recover straight color before the Karis luminance weighting.
   let aux = textureLoad(maskTex, cc, 0);
-  let mask = aux.r;
-  let rgb = max(s.rgb / max(aux.g, 1e-6), vec3f(0.0));
-  let masked = rgb * mask;
-  // Blender clamps each tap BEFORE Karis average (eevee_bloom: color = min(clampIntensity, color)).
-  return select(masked, min(masked, vec3f(clampV)), clampV > 0.0);
+  return max(textureLoad(hdrTex, cc, 0).rgb / max(aux.g, 1e-6), vec3f(0.0)) * aux.r;
 }
 
 @fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {
-  let dst = vec2<i32>(p.xy - vec2f(0.5));
-  let base = dst * 2;
-  let clampV = prefilter.z;
-  let a = fetch(base + vec2<i32>(0, 0), clampV);
-  let b = fetch(base + vec2<i32>(1, 0), clampV);
-  let c = fetch(base + vec2<i32>(0, 1), clampV);
-  let d = fetch(base + vec2<i32>(1, 1), clampV);
-  // Karis partial average: weight each tap by 1/(1+luma) — suppresses fireflies.
-  let wa = 1.0 / (1.0 + luminance(a));
-  let wb = 1.0 / (1.0 + luminance(b));
-  let wc = 1.0 / (1.0 + luminance(c));
-  let wd = 1.0 / (1.0 + luminance(d));
-  let avg = (a * wa + b * wb + c * wc + d * wd) / max(wa + wb + wc + wd, 1e-6);
-  // EEVEE quadratic threshold (brightness = max-channel, then soft-knee curve).
-  let bright = max(avg.r, max(avg.g, avg.b));
-  let soft = clamp(bright - prefilter.x + prefilter.y, 0.0, 2.0 * prefilter.y);
-  let q = (soft * soft) / (4.0 * max(prefilter.y, 1e-4) + 1e-6);
-  let contrib = max(q, bright - prefilter.x) / max(bright, 1e-4);
-  return vec4f(max(avg * contrib, vec3f(0.0)), 1.0);
+  let base = vec2<i32>(p.xy - vec2f(0.5)) * 2;
+  let avg = (fetch(base) + fetch(base + vec2<i32>(1, 0)) + fetch(base + vec2<i32>(0, 1)) + fetch(base + vec2<i32>(1, 1))) * 0.25;
+  let c = min(avg, vec3f(params.z));
+  // URP's quadratic soft knee on the brightest channel.
+  let bright = max(c.r, max(c.g, c.b));
+  let knee = params.y;
+  let soft = clamp(bright - params.x + knee, 0.0, 2.0 * knee);
+  let curve = soft * soft / (4.0 * knee + 1e-4);
+  return vec4f(c * (max(curve, bright - params.x) / max(bright, 1e-4)), 1.0);
 }
 `
 
-// Jimenez/COD 13-tap dual-box — 5 weighted 2×2 averages, rejects nyquist ringing.
-export const BLOOM_DOWNSAMPLE_SHADER_WGSL = `${FULLSCREEN_VS}
+// Horizontal 9-tap Gaussian (σ ≈ 2 at the destination's scale), its taps two
+// SOURCE texels apart: the destination is half the source, so this both halves
+// and blurs. Each tap lands on a texel boundary, so bilinear averages pairs.
+export const BLOOM_BLUR_H_SHADER_WGSL = `${FULLSCREEN_VS}
 @group(0) @binding(0) var srcTex: texture_2d<f32>;
 @group(0) @binding(1) var srcSamp: sampler;
 
-fn samp(uv: vec2f, off: vec2f) -> vec3f {
-  return textureSampleLevel(srcTex, srcSamp, uv + off, 0.0).rgb;
+@fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {
+  let srcDims = vec2f(textureDimensions(srcTex));
+  let dstDims = max(floor(srcDims * 0.5), vec2f(1.0));
+  let uv = p.xy / dstDims;
+  let dx = vec2f(2.0 / srcDims.x, 0.0);
+  var w = array<f32, 5>(0.22702703, 0.19459459, 0.12162162, 0.05405405, 0.01621622);
+  var o = textureSampleLevel(srcTex, srcSamp, uv, 0.0).rgb * w[0];
+  for (var i = 1; i < 5; i++) {
+    let off = dx * f32(i);
+    o += (textureSampleLevel(srcTex, srcSamp, uv - off, 0.0).rgb + textureSampleLevel(srcTex, srcSamp, uv + off, 0.0).rgb) * w[i];
+  }
+  return vec4f(o, 1.0);
 }
+`
+
+// Vertical pass at the same size: the same 9-tap Gaussian as five bilinear taps.
+export const BLOOM_BLUR_V_SHADER_WGSL = `${FULLSCREEN_VS}
+@group(0) @binding(0) var srcTex: texture_2d<f32>;
+@group(0) @binding(1) var srcSamp: sampler;
 
 @fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {
-  let srcDims = vec2f(textureDimensions(srcTex));
-  let t = 1.0 / srcDims;
-  // fragCoord.xy reports pixel centers (e.g. 0.5,0.5 for first pixel) — divide by dst dims directly.
-  let dstDims = srcDims * 0.5;
-  let uv = p.xy / max(dstDims, vec2f(1.0));
-  let A = samp(uv, t * vec2f(-2.0, -2.0));
-  let B = samp(uv, t * vec2f( 0.0, -2.0));
-  let C = samp(uv, t * vec2f( 2.0, -2.0));
-  let D = samp(uv, t * vec2f(-1.0, -1.0));
-  let E = samp(uv, t * vec2f( 1.0, -1.0));
-  let F = samp(uv, t * vec2f(-2.0,  0.0));
-  let G = samp(uv, t * vec2f( 0.0,  0.0));
-  let H = samp(uv, t * vec2f( 2.0,  0.0));
-  let I = samp(uv, t * vec2f(-1.0,  1.0));
-  let J = samp(uv, t * vec2f( 1.0,  1.0));
-  let K = samp(uv, t * vec2f(-2.0,  2.0));
-  let L = samp(uv, t * vec2f( 0.0,  2.0));
-  let M = samp(uv, t * vec2f( 2.0,  2.0));
-  var o = (D + E + I + J) * (0.5 / 4.0);
-  o = o + (A + B + G + F) * (0.125 / 4.0);
-  o = o + (B + C + H + G) * (0.125 / 4.0);
-  o = o + (F + G + L + K) * (0.125 / 4.0);
-  o = o + (G + H + M + L) * (0.125 / 4.0);
+  let dims = vec2f(textureDimensions(srcTex));
+  let uv = p.xy / dims;
+  let near = vec2f(0.0, 1.3846154 / dims.y);
+  let far = vec2f(0.0, 3.2307692 / dims.y);
+  var o = textureSampleLevel(srcTex, srcSamp, uv, 0.0).rgb * 0.22702703;
+  o += (textureSampleLevel(srcTex, srcSamp, uv - near, 0.0).rgb + textureSampleLevel(srcTex, srcSamp, uv + near, 0.0).rgb) * 0.31621623;
+  o += (textureSampleLevel(srcTex, srcSamp, uv - far, 0.0).rgb + textureSampleLevel(srcTex, srcSamp, uv + far, 0.0).rgb) * 0.07027027;
   return vec4f(o, 1.0);
 }
 `
 
-// 9-tap tent, progressively added to matching downsample mip. Blender radius = sample scale.
+// One level up: this level's blur leaned toward the coarser one by scatter.
 export const BLOOM_UPSAMPLE_SHADER_WGSL = `${FULLSCREEN_VS}
-@group(0) @binding(0) var srcTex: texture_2d<f32>;   // coarser accumulator
-@group(0) @binding(1) var baseTex: texture_2d<f32>;  // matching downsample mip
+@group(0) @binding(0) var highTex: texture_2d<f32>;  // down[i]
+@group(0) @binding(1) var lowTex: texture_2d<f32>;   // coarser: down[i+1] at the top, up[i+1] after
 @group(0) @binding(2) var srcSamp: sampler;
-@group(0) @binding(3) var<uniform> upU: vec4<f32>;   // sampleScale, _, _, _
+@group(0) @binding(3) var<uniform> params: vec4<f32>; // threshold, knee, clamp, scatter
 
 @fragment fn fs(@builtin(position) p: vec4f) -> @location(0) vec4f {
-  let srcDims = vec2f(textureDimensions(srcTex));
-  let baseDims = vec2f(textureDimensions(baseTex));
-  let uv = p.xy / max(baseDims, vec2f(1.0));
-  let t = upU.x / srcDims;
-  var o = textureSampleLevel(srcTex, srcSamp, uv + t * vec2f(-1.0, -1.0), 0.0).rgb * 1.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 0.0, -1.0), 0.0).rgb * 2.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 1.0, -1.0), 0.0).rgb * 1.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f(-1.0,  0.0), 0.0).rgb * 2.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 0.0,  0.0), 0.0).rgb * 4.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 1.0,  0.0), 0.0).rgb * 2.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f(-1.0,  1.0), 0.0).rgb * 1.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 0.0,  1.0), 0.0).rgb * 2.0;
-  o = o + textureSampleLevel(srcTex, srcSamp, uv + t * vec2f( 1.0,  1.0), 0.0).rgb * 1.0;
-  o = o * (1.0 / 16.0);
-  let base = textureSampleLevel(baseTex, srcSamp, uv, 0.0).rgb;
-  return vec4f(o + base, 1.0);
+  let uv = p.xy / vec2f(textureDimensions(highTex));
+  let high = textureSampleLevel(highTex, srcSamp, uv, 0.0).rgb;
+  let low = textureSampleLevel(lowTex, srcSamp, uv, 0.0).rgb;
+  return vec4f(mix(high, low, params.w), 1.0);
 }
 `