@driftengine/core 4.4.2 → 4.6.0

package/dist/render/shaders/gi/driftLight.wgsl.d.ts

@@ -13,4 +13,4 @@
  * The including module declares `driftIndex: texture_3d<u32>`, `driftAtlas: texture_3d<f32>` and a
  * filtering `driftSampler`; `origin` is the field's first sample and, in `w`, the spacing.
  */
-export declare const DRIFT_LIGHT_WGSL = "\nfn driftLightIrradiance(world: vec3<f32>, n: vec3<f32>, origin: vec4<f32>) -> vec3<f32> {\n  let spacing = origin.w;\n  let at = (world + n * (0.5 * spacing) - origin.xyz) / (3.0 * spacing);\n  let cell = vec3<i32>(floor(at));\n  if (any(cell < vec3<i32>(0)) || any(cell >= vec3<i32>(textureDimensions(driftIndex, 0)))) {\n    return vec3<f32>(0.0);\n  }\n  let id = textureLoad(driftIndex, cell, 0).r;\n  if (id == 0u) {\n    return vec3<f32>(0.0);\n  }\n  let size = vec3<i32>(textureDimensions(driftAtlas, 0));\n  let brick = i32(id) - 1;\n  let across = size.x / 8;\n  let down = size.y / 4;\n  let corner = vec3<f32>(\n    f32((brick % across) * 8),\n    f32(((brick / across) % down) * 4),\n    f32((brick / (across * down)) * 4)\n  );\n  let texel = 1.0 / vec3<f32>(size);\n  let inside = (at - vec3<f32>(cell)) * 3.0 + 0.5;\n  let light = textureSampleLevel(driftAtlas, driftSampler, (corner + inside) * texel, 0.0);\n  if (light.a < 1e-3) {\n    return vec3<f32>(0.0);\n  }\n  let toward = textureSampleLevel(driftAtlas, driftSampler, (corner + vec3<f32>(4.0, 0.0, 0.0) + inside) * texel, 0.0);\n  let arriving = light.rgb / light.a;\n  let towardLight = toward.xyz / light.a;\n  let facing = max(dot(n, towardLight), 0.0) + (1.0 - min(length(towardLight), 1.0)) * 0.25;\n  return arriving * facing;\n}\n";
+export declare const DRIFT_LIGHT_WGSL = "\nfn driftLightFacing(light: vec4<f32>, toward: vec4<f32>, n: vec3<f32>) -> vec3<f32> {\n  let arriving = light.rgb / light.a;\n  let towardLight = toward.xyz / light.a;\n  let facing = max(dot(n, towardLight), 0.0) + (1.0 - min(length(towardLight), 1.0)) * 0.25;\n  return arriving * facing;\n}\n\nfn driftLightDense(world: vec3<f32>, n: vec3<f32>, origin: vec4<f32>, spacing: f32) -> vec3<f32> {\n  let size = vec3<i32>(textureDimensions(driftAtlas, 0));\n  let dims = vec3<f32>(f32(size.x), f32(size.y / 2), f32(size.z));\n  let at = (world + n * (0.5 * spacing) - origin.xyz) / spacing;\n  if (any(at < vec3<f32>(0.0)) || any(at > dims - 1.0)) {\n    return vec3<f32>(0.0);\n  }\n  let uvw = (at + 0.5) / vec3<f32>(dims.x, dims.y * 2.0, dims.z);\n  let light = textureSampleLevel(driftAtlas, driftSampler, uvw, 0.0);\n  if (light.a < 1e-3) {\n    return vec3<f32>(0.0);\n  }\n  let toward = textureSampleLevel(driftAtlas, driftSampler, uvw + vec3<f32>(0.0, 0.5, 0.0), 0.0);\n  return driftLightFacing(light, toward, n);\n}\n\nfn driftLightIrradiance(world: vec3<f32>, n: vec3<f32>, origin: vec4<f32>) -> vec3<f32> {\n  let spacing = origin.w;\n  if (spacing < 0.0) {\n    return driftLightDense(world, n, origin, -spacing);\n  }\n  let at = (world + n * (0.5 * spacing) - origin.xyz) / (3.0 * spacing);\n  let cell = vec3<i32>(floor(at));\n  if (any(cell < vec3<i32>(0)) || any(cell >= vec3<i32>(textureDimensions(driftIndex, 0)))) {\n    return vec3<f32>(0.0);\n  }\n  let id = textureLoad(driftIndex, cell, 0).r;\n  if (id == 0u) {\n    return vec3<f32>(0.0);\n  }\n  let size = vec3<i32>(textureDimensions(driftAtlas, 0));\n  let brick = i32(id) - 1;\n  let across = size.x / 8;\n  let down = size.y / 4;\n  let corner = vec3<f32>(\n    f32((brick % across) * 8),\n    f32(((brick / across) % down) * 4),\n    f32((brick / (across * down)) * 4)\n  );\n  let texel = 1.0 / vec3<f32>(size);\n  let inside = (at - vec3<f32>(cell)) * 3.0 + 0.5;\n  let light = textureSampleLevel(driftAtlas, driftSampler, (corner + inside) * texel, 0.0);\n  if (light.a < 1e-3) {\n    return vec3<f32>(0.0);\n  }\n  let toward = textureSampleLevel(driftAtlas, driftSampler, (corner + vec3<f32>(4.0, 0.0, 0.0) + inside) * texel, 0.0);\n  return driftLightFacing(light, toward, n);\n}\n";

package/dist/render/shaders/gi/driftLight.wgsl.js

@@ -14,8 +14,34 @@
  * filtering `driftSampler`; `origin` is the field's first sample and, in `w`, the spacing.
  */
 export const DRIFT_LIGHT_WGSL = /* wgsl */ `
+fn driftLightFacing(light: vec4<f32>, toward: vec4<f32>, n: vec3<f32>) -> vec3<f32> {
+  let arriving = light.rgb / light.a;
+  let towardLight = toward.xyz / light.a;
+  let facing = max(dot(n, towardLight), 0.0) + (1.0 - min(length(towardLight), 1.0)) * 0.25;
+  return arriving * facing;
+}
+
+fn driftLightDense(world: vec3<f32>, n: vec3<f32>, origin: vec4<f32>, spacing: f32) -> vec3<f32> {
+  let size = vec3<i32>(textureDimensions(driftAtlas, 0));
+  let dims = vec3<f32>(f32(size.x), f32(size.y / 2), f32(size.z));
+  let at = (world + n * (0.5 * spacing) - origin.xyz) / spacing;
+  if (any(at < vec3<f32>(0.0)) || any(at > dims - 1.0)) {
+    return vec3<f32>(0.0);
+  }
+  let uvw = (at + 0.5) / vec3<f32>(dims.x, dims.y * 2.0, dims.z);
+  let light = textureSampleLevel(driftAtlas, driftSampler, uvw, 0.0);
+  if (light.a < 1e-3) {
+    return vec3<f32>(0.0);
+  }
+  let toward = textureSampleLevel(driftAtlas, driftSampler, uvw + vec3<f32>(0.0, 0.5, 0.0), 0.0);
+  return driftLightFacing(light, toward, n);
+}
+
 fn driftLightIrradiance(world: vec3<f32>, n: vec3<f32>, origin: vec4<f32>) -> vec3<f32> {
   let spacing = origin.w;
+  if (spacing < 0.0) {
+    return driftLightDense(world, n, origin, -spacing);
+  }
   let at = (world + n * (0.5 * spacing) - origin.xyz) / (3.0 * spacing);
   let cell = vec3<i32>(floor(at));
   if (any(cell < vec3<i32>(0)) || any(cell >= vec3<i32>(textureDimensions(driftIndex, 0)))) {
@@ -41,9 +67,6 @@ fn driftLightIrradiance(world: vec3<f32>, n: vec3<f32>, origin: vec4<f32>) -> ve
     return vec3<f32>(0.0);
   }
   let toward = textureSampleLevel(driftAtlas, driftSampler, (corner + vec3<f32>(4.0, 0.0, 0.0) + inside) * texel, 0.0);
-  let arriving = light.rgb / light.a;
-  let towardLight = toward.xyz / light.a;
-  let facing = max(dot(n, towardLight), 0.0) + (1.0 - min(length(towardLight), 1.0)) * 0.25;
-  return arriving * facing;
+  return driftLightFacing(light, toward, n);
 }
 `;

package/dist/render/shaders/globalMedium.js

@@ -1,3 +1,4 @@
+import { SUN_DYNAMIC_LAYER, SUN_PEELED_LAYER, SUN_STATIC_LAYER } from '../shadowMap.js';
 import { glslIsFarDepth, glslSceneDepthToNdc } from '../depthConvention.js';
 import { MAX_GLOBAL_MEDIUM_STEPS } from '../globalMedium.js';
 /**
@@ -77,9 +78,8 @@ uniform int uSteps;
 /** How much of the medium the sun's own shadow map removes, 0 to 1. At 0 nothing is sampled. */
 uniform float uSunShadow;
 uniform mat4 uLightViewProj;
-uniform sampler2D uStaticShadowMap;
-uniform sampler2D uPeeledShadowMap;
-uniform sampler2D uDynamicShadowMap;
+/* The sun's static, moving and peeled maps, as layers of one array: see shadowMap.ts. */
+uniform highp sampler2DArray uSunShadows;
 uniform int uPeeledShadowEnabled;
 
 out vec4 fragColor;
@@ -148,11 +148,11 @@ float sunReach(vec3 worldPos) {
   if (edgeFade <= 0.0) return 1.0;
 
   float compare = p.z - SHADOW_BIAS;
-  float blocked = occlusion(textureLod(uStaticShadowMap, p.xy, 0.0).r, compare);
+  float blocked = occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_STATIC_LAYER}.0), 0.0).r, compare);
   if (uPeeledShadowEnabled != 0) {
-    blocked = max(blocked, occlusion(textureLod(uPeeledShadowMap, p.xy, 0.0).r, compare));
+    blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_PEELED_LAYER}.0), 0.0).r, compare));
   }
-  blocked = max(blocked, occlusion(textureLod(uDynamicShadowMap, p.xy, 0.0).r, compare));
+  blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r, compare));
   return mix(1.0, 1.0 - blocked, uSunShadow * edgeFade);
 }
 

package/dist/render/shaders/gpudriven/blendRaster.wgsl.d.ts

@@ -24,3 +24,10 @@ export declare const BLEND_RESOLVE_WGSL = "\n@group(0) @binding(0) var accumMap:
  * `oitWeight` and `resolveOit` over generated cases.
  */
 export declare const BLEND_OIT_PARITY_WGSL = "\n/** Six floats a case: depth, alpha, colour, and the background behind it. */\n@group(0) @binding(0) var<storage, read> cases: array<f32>;\n/** Four out: the weight, and the three resolved channels. */\n@group(0) @binding(1) var<storage, read_write> results: array<f32>;\n\nfn oitWeight(viewDepth: f32, alpha: f32) -> f32 {\n  let z = max(viewDepth, 0.0) / 200.0;\n  let falloff = 0.03 / (1e-5 + z * z * z * z);\n  return alpha * clamp(falloff, 1e-2, 3e3);\n}\n\n/* Premultiplied and weighted, against a blend of \"one, one\": the target holds the two sums. */\nfn oitAccumulate(colour: vec3<f32>, alpha: f32, weight: f32) -> vec4<f32> {\n  return vec4<f32>(colour * alpha * weight, alpha * weight);\n}\n\n/*\n * The two targets, as a premultiplied fragment to lay over what is behind them.\n *\n * The weighted sum divided by the weighted alpha is the average colour the layers make, and the\n * revealage says how much of the background still shows. The division is guarded because a pixel no\n * fragment touched has a weighted alpha of zero \u2014 and its revealage of one discards whatever this\n * produces anyway.\n */\nfn oitResolved(accum: vec4<f32>, reveal: f32) -> vec4<f32> {\n  let average = accum.xyz / max(accum.w, 1e-5);\n  let covered = 1.0 - reveal;\n  return vec4<f32>(average * covered, covered);\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x * 8u + 7u >= arrayLength(&cases)) { return; }\n  let at = id.x * 8u;\n  let depth = cases[at];\n  let alpha = cases[at + 1u];\n  let colour = vec3<f32>(cases[at + 2u], cases[at + 3u], cases[at + 4u]);\n  let background = vec3<f32>(cases[at + 5u], cases[at + 6u], cases[at + 7u]);\n\n  let weight = oitWeight(depth, alpha);\n  /* One fragment folded in, which is the anchor: for a single layer this reduces to \"over\". */\n  let accum = oitAccumulate(colour, alpha, weight);\n  let reveal = 1.0 - alpha;\n  /*\n   * The resolve's own fragment, then the blend state applied by hand: the pipeline lays it over\n   * the target with \"one, one-minus-src-alpha\", so the background keeps the revealage.\n   */\n  let over = oitResolved(accum, reveal);\n  let resolved = over.xyz + background * (1.0 - over.w);\n\n  let out = id.x * 4u;\n  results[out] = weight;\n  results[out + 1u] = resolved.x;\n  results[out + 2u] = resolved.y;\n  results[out + 3u] = resolved.z;\n}\n";
+/**
+ * `glassShade` alone, as a dispatch, so it can be checked against `gpudriven/lit.ts`.
+ *
+ * Sixteen floats a case — own, seen, transmission, frost, tint, the view cosine, the glow, one
+ * spare — and four out, the colour and one spare.
+ */
+export declare const GLASS_SHADE_PARITY_WGSL = "\n@group(0) @binding(0) var<storage, read> cases: array<f32>;\n@group(0) @binding(1) var<storage, read_write> results: array<f32>;\n\nfn glassShade(\n  own: vec3<f32>,\n  seen: vec3<f32>,\n  transmission: f32,\n  frost: f32,\n  tint: vec3<f32>,\n  cosView: f32,\n  sunGlow: vec3<f32>,\n) -> vec3<f32> {\n  let c = clamp(abs(cosView), 0.05, 1.0);\n  let fresnel = 0.04 + 0.96 * pow(1.0 - c, 5.0);\n  let shown = transmission * (1.0 - fresnel);\n  return own + (seen * tint - own) * shown + sunGlow * tint * (frost * transmission);\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  if (id.x * 16u + 15u >= arrayLength(&cases)) { return; }\n  let at = id.x * 16u;\n  let own = vec3<f32>(cases[at], cases[at + 1u], cases[at + 2u]);\n  let seen = vec3<f32>(cases[at + 3u], cases[at + 4u], cases[at + 5u]);\n  let tint = vec3<f32>(cases[at + 8u], cases[at + 9u], cases[at + 10u]);\n  let glow = vec3<f32>(cases[at + 12u], cases[at + 13u], cases[at + 14u]);\n  let shaded = glassShade(own, seen, cases[at + 6u], cases[at + 7u], tint, cases[at + 11u], glow);\n  let out = id.x * 4u;\n  results[out] = shaded.x;\n  results[out + 1u] = shaded.y;\n  results[out + 2u] = shaded.z;\n}\n";

package/dist/render/shaders/gpudriven/blendRaster.wgsl.js

@@ -80,6 +80,27 @@ fn oitResolved(accum: vec4<f32>, reveal: f32) -> vec4<f32> {
   return vec4<f32>(average * covered, covered);
 }
 `;
+/**
+ * Glass over its own shading, as the forward path draws it: `gpudriven/lit.ts`'s `glassShade`,
+ * which `scripts/gpu-parity.mjs` holds this to. Schlick at 0.04 with the angle unsigned — a pane
+ * passes the same light seen from either side — and floored at the forward path's grazing 0.05.
+ */
+const GLASS_SHADE_WGSL = /* wgsl */ `
+fn glassShade(
+  own: vec3<f32>,
+  seen: vec3<f32>,
+  transmission: f32,
+  frost: f32,
+  tint: vec3<f32>,
+  cosView: f32,
+  sunGlow: vec3<f32>,
+) -> vec3<f32> {
+  let c = clamp(abs(cosView), 0.05, 1.0);
+  let fresnel = 0.04 + 0.96 * pow(1.0 - c, 5.0);
+  let shown = transmission * (1.0 - fresnel);
+  return own + (seen * tint - own) * shown + sunGlow * tint * (frost * transmission);
+}
+`;
 export const BLEND_RASTER_WGSL = /* wgsl */ `
 struct BlendVarying {
   @builtin(position) position: vec4<f32>,
@@ -106,6 +127,12 @@ ${FRAME_BLOCK_WGSL}
 @group(0) @binding(9) var environmentMap: texture_2d_array<f32>;
 @group(0) @binding(10) var environmentSampler: sampler;
 ${decodeResourcesWgsl({ group: 0, latents: 11, clampSampler: 12, repeatSampler: 13, nodes: 14, weights: 15 })}
+/**
+ * What the opaque half drew, with a mip chain on a frame whose scene holds glass: a pane shows it,
+ * a frosted one a coarser level of it. Read only by a material whose transmission is not zero.
+ */
+@group(0) @binding(16) var opaqueColour: texture_2d<f32>;
+@group(0) @binding(17) var opaqueSampler: sampler;
 fn decodeLatentSize() -> f32 {
   return frame.size.w;
 }
@@ -124,6 +151,7 @@ ${MESH_TRANSFORM_WGSL}
 ${SHADE_LIGHTING_WGSL}
 ${FOG_WGSL}
 ${OIT_WGSL}
+${GLASS_SHADE_WGSL}
 
 const NO_PROGRAM_HERE: u32 = ${0xffffffff}u;
 
@@ -239,7 +267,25 @@ fn blendFrag(in: BlendVarying) -> BlendTargets {
    * distance — which is the whole reason this pipeline gained a fog.
    */
   let toward = distance(in.world, frame.eye.xyz);
-  let colour = mix(litColour(surface, room), mediumColour(), mediumFog(toward, in.world.y));
+  let fog = mediumFog(toward, in.world.y);
+  var colour = mix(litColour(surface, room), mediumColour(), fog);
+  /*
+   * **Glass shows what is behind it**, as the forward path's glass branch does: the opaque half's
+   * picture at this pixel, at the level frost picks, two short of the chain's end so a fully frosted
+   * pane keeps the large light and dark behind it. The sun glows through from the pane's far side,
+   * after the haze as the forward path adds it. A pane is seen from both sides, so its facing is
+   * the side toward the eye.
+   */
+  let transmission = entry.extra.y;
+  if (transmission > 0.0) {
+    let size = vec2<f32>(textureDimensions(opaqueColour, 0));
+    let levels = max(floor(log2(max(size.x, size.y))) - 2.0, 0.0);
+    let seen = textureSampleLevel(opaqueColour, opaqueSampler, in.position.xy / size, entry.extra.z * levels).xyz;
+    let cosView = dot(surface.normal, toEye);
+    let facing = select(surface.normal, -surface.normal, cosView < 0.0);
+    let sunGlow = frame.lightColour.xyz * max(-dot(facing, frame.lightDir.xyz), 0.0) * (1.0 - fog);
+    colour = glassShade(colour, seen, transmission, entry.extra.z, entry.glassTint.xyz, cosView, sunGlow);
+  }
 
   /*
    * **The distance to the eye, not the clip-space depth**, because that is what oitWeight's falloff
@@ -253,6 +299,20 @@ fn blendFrag(in: BlendVarying) -> BlendTargets {
   out.reveal = vec4<f32>(alpha, 0.0, 0.0, alpha);
   return out;
 }
+
+/*
+ * **What a pane lets through, drawn from the sun into the tint map**: \`blendVert\` again, handed
+ * the light's raster matrix and the glass list, and this for the colour — \`glassShadow.ts\`'s
+ * paneTexel, the forward path's GLASS_TINT_FRAG in this language. Written against a white target
+ * with a multiplying blend and no depth, so every pane on a ray counts in any order.
+ */
+@fragment
+fn glassTintFrag(in: BlendVarying) -> @location(0) vec4<f32> {
+  let entry = materials[min(in.material, ${MATERIAL_SLOTS - 1}u)];
+  let c = clamp(abs(dot(normalize(in.normal), frame.lightDir.xyz)), 0.05, 1.0);
+  let passes = entry.extra.y * (1.0 - (0.04 + 0.96 * pow(1.0 - c, 5.0)));
+  return vec4<f32>(passes * entry.glassTint.xyz, 1.0 - entry.extra.z);
+}
 `;
 /**
  * The two targets composited over what the opaque half drew.
@@ -337,3 +397,28 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
   results[out + 3u] = resolved.z;
 }
 `;
+/**
+ * `glassShade` alone, as a dispatch, so it can be checked against `gpudriven/lit.ts`.
+ *
+ * Sixteen floats a case — own, seen, transmission, frost, tint, the view cosine, the glow, one
+ * spare — and four out, the colour and one spare.
+ */
+export const GLASS_SHADE_PARITY_WGSL = /* wgsl */ `
+@group(0) @binding(0) var<storage, read> cases: array<f32>;
+@group(0) @binding(1) var<storage, read_write> results: array<f32>;
+${GLASS_SHADE_WGSL}
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x * 16u + 15u >= arrayLength(&cases)) { return; }
+  let at = id.x * 16u;
+  let own = vec3<f32>(cases[at], cases[at + 1u], cases[at + 2u]);
+  let seen = vec3<f32>(cases[at + 3u], cases[at + 4u], cases[at + 5u]);
+  let tint = vec3<f32>(cases[at + 8u], cases[at + 9u], cases[at + 10u]);
+  let glow = vec3<f32>(cases[at + 12u], cases[at + 13u], cases[at + 14u]);
+  let shaded = glassShade(own, seen, cases[at + 6u], cases[at + 7u], tint, cases[at + 11u], glow);
+  let out = id.x * 4u;
+  results[out] = shaded.x;
+  results[out + 1u] = shaded.y;
+  results[out + 2u] = shaded.z;
+}
+`;

package/dist/render/shaders/gpudriven/cull.wgsl.d.ts

@@ -43,7 +43,7 @@ export declare const CULL_INSTANCES_WGSL = "\n@group(0) @binding(0) var<storage,
  * wall and is the whole reason the front half of the pipeline is reusable. A scene with nothing
  * blended runs this once and the filter costs it one comparison against a uniform.
  */
-export declare const LOD_CUT_WGSL = "\nstruct Params {\n  screenHeight: f32,\n  fovY: f32,\n  thresholdPixels: f32,\n  eyeX: f32,\n  eyeY: f32,\n  eyeZ: f32,\n  /** Non-zero to select the blended clusters, zero to select everything else. */\n  wantBlend: f32,\n};\n\nstruct Material {\n  /** rgb is the tint, w is the emissive gain. */\n  tint: vec4<f32>,\n  /** x is the roughness, y the specular reflectance, z the environment's and w the metalness. */\n  surface: vec4<f32>,\n  /** Base colour, normal, ORM and emissive programs; NO_PROGRAM where there is none. */\n  programs: vec4<u32>,\n  /** u scale, v scale, normal strength, occlusion strength. */\n  maps: vec4<f32>,\n  /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */\n  orm: vec4<f32>,\n  /** The blended opacity, and three spare. */\n  extra: vec4<f32>,\n}\n\nconst NO_PROGRAM: u32 = 4294967295u;\n\n@group(0) @binding(0) var<storage, read> params: array<f32, 7>;\n/** Six floats a cluster: centre, radius, own error, parent error. */\n@group(0) @binding(1) var<storage, read> clusters: array<f32>;\n@group(0) @binding(2) var<storage, read_write> selected: array<u32>;\n/** Four words a cluster: index offset, index count, identifier, mesh. */\n@group(0) @binding(3) var<storage, read> clusterMeta: array<u32>;\n/** One word a mesh, nonzero where CULL_INSTANCES_WGSL found it wholly outside the view. */\n@group(0) @binding(4) var<storage, read> instanceHidden: array<u32>;\n/** One material a cluster, and the table it indexes. Both only to read one flag. */\n@group(0) @binding(5) var<storage, read> materialOf: array<u32>;\n@group(0) @binding(6) var<uniform> materials: array<Material, 64>;\n\nfn projectedError(error: f32, distance: f32, radius: f32, screenHeight: f32, fovY: f32) -> f32 {\n  let safe = max(max(distance, radius), 1e-4);\n  let scale = screenHeight / (2.0 * tan(fovY * 0.5));\n  return (error * scale) / safe;\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i * 6u + 5u >= arrayLength(&clusters)) { return; }\n  /* A hidden mesh contributes nothing, so none of its clusters is in the cut at any level. */\n  if (instanceHidden[clusterMeta[i * 4u + 3u]] != 0u) {\n    selected[i] = 0u;\n    return;\n  }\n  /*\n   * **Which half of the frame this cluster belongs to, asked once.** The two halves are exclusive:\n   * a blended cluster is not in the opaque cut and an opaque one is not in the blended cut, so\n   * neither is drawn twice and neither is dropped. The flag is read through a uniform by an index\n   * that is the same for every cluster of a mesh, so the branch is as coherent as this shader gets.\n   */\n  let blended = materials[min(materialOf[i], 63u)].orm.w != 0.0;\n  if (blended != (params[6] != 0.0)) {\n    selected[i] = 0u;\n    return;\n  }\n  let screenHeight = params[0];\n  let fovY = params[1];\n  let threshold = params[2];\n  let eye = vec3<f32>(params[3], params[4], params[5]);\n\n  let centre = vec3<f32>(clusters[i * 6u], clusters[i * 6u + 1u], clusters[i * 6u + 2u]);\n  let radius = clusters[i * 6u + 3u];\n  let ownError = clusters[i * 6u + 4u];\n  let parentError = clusters[i * 6u + 5u];\n  let distance = length(centre - eye);\n\n  let own = projectedError(ownError, distance, radius, screenHeight, fovY);\n  let parent = projectedError(parentError, distance, radius, screenHeight, fovY);\n  /* Both halves: the first alone draws every ancestor too, the second alone draws nothing. */\n  selected[i] = select(0u, 1u, own <= threshold && parent > threshold);\n}\n";
+export declare const LOD_CUT_WGSL = "\nstruct Params {\n  screenHeight: f32,\n  fovY: f32,\n  thresholdPixels: f32,\n  eyeX: f32,\n  eyeY: f32,\n  eyeZ: f32,\n  /** Non-zero to select the blended clusters, zero to select everything else. */\n  wantBlend: f32,\n  /** Non-zero to keep, of those, only glass: what the light's glass pass draws. */\n  wantGlass: f32,\n};\n\nstruct Material {\n  /** rgb is the tint, w is the emissive gain. */\n  tint: vec4<f32>,\n  /** x is the roughness, y the specular reflectance, z the environment's and w the metalness. */\n  surface: vec4<f32>,\n  /** Base colour, normal, ORM and emissive programs; NO_PROGRAM where there is none. */\n  programs: vec4<u32>,\n  /** u scale, v scale, normal strength, occlusion strength. */\n  maps: vec4<f32>,\n  /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */\n  orm: vec4<f32>,\n  /** The blended opacity, the glass's transmission and frost, and one spare. */\n  extra: vec4<f32>,\n  /** The glass's tint, white where the material is not glass, and one spare. */\n  glassTint: vec4<f32>,\n}\n\nconst NO_PROGRAM: u32 = 4294967295u;\n\n@group(0) @binding(0) var<storage, read> params: array<f32, 8>;\n/** Six floats a cluster: centre, radius, own error, parent error. */\n@group(0) @binding(1) var<storage, read> clusters: array<f32>;\n@group(0) @binding(2) var<storage, read_write> selected: array<u32>;\n/** Four words a cluster: index offset, index count, identifier, mesh. */\n@group(0) @binding(3) var<storage, read> clusterMeta: array<u32>;\n/** One word a mesh, nonzero where CULL_INSTANCES_WGSL found it wholly outside the view. */\n@group(0) @binding(4) var<storage, read> instanceHidden: array<u32>;\n/** One material a cluster, and the table it indexes. Both only to read one flag. */\n@group(0) @binding(5) var<storage, read> materialOf: array<u32>;\n@group(0) @binding(6) var<uniform> materials: array<Material, 64>;\n\nfn projectedError(error: f32, distance: f32, radius: f32, screenHeight: f32, fovY: f32) -> f32 {\n  let safe = max(max(distance, radius), 1e-4);\n  let scale = screenHeight / (2.0 * tan(fovY * 0.5));\n  return (error * scale) / safe;\n}\n\n@compute @workgroup_size(64)\nfn main(@builtin(global_invocation_id) id: vec3<u32>) {\n  let i = id.x;\n  if (i * 6u + 5u >= arrayLength(&clusters)) { return; }\n  /* A hidden mesh contributes nothing, so none of its clusters is in the cut at any level. */\n  if (instanceHidden[clusterMeta[i * 4u + 3u]] != 0u) {\n    selected[i] = 0u;\n    return;\n  }\n  /*\n   * **Which half of the frame this cluster belongs to, asked once.** The two halves are exclusive:\n   * a blended cluster is not in the opaque cut and an opaque one is not in the blended cut, so\n   * neither is drawn twice and neither is dropped. The flag is read through a uniform by an index\n   * that is the same for every cluster of a mesh, so the branch is as coherent as this shader gets.\n   */\n  let material = materials[min(materialOf[i], 63u)];\n  let blended = material.orm.w != 0.0;\n  if (blended != (params[6] != 0.0)) {\n    selected[i] = 0u;\n    return;\n  }\n  /* The light's glass pass: a blended surface that is not glass casts nothing, as on the forward\n     path, so only a material letting light through is kept. */\n  if (params[7] != 0.0 && material.extra.y <= 0.0) {\n    selected[i] = 0u;\n    return;\n  }\n  let screenHeight = params[0];\n  let fovY = params[1];\n  let threshold = params[2];\n  let eye = vec3<f32>(params[3], params[4], params[5]);\n\n  let centre = vec3<f32>(clusters[i * 6u], clusters[i * 6u + 1u], clusters[i * 6u + 2u]);\n  let radius = clusters[i * 6u + 3u];\n  let ownError = clusters[i * 6u + 4u];\n  let parentError = clusters[i * 6u + 5u];\n  let distance = length(centre - eye);\n\n  let own = projectedError(ownError, distance, radius, screenHeight, fovY);\n  let parent = projectedError(parentError, distance, radius, screenHeight, fovY);\n  /* Both halves: the first alone draws every ancestor too, the second alone draws nothing. */\n  selected[i] = select(0u, 1u, own <= threshold && parent > threshold);\n}\n";
 /**
  * The pyramid's base level, copied out of the depth attachment a phase drew into.
  *

package/dist/render/shaders/gpudriven/cull.wgsl.js

@@ -100,9 +100,11 @@ struct Params {
   eyeZ: f32,
   /** Non-zero to select the blended clusters, zero to select everything else. */
   wantBlend: f32,
+  /** Non-zero to keep, of those, only glass: what the light's glass pass draws. */
+  wantGlass: f32,
 };
 ${MATERIAL_TABLE_WGSL}
-@group(0) @binding(0) var<storage, read> params: array<f32, 7>;
+@group(0) @binding(0) var<storage, read> params: array<f32, 8>;
 /** Six floats a cluster: centre, radius, own error, parent error. */
 @group(0) @binding(1) var<storage, read> clusters: array<f32>;
 @group(0) @binding(2) var<storage, read_write> selected: array<u32>;
@@ -135,11 +137,18 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
    * neither is drawn twice and neither is dropped. The flag is read through a uniform by an index
    * that is the same for every cluster of a mesh, so the branch is as coherent as this shader gets.
    */
-  let blended = materials[min(materialOf[i], ${MATERIAL_SLOTS - 1}u)].orm.w != 0.0;
+  let material = materials[min(materialOf[i], ${MATERIAL_SLOTS - 1}u)];
+  let blended = material.orm.w != 0.0;
   if (blended != (params[6] != 0.0)) {
     selected[i] = 0u;
     return;
   }
+  /* The light's glass pass: a blended surface that is not glass casts nothing, as on the forward
+     path, so only a material letting light through is kept. */
+  if (params[7] != 0.0 && material.extra.y <= 0.0) {
+    selected[i] = 0u;
+    return;
+  }
   let screenHeight = params[0];
   let fovY = params[1];
   let threshold = params[2];

package/dist/render/shaders/gpudriven/materialTable.wgsl.d.ts

@@ -22,4 +22,4 @@
  */
 export declare const MATERIAL_SLOTS = 64;
 /** The struct and the sentinel, for any module that binds the table. */
-export declare const MATERIAL_TABLE_WGSL = "\nstruct Material {\n  /** rgb is the tint, w is the emissive gain. */\n  tint: vec4<f32>,\n  /** x is the roughness, y the specular reflectance, z the environment's and w the metalness. */\n  surface: vec4<f32>,\n  /** Base colour, normal, ORM and emissive programs; NO_PROGRAM where there is none. */\n  programs: vec4<u32>,\n  /** u scale, v scale, normal strength, occlusion strength. */\n  maps: vec4<f32>,\n  /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */\n  orm: vec4<f32>,\n  /** The blended opacity, and three spare. */\n  extra: vec4<f32>,\n}\n\nconst NO_PROGRAM: u32 = 4294967295u;\n";
+export declare const MATERIAL_TABLE_WGSL = "\nstruct Material {\n  /** rgb is the tint, w is the emissive gain. */\n  tint: vec4<f32>,\n  /** x is the roughness, y the specular reflectance, z the environment's and w the metalness. */\n  surface: vec4<f32>,\n  /** Base colour, normal, ORM and emissive programs; NO_PROGRAM where there is none. */\n  programs: vec4<u32>,\n  /** u scale, v scale, normal strength, occlusion strength. */\n  maps: vec4<f32>,\n  /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */\n  orm: vec4<f32>,\n  /** The blended opacity, the glass's transmission and frost, and one spare. */\n  extra: vec4<f32>,\n  /** The glass's tint, white where the material is not glass, and one spare. */\n  glassTint: vec4<f32>,\n}\n\nconst NO_PROGRAM: u32 = 4294967295u;\n";

package/dist/render/shaders/gpudriven/materialTable.wgsl.js

@@ -35,8 +35,10 @@ struct Material {
   maps: vec4<f32>,
   /** Roughness scale, metallic scale, the alpha cutoff, and non-zero where this one blends. */
   orm: vec4<f32>,
-  /** The blended opacity, and three spare. */
+  /** The blended opacity, the glass's transmission and frost, and one spare. */
   extra: vec4<f32>,
+  /** The glass's tint, white where the material is not glass, and one spare. */
+  glassTint: vec4<f32>,
 }
 
 const NO_PROGRAM: u32 = ${DECODE_NO_PROGRAM}u;

package/dist/render/shaders/gpudriven/shade.wgsl.js

@@ -8,6 +8,7 @@ import { MATERIAL_SLOTS, MATERIAL_TABLE_WGSL } from './materialTable.wgsl.js';
 import { MESH_TRANSFORM_WGSL } from './meshTransform.wgsl.js';
 import { ENVIRONMENT_WGSL } from './environment.wgsl.js';
 import { SHADE_SHADOW_WGSL } from './shadow.wgsl.js';
+import { SUN_GLASS_WGSL } from './sunGlass.wgsl.js';
 /**
  * Rebuilding a pixel's surface from the triangle it recorded, on the device.
  *
@@ -509,6 +510,14 @@ struct Job {
 @group(0) @binding(12) var environmentMap: texture_2d_array<f32>;
 @group(0) @binding(13) var environmentSampler: sampler;
 ${decodeResourcesWgsl({ group: 0, latents: 14, clampSampler: 15, repeatSampler: 16, nodes: 17, weights: 18 })}
+/*
+ * **What the sun keeps through glass: the nearest pane's depth and what the panes let through**,
+ * which the pass draws from the sun after its opaque map. Where no material is glass the depth is
+ * the opaque map again and the tint a single white texel, which sunGlassAt reads as none.
+ */
+@group(0) @binding(19) var glassDepthMap: texture_depth_2d;
+@group(0) @binding(20) var glassTints: texture_2d<f32>;
+@group(0) @binding(21) var glassSampler: sampler;
 
 fn decodeLatentSize() -> f32 {
   return frame.size.w;
@@ -540,6 +549,45 @@ fn shadowDepthAt(u: f32, v: f32) -> f32 {
   return textureLoad(shadowMap, vec2<i32>(x, y), 0);
 }
 ${SHADE_SHADOW_WGSL}
+
+/* sunGlass.wgsl.ts's three reads, as the opaque map is read: nearest by integer coordinate. */
+fn glassDepthAt(u: f32, v: f32) -> f32 {
+  let size = frame.shadow.y;
+  let x = i32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = i32(clamp(floor(v * size), 0.0, size - 1.0));
+  return textureLoad(glassDepthMap, vec2<i32>(x, y), 0);
+}
+
+fn glassTintTexel(u: f32, v: f32) -> vec4<f32> {
+  let size = f32(textureDimensions(glassTints, 0).x);
+  let x = i32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = i32(clamp(floor(v * size), 0.0, size - 1.0));
+  return textureLoad(glassTints, vec2<i32>(x, y), 0);
+}
+
+/* The tint over a spread, from the chain: the level whose texel is the spread's width. */
+fn glassTintAround(u: f32, v: f32, radius: f32) -> vec4<f32> {
+  let size = f32(textureDimensions(glassTints, 0).x);
+  return textureSampleLevel(glassTints, glassSampler, vec2<f32>(u, v), log2(max(radius * size, 1.0)));
+}
+${SUN_GLASS_WGSL}
+
+/*
+ * The sun's colour at this receiver after the panes between it and the sun: white where no glass
+ * cast, and faded with the opaque shadow's own strength. The map's scale in metres comes off the
+ * light's matrix, which is orthographic: a compute invocation has no derivatives to take it from.
+ */
+fn sunGlassAt(lightPos: vec3<f32>) -> vec3<f32> {
+  if (textureDimensions(glassTints, 0).x <= 1u || frame.shadow.x <= 0.0) { return vec3<f32>(1.0); }
+  let m = frame.lightViewProj;
+  var settings: SunGlassSettings;
+  settings.mapSize = frame.shadow.y;
+  settings.depthSpan = frame.shadow.z;
+  settings.uvPerMetre = 0.5 * length(vec3<f32>(m[0][0], m[1][0], m[2][0]));
+  settings.taps = frame.shadowLimits.y;
+  let tint = sunGlass(lightPos.x * 0.5 + 0.5, lightPos.y * 0.5 + 0.5, lightPos.z, settings);
+  return mix(vec3<f32>(1.0), tint, frame.shadow.x);
+}
 ${ENVIRONMENT_WGSL}
 ${FOG_WGSL}
 
@@ -732,7 +780,8 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 
   var room: LitEnvironment;
   room.lightDir = frame.lightDir.xyz;
-  room.lightColour = frame.lightColour.xyz;
+  /* The sun's colour through whatever glass stands between it and here, as flat/main.ts's is. */
+  room.lightColour = frame.lightColour.xyz * sunGlassAt(lightPos);
   room.sky = frame.sky.xyz;
   room.ground = frame.ground.xyz;
   /*

package/dist/render/shaders/gpudriven/sunGlass.wgsl.d.ts

@@ -0,0 +1,9 @@
+export declare const SUN_GLASS_WGSL: string;
+/**
+ * `sunGlass` over maps held in storage buffers, read as the reference reads them, so the whole
+ * lookup can be compared with `glassTintAt` rather than only the arithmetic between the reads.
+ *
+ * Four floats a case in — u, v, the receiver's depth, one spare — and four out, the tint and one
+ * spare. The config is the map's size, the depth span, map units a metre, and the tap count.
+ */
+export declare const SUN_GLASS_PARITY_WGSL: string;

package/dist/render/shaders/gpudriven/sunGlass.wgsl.js

@@ -0,0 +1,133 @@
+/**
+ * The sun through glass for the device: `gpudriven/sunGlass.ts`'s `glassTintAt`, term for term, as
+ * the text the shading pass and the parity entry point both include.
+ *
+ * **The reads are the including module's**, as `SHADE_SHADOW_WGSL`'s are: `glassDepthAt(u, v)` the
+ * nearest pane's depth, `glassTintTexel(u, v)` the tint at the finest level, and
+ * `glassTintAround(u, v, radius)` the tint averaged over a spread of that radius. The shading pass
+ * answers the last from the tint's mip chain; the parity entry answers it with the reference's own
+ * box average, so everything around the reads is checked as it stands. Every constant is the
+ * reference's, interpolated rather than restated.
+ */
+import { FROST_RADIUS_CAP, FROST_SPREAD } from '../../glassShadow.js';
+import { SHADOW_DEPTH_BIAS, SHADOW_PCF_OFFSETS, SHADOW_TEXEL_SCALE, } from '../../gpudriven/shadow.js';
+import { SHADE_SHADOW_WGSL } from './shadow.wgsl.js';
+export const SUN_GLASS_WGSL = /* wgsl */ `
+struct SunGlassSettings {
+  mapSize: f32,
+  depthSpan: f32,
+  uvPerMetre: f32,
+  taps: f32,
+}
+
+/*
+ * A coarse texel with the open ground's white taken back out, by how milky the pane at the
+ * receiver is: the pane's colour and its share of the texel. glassShadow.ts's unmixTint.
+ */
+fn sunGlassUnmix(mip: vec4<f32>, centreClarity: f32) -> vec4<f32> {
+  if (centreClarity >= 1.0) { return vec4<f32>(mip.xyz, 1.0); }
+  let share = clamp((1.0 - mip.w) / (1.0 - centreClarity), 0.0, 1.0);
+  if (share <= 0.0) { return vec4<f32>(1.0, 1.0, 1.0, 0.0); }
+  let colour = clamp((mip.xyz - vec3<f32>(1.0 - share)) / share, vec3<f32>(0.0), vec3<f32>(1.0));
+  return vec4<f32>(colour, share);
+}
+
+/* What the sun keeps through glass at map position (u, v) and light depth "depth". */
+fn sunGlass(u: f32, v: f32, depth: f32, settings: SunGlassSettings) -> vec3<f32> {
+  if (u < 0.0 || u > 1.0 || v < 0.0 || v > 1.0) { return vec3<f32>(1.0); }
+  let texel = ${SHADOW_TEXEL_SCALE.toFixed(4)} / settings.mapSize;
+  let bias = ${SHADOW_DEPTH_BIAS.toFixed(4)} / settings.depthSpan;
+  let taps = min(u32(settings.taps), ${SHADOW_PCF_OFFSETS.length}u);
+  let clarity = glassTintTexel(u, v).w;
+  let behind = max(depth - glassDepthAt(u, v), 0.0) * settings.depthSpan;
+  let spread = (1.0 - clarity) * ${FROST_SPREAD.toFixed(6)} * behind * settings.uvPerMetre;
+  let radius = min(max(texel, spread), texel * ${FROST_RADIUS_CAP.toFixed(1)});
+
+  var cover = 0.0;
+  var colour = vec3<f32>(0.0);
+  var found = 0.0;
+  for (var i = 0u; i < taps; i = i + 1u) {
+    let offset = SHADOW_TAPS[i];
+    /* The outline: a tap counts the pane only where the receiver is behind it, by the bias. */
+    if (depth > glassDepthAt(u + offset.x * texel, v + offset.y * texel) + bias) {
+      cover = cover + 1.0;
+    }
+    /* The colour: the spread's taps, each an average, unmixed and weighed by the pane's share. */
+    let pane = sunGlassUnmix(glassTintAround(u + offset.x * radius, v + offset.y * radius, radius), clarity);
+    colour = colour + pane.xyz * pane.w;
+    found = found + pane.w;
+  }
+  let mixed = select(vec3<f32>(1.0), colour / max(found, 1e-6), found > 0.0);
+  return mix(vec3<f32>(1.0), mixed, cover / f32(max(taps, 1u)));
+}
+`;
+/**
+ * `sunGlass` over maps held in storage buffers, read as the reference reads them, so the whole
+ * lookup can be compared with `glassTintAt` rather than only the arithmetic between the reads.
+ *
+ * Four floats a case in — u, v, the receiver's depth, one spare — and four out, the tint and one
+ * spare. The config is the map's size, the depth span, map units a metre, and the tap count.
+ */
+export const SUN_GLASS_PARITY_WGSL = /* wgsl */ `
+@group(0) @binding(0) var<storage, read> depths: array<f32>;
+@group(0) @binding(1) var<storage, read> tints: array<f32>;
+@group(0) @binding(2) var<storage, read> cases: array<f32>;
+@group(0) @binding(3) var<storage, read> config: array<f32>;
+@group(0) @binding(4) var<storage, read_write> results: array<f32>;
+
+/* The opaque lookup's own read, which this entry never calls: included only for its tap table. */
+fn shadowDepthAt(u: f32, v: f32) -> f32 { return 1.0; }
+${SHADE_SHADOW_WGSL}
+
+fn glassIndex(u: f32, v: f32) -> u32 {
+  let size = config[0];
+  let x = u32(clamp(floor(u * size), 0.0, size - 1.0));
+  let y = u32(clamp(floor(v * size), 0.0, size - 1.0));
+  return y * u32(size) + x;
+}
+
+fn glassDepthAt(u: f32, v: f32) -> f32 {
+  return depths[glassIndex(u, v)];
+}
+
+fn glassTintTexel(u: f32, v: f32) -> vec4<f32> {
+  let at = glassIndex(u, v) * 4u;
+  return vec4<f32>(tints[at], tints[at + 1u], tints[at + 2u], tints[at + 3u]);
+}
+
+/* The reference's coarse read: the average of every texel within the radius. */
+fn glassTintAround(u: f32, v: f32, radius: f32) -> vec4<f32> {
+  let size = config[0];
+  let reach = radius * size;
+  let x0 = u32(max(0.0, floor(u * size - reach)));
+  let x1 = u32(min(size - 1.0, floor(u * size + reach)));
+  let y0 = u32(max(0.0, floor(v * size - reach)));
+  let y1 = u32(min(size - 1.0, floor(v * size + reach)));
+  var sum = vec4<f32>(0.0);
+  var n = 0.0;
+  for (var y = y0; y <= y1; y = y + 1u) {
+    for (var x = x0; x <= x1; x = x + 1u) {
+      let at = (y * u32(size) + x) * 4u;
+      sum = sum + vec4<f32>(tints[at], tints[at + 1u], tints[at + 2u], tints[at + 3u]);
+      n = n + 1.0;
+    }
+  }
+  return sum / max(n, 1.0);
+}
+${SUN_GLASS_WGSL}
+
+@compute @workgroup_size(64)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+  if (id.x * 4u + 3u >= arrayLength(&cases)) { return; }
+  var settings: SunGlassSettings;
+  settings.mapSize = config[0];
+  settings.depthSpan = config[1];
+  settings.uvPerMetre = config[2];
+  settings.taps = config[3];
+  let at = id.x * 4u;
+  let tint = sunGlass(cases[at], cases[at + 1u], cases[at + 2u], settings);
+  results[at] = tint.x;
+  results[at + 1u] = tint.y;
+  results[at + 2u] = tint.z;
+}
+`;

package/dist/render/shaders/lightVolume.js

@@ -46,6 +46,7 @@
  *   the window it came through, and without it a barred floor under a smooth shaft is two
  *   halves of one frame disagreeing about the same light.
  */
+import { SUN_DYNAMIC_LAYER, SUN_PEELED_LAYER, SUN_STATIC_LAYER } from '../shadowMap.js';
 import { resolveConditionals } from './conditionals.js';
 export const LIGHT_VOLUME_VERT = `#version 300 es
 precision highp float;
@@ -143,9 +144,8 @@ uniform vec3 uDustOffset;
 uniform float uSunShadow;
 uniform mat4 uLightViewProj;
 uniform float uShadowMapSize;
-uniform sampler2D uStaticShadowMap;
-uniform sampler2D uPeeledShadowMap;
-uniform sampler2D uDynamicShadowMap;
+/* The sun's static, moving and peeled maps, as layers of one array: see shadowMap.ts. */
+uniform highp sampler2DArray uSunShadows;
 uniform int uPeeledShadowEnabled;
 #endif
 
@@ -308,11 +308,11 @@ float sunReach(vec3 worldPos) {
   if (edgeFade <= 0.0) return 1.0;
 
   float compare = p.z - BIAS;
-  float blocked = occlusion(textureLod(uStaticShadowMap, p.xy, 0.0).r, compare);
+  float blocked = occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_STATIC_LAYER}.0), 0.0).r, compare);
   if (uPeeledShadowEnabled != 0) {
-    blocked = max(blocked, occlusion(textureLod(uPeeledShadowMap, p.xy, 0.0).r, compare));
+    blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_PEELED_LAYER}.0), 0.0).r, compare));
   }
-  blocked = max(blocked, occlusion(textureLod(uDynamicShadowMap, p.xy, 0.0).r, compare));
+  blocked = max(blocked, occlusion(textureLod(uSunShadows, vec3(p.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r, compare));
   return mix(1.0, 1.0 - blocked, uSunShadow * edgeFade);
 }
 #endif

package/dist/render/shaders/octahedralResolve.d.ts

@@ -23,3 +23,11 @@ export declare const OCTAHEDRAL_RESOLVE_VERT = "#version 300 es\nvoid main() {\n
  * redeclaration and GLSL rejects the whole shader.
  */
 export declare const OCTAHEDRAL_RESOLVE_FRAG = "#version 300 es\nprecision highp float;\n\n/** The face the bake just rendered, as a depth texture. */\nuniform highp sampler2D uFace;\n/** That face's world-to-face rotation. See pointShadowFaceRotation. */\nuniform mat3 uFaceRotation;\n/** Which of the six this pass is resolving. Every other texel discards. */\nuniform int uFaceIndex;\nuniform float uFar;\nuniform float uNear;\n/** The octahedral map's edge, so this needs no viewport query. */\nuniform float uEdge;\n\nvec2 octEncode(vec3 d) {\n  vec3 n = d / (abs(d.x) + abs(d.y) + abs(d.z));\n  vec2 p = n.z >= 0.0\n    ? n.xy\n    : (1.0 - abs(vec2(n.y, n.x))) * vec2(n.x >= 0.0 ? 1.0 : -1.0, n.y >= 0.0 ? 1.0 : -1.0);\n  return p * 0.5 + 0.5;\n}\n\nvec3 octDecode(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  vec3 n = vec3(f.x, f.y, 1.0 - abs(f.x) - abs(f.y));\n  float t = max(-n.z, 0.0);\n  n.x += n.x >= 0.0 ? -t : t;\n  n.y += n.y >= 0.0 ? -t : t;\n  return normalize(n);\n}\n\nvec2 octWrapUv(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  if (f.x < -1.0 || f.x > 1.0) {\n    f.x = (f.x > 0.0 ? 2.0 : -2.0) - f.x;\n    f.y = -f.y;\n  }\n  if (f.y < -1.0 || f.y > 1.0) {\n    f.y = (f.y > 0.0 ? 2.0 : -2.0) - f.y;\n    f.x = -f.x;\n  }\n  return f * 0.5 + 0.5;\n}\n\nvec2 octInsetUv(vec3 d, float edge) {\n  return (octEncode(d) * (edge - 2.0) + 1.0) / edge;\n}\n\nvec3 octInsetDir(vec2 uv, float edge) {\n  return octDecode(octWrapUv((uv * edge - 1.0) / (edge - 2.0)));\n}\n\nvoid main() {\n  vec3 d = octDecode(gl_FragCoord.xy / uEdge);\n\n  /*\n   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the\n   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.\n   */\n  vec3 a = abs(d);\n  int face;\n  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;\n  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;\n  else face = d.z >= 0.0 ? 4 : 5;\n  if (face != uFaceIndex) discard;\n\n  /* lookAt looks down -z, so a direction inside this face has a negative z here. */\n  vec3 v = uFaceRotation * d;\n  float forward = -v.z;\n  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;\n\n  /*\n   * textureLod at level zero rather than plain texture. The scratch carries one storage level and\n   * NEAREST filtering so the fetch is identical, and this call sits after a discard \u2014 which is\n   * non-uniform control flow, where an implicit derivative is undefined in GLSL and rejected\n   * outright in WGSL. AGENTS.md, 2026-08-07.\n   */\n  float stored = textureLod(uFace, faceUv, 0.0).r;\n  if (stored >= 0.9999) {\n    /* Nothing was rendered along this direction, so the stored radius is the far plane. */\n    gl_FragDepth = 1.0;\n    return;\n  }\n  float ndc = stored * 2.0 - 1.0;\n  float faceLocalZ = (2.0 * uFar * uNear) / (uFar + uNear - ndc * (uFar - uNear));\n  /* d is a unit vector, so forward is its cosine to the axis and this is the true radius. */\n  gl_FragDepth = clamp((faceLocalZ / forward) / uFar, 0.0, 1.0);\n}";
+/**
+ * One face of a lamp's glass tint into its region of the tint layer: the depth resolve's region,
+ * and a colour copied rather than a depth decoded.
+ *
+ * **Nearest, at level zero**, like the depth beside it: the tint's outline has to land on the
+ * glass depth's texels, and a filtered copy would smear a pane's colour a texel past its edge.
+ */
+export declare const OCTAHEDRAL_RESOLVE_TINT_FRAG = "#version 300 es\nprecision highp float;\n\n/** The face the bake just tinted, as colour. */\nuniform highp sampler2D uFace;\nuniform mat3 uFaceRotation;\nuniform int uFaceIndex;\nuniform float uEdge;\n\nout vec4 outTint;\n\nvec2 octEncode(vec3 d) {\n  vec3 n = d / (abs(d.x) + abs(d.y) + abs(d.z));\n  vec2 p = n.z >= 0.0\n    ? n.xy\n    : (1.0 - abs(vec2(n.y, n.x))) * vec2(n.x >= 0.0 ? 1.0 : -1.0, n.y >= 0.0 ? 1.0 : -1.0);\n  return p * 0.5 + 0.5;\n}\n\nvec3 octDecode(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  vec3 n = vec3(f.x, f.y, 1.0 - abs(f.x) - abs(f.y));\n  float t = max(-n.z, 0.0);\n  n.x += n.x >= 0.0 ? -t : t;\n  n.y += n.y >= 0.0 ? -t : t;\n  return normalize(n);\n}\n\nvec2 octWrapUv(vec2 uv) {\n  vec2 f = uv * 2.0 - 1.0;\n  if (f.x < -1.0 || f.x > 1.0) {\n    f.x = (f.x > 0.0 ? 2.0 : -2.0) - f.x;\n    f.y = -f.y;\n  }\n  if (f.y < -1.0 || f.y > 1.0) {\n    f.y = (f.y > 0.0 ? 2.0 : -2.0) - f.y;\n    f.x = -f.x;\n  }\n  return f * 0.5 + 0.5;\n}\n\nvec2 octInsetUv(vec3 d, float edge) {\n  return (octEncode(d) * (edge - 2.0) + 1.0) / edge;\n}\n\nvec3 octInsetDir(vec2 uv, float edge) {\n  return octDecode(octWrapUv((uv * edge - 1.0) / (edge - 2.0)));\n}\n\nvoid main() {\n  vec3 d = octDecode(gl_FragCoord.xy / uEdge);\n\n  /*\n   * Which face owns this texel. The tie-breaking is x, then y, then z, and it has to match the\n   * CPU's exactly or a sliver of texels along a boundary belongs to two faces or to none.\n   */\n  vec3 a = abs(d);\n  int face;\n  if (a.x >= a.y && a.x >= a.z) face = d.x >= 0.0 ? 0 : 1;\n  else if (a.y >= a.z) face = d.y >= 0.0 ? 2 : 3;\n  else face = d.z >= 0.0 ? 4 : 5;\n  if (face != uFaceIndex) discard;\n\n  /* lookAt looks down -z, so a direction inside this face has a negative z here. */\n  vec3 v = uFaceRotation * d;\n  float forward = -v.z;\n  vec2 faceUv = (v.xy / forward) * 0.5 + 0.5;\n  outTint = textureLod(uFace, faceUv, 0.0);\n}";