@driftengine/core 4.4.2 → 4.5.0

package/src/render/shaders/flat/directionalShadow.ts

@@ -1,5 +1,13 @@
 /** Filtering the directional cascade, with receiver-plane depth gradient compensation. */
 import { DIRECTIONAL_SHADOW_FADE_START, MAX_SHADOW_FILTER_TAPS } from '../../renderQuality.ts';
+import {
+  SUN_DYNAMIC_LAYER,
+  SUN_GLASS_MOVING_LAYER,
+  SUN_GLASS_STATIC_LAYER,
+  SUN_PEELED_LAYER,
+  SUN_STATIC_LAYER,
+} from '../../shadowMap.ts';
+import { FROST_RADIUS_CAP, FROST_SPREAD } from '../../glassShadow.ts';
 
 export const DIRECTIONALSHADOW_GLSL = `vec2 receiverPlaneDepthGradient(vec3 p) {
   vec3 dx = dFdx(p);
@@ -127,10 +135,10 @@ float shadowFactor(float directionalNdl) {
    */
   float coarseCompare = p.z - 1.0 / uShadowDepthSpan;
   float coarse =
-    directionalVisibility(p.z, coarseCompare, textureLod(uStaticShadowMap, p.xy, 0.0).r) *
-    directionalVisibility(p.z, coarseCompare, textureLod(uDynamicShadowMap, p.xy, 0.0).r);
+    directionalVisibility(p.z, coarseCompare, textureLod(uSunShadows, vec3(p.xy, ${SUN_STATIC_LAYER}.0), 0.0).r) *
+    directionalVisibility(p.z, coarseCompare, textureLod(uSunShadows, vec3(p.xy, ${SUN_DYNAMIC_LAYER}.0), 0.0).r);
   if (uPeeledShadowEnabled != 0) {
-    coarse *= directionalVisibility(p.z, coarseCompare, textureLod(uPeeledShadowMap, p.xy, 0.0).r);
+    coarse *= directionalVisibility(p.z, coarseCompare, textureLod(uSunShadows, vec3(p.xy, ${SUN_PEELED_LAYER}.0), 0.0).r);
   }
   float strength = uShadowStrength * edgeFade * lowElevationFade;
   if (receiverFade <= 0.0) return mix(1.0, coarse, strength);
@@ -191,11 +199,11 @@ float shadowFactor(float directionalNdl) {
      * \`shadowMap.ts\` allocates these with one storage level and \`NEAREST\` filtering, so
      * there is no mip to select and level zero is the only thing \`texture\` could have read.
      */
-    float staticDepth = textureLod(uStaticShadowMap, sampleUv, 0.0).r;
-    float dynamicDepth = textureLod(uDynamicShadowMap, sampleUv, 0.0).r;
+    float staticDepth = textureLod(uSunShadows, vec3(sampleUv, ${SUN_STATIC_LAYER}.0), 0.0).r;
+    float dynamicDepth = textureLod(uSunShadows, vec3(sampleUv, ${SUN_DYNAMIC_LAYER}.0), 0.0).r;
     staticLit += directionalVisibility(tapReceiverDepth, compare, staticDepth);
     if (uPeeledShadowEnabled != 0) {
-      float peeledDepth = textureLod(uPeeledShadowMap, sampleUv, 0.0).r;
+      float peeledDepth = textureLod(uSunShadows, vec3(sampleUv, ${SUN_PEELED_LAYER}.0), 0.0).r;
       peeledLit += directionalVisibility(tapReceiverDepth, compare, peeledDepth);
     } else {
       peeledLit += 1.0;
@@ -215,6 +223,89 @@ float shadowFactor(float directionalNdl) {
 
   return mix(1.0, mix(coarse, lit, receiverFade), strength);
 }
+
+/*
+ * One of the sun's two glass layers at receiver p: how milky the nearest pane is and how far behind
+ * it this receiver stands, the spread that follows (glassShadow.ts's frostRadius, capped), and the
+ * tint's level for that spread. Then glassShadow.ts's spreadTint: the outline from taps at the base
+ * radius — where the clear pane's patch ends — and the colour from the spread taps, each read coarse,
+ * unmixed from the ground around it and weighed by the pane's share of it, so a frosted patch mixes
+ * its panes' colours and keeps the light the clear one lets through. What it gives up is a pane lying
+ * behind the receiver lending it colour within the spread, which only a receiver between two panes
+ * meets. One function for both layers, because two copies were most of the lit shaders' growth.
+ */
+vec3 sunGlassLayer(vec3 p, float paneLayer, float tintLayer, float bias, float texel, float uvPerMetre) {
+  float tintSize = float(textureSize(uSunGlassTints, 0).x);
+  float clarity = textureLod(uSunGlassTints, vec3(p.xy, tintLayer), 0.0).a;
+  float behind =
+    max(p.z - textureLod(uSunShadows, vec3(p.xy, paneLayer), 0.0).r, 0.0) * uShadowDepthSpan;
+  float radius = clamp(
+    (1.0 - clarity) * ${FROST_SPREAD.toFixed(6)} * behind * uvPerMetre,
+    texel,
+    texel * ${FROST_RADIUS_CAP.toFixed(1)}
+  );
+  float lod = log2(max(radius * tintSize, 1.0));
+  float cover = 0.0;
+  vec3 colour = vec3(0.0);
+  float found = 0.0;
+  for (int i = 0; i < ${MAX_SHADOW_FILTER_TAPS}; i++) {
+    if (i >= uShadowFilterTaps) break;
+    vec2 offset = DIRECTIONAL_PCF_OFFSETS[i];
+    vec2 edgeUv = p.xy + offset * texel;
+    cover += p.z > textureLod(uSunShadows, vec3(edgeUv, paneLayer), 0.0).r + bias ? 1.0 : 0.0;
+    /* The spread taps weigh by the pane's unmixed share rather than a depth test: continuous, so a
+       colour crossing between two panes blends rather than stepping through sixteen bands. */
+    vec4 pane = glassUnmix(textureLod(uSunGlassTints, vec3(p.xy + offset * radius, tintLayer), lod), clarity);
+    colour += pane.rgb * pane.a;
+    found += pane.a;
+  }
+  float taps = float(max(uShadowFilterTaps, 1));
+  return mix(vec3(1.0), found > 0.0 ? colour / found : vec3(1.0), cover / taps);
+}
+
+/*
+ * What the sun's light keeps of itself through glass at this receiver: glassShadow.ts's tap rule
+ * and frost spread, over shadowFactor's own taps. A tap counts a pane only when the receiver is
+ * farther from the sun than that pane (the glass depth layers), so a surface on the sun's side of a
+ * pane, and the pane itself, keep the sun's own colour; the taps average with equal weight, so the
+ * spread moves light rather than losing it. Frost widens the taps by how far behind the nearest pane
+ * the receiver is, capped, with the tap count unchanged. What it gives up is spread past the edge of
+ * an opaque frame's shadow, which this lookup never sees. Faded with the opaque shadow's own fades.
+ */
+vec3 sunGlassLookup(float directionalNdl) {
+  vec3 p = vLightPos.xyz / vLightPos.w;
+  p = p * 0.5 + 0.5;
+  /* Map units per metre along the receiver, from derivatives taken first in uniform control flow,
+     so a frost spread stated in metres lands the same whatever size of light matrix a consumer built. */
+  float uvPerMetre = length(dFdx(p.xy)) / max(length(dFdx(vWorldPos)), 1e-6);
+  if (uShadowStrength <= 0.0 || textureSize(uSunGlassTints, 0).x <= 1) return vec3(1.0);
+  if (directionalNdl <= 0.0) return vec3(1.0);
+  if (p.z > 1.0 || p.x < 0.0 || p.x > 1.0 || p.y < 0.0 || p.y > 1.0) return vec3(1.0);
+  vec2 fromCentre = abs(p.xy - 0.5) * 2.0;
+  float edgeFade = 1.0 - smoothstep(0.72, 0.98, max(fromCentre.x, fromCentre.y));
+  edgeFade *= 1.0 - smoothstep(0.90, 1.0, p.z);
+  float shadowSlope = length(uDirectionalDir.xz) / max(uDirectionalDir.y, 0.001);
+  float lowElevationFade = 1.0 - smoothstep(
+    uShadowMaxSlope * ${DIRECTIONAL_SHADOW_FADE_START.toFixed(2)},
+    uShadowMaxSlope,
+    shadowSlope
+  );
+  float strength = uShadowStrength * edgeFade * lowElevationFade;
+  if (strength <= 0.0) return vec3(1.0);
+
+  float bias = 0.14 / uShadowDepthSpan;
+  float texel = 1.35 / uShadowMapSize;
+  vec3 staticTint = sunGlassLayer(p, ${SUN_GLASS_STATIC_LAYER}.0, 0.0, bias, texel, uvPerMetre);
+  vec3 movingTint = sunGlassLayer(p, ${SUN_GLASS_MOVING_LAYER}.0, 1.0, bias, texel, uvPerMetre);
+  return mix(vec3(1.0), staticTint * movingTint, strength);
+}
+
+/* The way in, asking first whether this build reads glass at all (GLASS_SHADOWS). A constant, so
+   the lookup's derivatives are still taken in uniform control flow. */
+vec3 sunGlassTint(float directionalNdl) {
+  if (GLASS_SHADOWS) return sunGlassLookup(directionalNdl);
+  return vec3(1.0);
+}
 #endif
 
 /**

package/src/render/shaders/flat/glassTint.ts

@@ -0,0 +1,25 @@
+/**
+ * What the lit stage shares between every glass tint it reads: whether it reads any, and
+ * `glassShadow.ts`'s `unmixTint`, stated once for the sun's lookup and the lamps'. At depth zero,
+ * outside every conditional, so each lookup can call it whichever shadows a permutation compiles.
+ */
+export function glassTintGlsl(glassShadows: boolean): string {
+  return /* glsl */ `
+/*
+ * Whether this build reads glass at all, which every way into the lookups asks first — and as a
+ * branch's own condition, never negated: see \`overridableConstants\` in scripts/wgsl/transform.mjs.
+ */
+const bool GLASS_SHADOWS = ${glassShadows ? 'true' : 'false'};  // wgsl:override
+/*
+ * A coarse level of a glass tint with the open ground's white taken back out, by how milky the pane
+ * at the centre is: rgb the pane's colour, a its share of the texel (glassShadow.ts's unmixTint).
+ * A clear centre is never read coarse, so it is returned as it stands.
+ */
+vec4 glassUnmix(vec4 mip, float centreClarity) {
+  if (centreClarity >= 1.0) return vec4(mip.rgb, 1.0);
+  float share = clamp((1.0 - mip.a) / (1.0 - centreClarity), 0.0, 1.0);
+  if (share <= 0.0) return vec4(1.0, 1.0, 1.0, 0.0);
+  return vec4(clamp((mip.rgb - vec3(1.0 - share)) / share, 0.0, 1.0), share);
+}
+`;
+}

package/src/render/shaders/flat/index.ts

@@ -7,6 +7,7 @@ import { preambleGlsl } from './preamble.ts';
 import { LOBES_GLSL } from './lobes.ts';
 import { POINTSHADOW_GLSL } from './pointShadow.ts';
 import { DIRECTIONALSHADOW_GLSL } from './directionalShadow.ts';
+import { glassTintGlsl } from './glassTint.ts';
 import { MORPH_GLSL } from '../morph.ts';
 import { SKINNING_GLSL } from '../skinning.ts';
 import { SURFACE_GLSL } from './surface.ts';
@@ -364,6 +365,19 @@ export interface FlatShaderOptions {
    * for its instructions not to be there.
    */
   readonly nightEmissive: boolean;
+  /**
+   * Whether this build reads glass in its shadows at all: `glassShadows` other than `'off'`. True
+   * when absent, which is what the generated WGSL is built with.
+   *
+   * **Not a permutation axis, and the payload is why.** Every lit permutation carries the glass
+   * lookups, and a second copy of each without them would be most of the generated file again. So
+   * it is one switch, `GLASS_SHADOWS`, that every way into the lookups branches on first: written
+   * into this source for WebGL2, and a pipeline-overridable constant on the generated WGSL, which
+   * the device compiles away as it would under `#if`. That matters because the lookups returning
+   * at their first line still cost the lit pass its registers — 0.42 ms at 720p on WebGL2 on the
+   * courtyard at night, measured, and nothing once compiled out.
+   */
+  readonly glassShadows?: boolean;
   /**
    * How many point lights this build declares room for. `MAX_POINT_LIGHTS` when absent.
    *
@@ -466,6 +480,9 @@ export function flatFrag(options: FlatShaderOptions): string {
        * is at depth zero, and it is still declared before `pointShadow` uses it.
        */
       OCTAHEDRAL_GLSL,
+      /* Depth zero as well: both glass lookups, sun and lamps, call it, and every permutation
+         declares its switch, which the pipelines set whether the permutation reads it or not. */
+      glassTintGlsl(options.glassShadows ?? true),
       LOBES_GLSL,
       POINTSHADOW_GLSL,
       DIRECTIONALSHADOW_GLSL,

package/src/render/shaders/flat/lampGlass.ts

@@ -0,0 +1,185 @@
+/**
+ * What a lamp's light keeps through glass at this receiver: `glassShadow.ts`'s rules over the point
+ * filter's own taps, for a round lamp and for a rectangle.
+ *
+ * **The sun's lookup, in the lamp's geometry** (`directionalShadow.ts`'s `sunGlassLookup`). The
+ * outline comes from depth-tested taps on the opaque filter's own disk — a tap counts a pane only
+ * where the receiver is farther from the lamp than that pane, by the opaque bias, and fades with
+ * the opaque shadow's own reach and penumbra — and the colour from spread taps, read coarse,
+ * unmixed from what lies around the pane and weighed by its share, so a frosted patch mixes its
+ * panes and keeps the light a clear one passes.
+ *
+ * **Where a lamp differs is the frost.** Light scattered at a pane spreads in a cone behind it, so
+ * at a receiver `behind` metres past the pane the colour comes from pane points within
+ * `(1 − clarity) × tan 30° × behind` of the ray. Seen from the lamp that is an angle over the pane's
+ * distance, and in the filter's units — offsets added to the ray at the receiver's distance — it is
+ * that spread times `dist / pane`. Capped at `FROST_RADIUS_CAP` base radii, the tap count unchanged.
+ *
+ * **What it costs** is one coarse tint fetch per shadowed lamp on a receiver with no glass near its
+ * filter — the tint is white there, and the lookup stops — and two tap loops where there is. **What
+ * it gives up** is what the sun's gives up, plus the octahedral map's fold: a coarse level averages
+ * across the map's outer edges, so a wide frost spread lying across one borrows a little colour from
+ * the other side of the sphere.
+ */
+import { FROST_RADIUS_CAP, FROST_SPREAD } from '../../glassShadow.ts';
+import { MAX_SHADOW_FILTER_TAPS } from '../../renderQuality.ts';
+
+/** Octahedral texels per radian at edge 1: the sphere's 4π over `edge²` texels, as a side. */
+const TEXELS_PER_RADIAN = 1 / Math.sqrt(4 * Math.PI);
+
+export const LAMP_GLASS_GLSL = `
+/*
+ * Whether any glass lies within \`radius\` of this ray: the tint is exactly white wherever no pane
+ * was drawn, and any pane passes at most 0.96 of itself, so one coarse fetch answers for the disk.
+ */
+bool lampGlassNear(float tintLayer, vec3 toFrag, float dist, float radius) {
+  float texels = radius / dist * float(textureSize(uPointGlassTints, 0).x) * ${TEXELS_PER_RADIAN.toFixed(6)};
+  vec4 around = textureLod(uPointGlassTints, vec3(octEncode(toFrag), tintLayer), log2(max(texels, 1.0)) + 1.0);
+  return min(min(around.r, around.g), min(around.b, around.a)) < 0.998;
+}
+
+/*
+ * The spread half: the colour of the glass the frost disk finds, read at \`lod\`, unmixed from what
+ * lies around it and weighed by its share (glassShadow.ts's spreadTint). Clear when it finds none.
+ */
+vec3 lampGlassColour(
+  float tintLayer,
+  vec3 toFrag,
+  vec3 tu,
+  vec3 tv,
+  float offset,
+  float lod,
+  float clarity,
+  float ca,
+  float sa
+) {
+  vec3 colour = vec3(0.0);
+  float found = 0.0;
+  for (int i = 0; i < ${MAX_SHADOW_FILTER_TAPS}; i++) {
+    if (i >= uShadowFilterTaps) break;
+    vec2 disk = PCF_OFFSETS[i];
+    vec2 turned = vec2(disk.x * ca - disk.y * sa, disk.x * sa + disk.y * ca);
+    vec3 spreadDir = toFrag + (tu * turned.x + tv * turned.y) * offset;
+    vec4 pane = glassUnmix(textureLod(uPointGlassTints, vec3(octEncode(spreadDir), tintLayer), lod), clarity);
+    colour += pane.rgb * pane.a;
+    found += pane.a;
+  }
+  return found > 0.0 ? colour / found : vec3(1.0);
+}
+
+/* One outline tap: how much of the pane on this ray lies between the lamp and the receiver. */
+float lampGlassTap(vec3 sampleDir, float glassLayer, float dist, float bias, float far, float size) {
+  float stored = textureLod(uPointShadows, vec3(octEncode(sampleDir), glassLayer), 0.0).r;
+  if (stored >= 0.9999) return 0.0;
+  float storedDistance = stored * far;
+  if (dist - bias <= storedDistance) return 0.0;
+  return shadowReach(max(dist - storedDistance, 0.0), far) * tapStrength(dist, storedDistance, size);
+}
+
+/*
+ * The frost's offset in the filter's units, the tint level that reads it as an average, and the
+ * pane's clarity: the cone behind the nearest pane on the ray, as the lamp sees it, capped at
+ * \`base\` radii.
+ */
+vec3 lampGlassFrost(float tintLayer, vec2 centreUv, float dist, float paneDistance, float base) {
+  float clarity = textureLod(uPointGlassTints, vec3(centreUv, tintLayer), 0.0).a;
+  float behind = max(dist - paneDistance, 0.0);
+  float frost = (1.0 - clarity) * ${FROST_SPREAD.toFixed(6)} * behind * dist / max(paneDistance, 0.05);
+  float offset = clamp(frost, base, base * ${FROST_RADIUS_CAP.toFixed(1)});
+  float texels = offset / dist * float(textureSize(uPointGlassTints, 0).x) * ${TEXELS_PER_RADIAN.toFixed(6)};
+  return vec3(offset, log2(max(texels, 1.0)), clarity);
+}
+
+/*
+ * **One lookup for both kinds of lamp**, a rectangle's being the round one with its outline taps on
+ * areaShadow's ellipse: a zero \`halfSize\` is a round lamp of \`sourceRadius\`. One function rather
+ * than two because every lit permutation carries it, and two copies of the same eighty lines were
+ * thirty-five kilobytes of the generated shaders.
+ */
+vec3 lampGlassTint(
+  float layer,
+  vec3 toFrag,
+  float far,
+  float near,
+  vec3 right,
+  vec3 up,
+  vec2 halfSize,
+  float sourceRadius
+) {
+  if (textureSize(uPointGlassTints, 0).x <= 1) return vec3(1.0);
+  float dist = length(toFrag);
+  if (dist <= near) return vec3(1.0);
+  float glassLayer = layer + 1.0;
+  float tintLayer = layer * 0.5;
+  /* The opaque filter's own widest disk, so the check covers every tap it could take. */
+  if (!lampGlassNear(tintLayer, toFrag, dist, MAX_FILTER_RADIUS + 0.012)) return vec3(1.0);
+
+  float bias = 0.04 + dist * 0.015;
+  vec2 centreUv = octEncode(toFrag);
+  float paneStored = textureLod(uPointShadows, vec3(centreUv, glassLayer), 0.0).r;
+  float paneDistance = paneStored >= 0.9999 ? dist : paneStored * far;
+  float spread = max(dist - paneDistance, 0.0) / max(paneDistance, 0.05);
+
+  vec3 fwd = toFrag / dist;
+  vec3 lift = abs(fwd.y) < 0.9 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0);
+  vec3 tu = normalize(cross(lift, fwd));
+  vec3 tv = cross(fwd, tu);
+  /* A round lamp: the opaque filter's radius, from the pane as its occluder, so a large lamp's
+     tint is soft too. A rectangle: its two axes across the ray, each with its own width. */
+  vec3 alongX = tu;
+  vec3 alongY = tv;
+  float radius = clamp(sourceRadius * spread, 0.01, MAX_FILTER_RADIUS) + 0.012;
+  float widthX = radius;
+  float widthY = radius;
+  float penumbra = sourceRadius;
+  if (halfSize.x > 0.0) {
+    vec3 acrossX = right - fwd * dot(right, fwd);
+    vec3 acrossY = up - fwd * dot(up, fwd);
+    float seenX = length(acrossX);
+    float seenY = length(acrossY);
+    alongX = seenX > 1e-5 ? acrossX / seenX : vec3(0.0);
+    alongY = seenY > 1e-5 ? acrossY / seenY : vec3(0.0);
+    float halfX = halfSize.x * seenX;
+    float halfY = halfSize.y * seenY;
+    widthX = min(halfX * spread, MAX_FILTER_RADIUS) + 0.012;
+    widthY = min(halfY * spread, MAX_FILTER_RADIUS) + 0.012;
+    penumbra = min(halfX, halfY);
+  }
+  /* pointShadow's column-pair turn, so main's pair resolve averages these taps as it does those. */
+  float angle = float(int(gl_FragCoord.x) & 1) * PCF_PAIR_TURN;
+  float ca = cos(angle);
+  float sa = sin(angle);
+
+  float cover = 0.0;
+  for (int i = 0; i < ${MAX_SHADOW_FILTER_TAPS}; i++) {
+    if (i >= uShadowFilterTaps) break;
+    vec2 disk = PCF_OFFSETS[i];
+    vec2 turned = vec2(disk.x * ca - disk.y * sa, disk.x * sa + disk.y * ca);
+    vec3 sampleDir = toFrag + alongX * (turned.x * widthX) + alongY * (turned.y * widthY);
+    cover += lampGlassTap(sampleDir, glassLayer, dist, bias, far, penumbra);
+  }
+  if (cover <= 0.0) return vec3(1.0);
+  vec3 frost = lampGlassFrost(tintLayer, centreUv, dist, paneDistance, max(widthX, widthY));
+  vec3 colour = lampGlassColour(tintLayer, toFrag, tu, tv, frost.x, frost.y, frost.z, ca, sa);
+  return mix(vec3(1.0), colour, cover / float(max(uShadowFilterTaps, 1)));
+}
+
+/* The two ways in, each asking first whether this build reads glass at all (GLASS_SHADOWS). */
+vec3 pointGlassTint(float layer, vec3 toFrag, float far, float near, float sourceRadius) {
+  if (GLASS_SHADOWS) return lampGlassTint(layer, toFrag, far, near, vec3(0.0), vec3(0.0), vec2(0.0), sourceRadius);
+  return vec3(1.0);
+}
+
+vec3 areaGlassTint(
+  float layer,
+  vec3 toFrag,
+  float far,
+  float near,
+  vec3 right,
+  vec3 up,
+  vec2 halfSize
+) {
+  if (GLASS_SHADOWS) return lampGlassTint(layer, toFrag, far, near, right, up, halfSize, 0.0);
+  return vec3(1.0);
+}
+`;

package/src/render/shaders/flat/main.ts

@@ -83,6 +83,11 @@ export const MAIN_GLSL = `void main() {
    * the branch below builds a shaded result on top of it.
    */
   vec3 lit = albedo;
+  /* The light arriving at a glass pane from behind it, gathered in each light loop below and added
+     over the see-through at the end. Stays zero for anything that is not glass. See glass.ts. */
+  vec3 glassGlow = vec3(0.0);
+  float glassTransmission = uSeeThrough.z;
+  float glassFrost = uSeeThrough.w;
 
   if (uLightingEnabled != 0) {
     vec3 n = normalize(vNormal);
@@ -94,7 +99,13 @@ export const MAIN_GLSL = `void main() {
      * back of the sheet; what that gives up is a sliver at a curved silhouette, where a front face's
      * interpolated normal already leans away and is lit as the back.
      */
-    bool backFace = uDoubleSided != 0 && dot(n, uCameraPos - vWorldPos) < 0.0;
+    /*
+     * **Glass is two-sided whatever its material says**: a pane is symmetric, so from behind the
+     * side the eye sees is the one lit, and the light on its far side is what glows through it.
+     * Taken from the stored normal alone, a pane seen from behind glowed with the light on the
+     * eye's side and not with the sun shining through it.
+     */
+    bool backFace = (uDoubleSided != 0 || glassTransmission > 0.0) && dot(n, uCameraPos - vWorldPos) < 0.0;
     /*
      * The authored normal, before either relief perturbs it.
      *
@@ -313,9 +324,13 @@ export const MAIN_GLSL = `void main() {
     float surfaceNdl = dot(surfaceN, uDirectionalDir);
 #if DIRECTIONAL_SHADOWS
     float sunShade = shadowFactor(max(surfaceNdl, 0.0));
+    /* What the sun keeps through any glass on its way here: see sunGlassLookup. */
+    vec3 sunGlass = sunGlassTint(max(surfaceNdl, 0.0));
 #else
     float sunShade = 1.0;
+    vec3 sunGlass = vec3(1.0);
 #endif
+    vec3 sunColor = uDirectionalColor * sunGlass;
     /*
      * **How much sky this vertex can see, applied to the sun and to nothing else.**
      *
@@ -343,6 +358,8 @@ export const MAIN_GLSL = `void main() {
      */
     float sunFacing = smoothstep(0.0, 0.02, surfaceNdl);
     float direct = ndl * sunShade * sunFacing;
+    /* Glass: the sun on the far side of a pane lights it through the glass. See glassGlow. */
+    if (glassTransmission > 0.0) glassGlow += sunColor * max(-surfaceNdl, 0.0) * sunShade;
 
     /*
      * Hemispheric: sky above, ground below, mixed by which way the surface looks. An
@@ -389,7 +406,7 @@ export const MAIN_GLSL = `void main() {
      * smallest change available in a shader with a documented history of shared subexpressions
      * rounding differently when their neighbours move. See the night-emissive term.
      */
-    lit = albedo * (ambient + uDirectionalColor * direct * (1.0 - metal));
+    lit = albedo * (ambient + sunColor * direct * (1.0 - metal));
 
     /*
      * A sun highlight, for the few surfaces that ask for one.
@@ -451,7 +468,7 @@ export const MAIN_GLSL = `void main() {
      * before: \`sunSpec\` is \`vec3(vSpecular)\` at metal 0 and \`vSpecular\` defaults to 0.
      */
     vec3 sunHighlight =
-      uDirectionalColor * specularLobe(max(dot(n, halfway), 0.0), surfaceRoughness) * sunSpec * sunShade * sunFacing;
+      sunColor * specularLobe(max(dot(n, halfway), 0.0), surfaceRoughness) * sunSpec * sunShade * sunFacing;
     /*
      * The dielectric's share goes in here, where it has always gone, so the environment blend
      * below dims it by exactly the reflectance it always dimmed it by. The metal's share is added
@@ -1023,7 +1040,14 @@ export const MAIN_GLSL = `void main() {
       }
       if (falloff <= 0.0) continue;
       float ndl = max(dot(n, toLight / max(dist, 1e-4)), 0.0);
-      if (ndl <= 0.0) continue;
+      /*
+       * **A lamp behind a pane is not skipped when the surface is glass**: it lights the pane through
+       * the glass, shaped and shadowed like any lamp, and is added to glassGlow once its shape is
+       * known below. For everything else a lamp behind the surface is skipped here, as always.
+       */
+      float backNdl =
+        glassTransmission > 0.0 ? max(-dot(n, toLight / max(dist, 1e-4)), 0.0) : 0.0;
+      if (ndl <= 0.0 && backNdl <= 0.0) continue;
 
       /*
        * Normal-offset bias.
@@ -1076,7 +1100,17 @@ export const MAIN_GLSL = `void main() {
        */
       int shadowRead = clamp(shadowSlot, 0, MAX_LIGHTS - 1);
       int layer = shadowSlot >= 0 && shadowSlot < MAX_LIGHTS ? uPointShadowLayer[shadowRead] : -1;
+      /* What the panes between this receiver and the lamp let through, per map: lampGlass.ts. */
+      vec3 staticGlass = vec3(1.0);
+      vec3 liveGlass = vec3(1.0);
       if (layer >= 0 && shadowWeight > POINT_SHADOW_MIN_WEIGHT) {
+        staticGlass = pointGlassTint(
+          float(layer),
+          receiverPoint - uPointShadowProjection[shadowRead].xyz,
+          uPointShadowProjection[shadowRead].w,
+          uPointShadowNear[shadowRead],
+          uPointShadowSize[shadowRead]
+        );
         occl = mix(
           1.0,
           pointShadow(
@@ -1116,10 +1150,20 @@ export const MAIN_GLSL = `void main() {
           uLivePointShadowSize[shadowRead]
         );
         liveWeight = uLivePointShadowWeight[shadowRead];
+        liveGlass = pointGlassTint(
+          float(liveLayer),
+          receiverPoint - uLivePointShadowProjection[shadowRead].xyz,
+          uLivePointShadowProjection[shadowRead].w,
+          uLivePointShadowNear[shadowRead],
+          uLivePointShadowSize[shadowRead]
+        );
       }
       occl *= mix(1.0, liveOccl, liveWeight);
+      /* Each map's glass faded in by that map's presence, as its occlusion is. */
+      vec3 lampGlass = mix(vec3(1.0), staticGlass, uPointShadowWeight[shadowRead]) * mix(vec3(1.0), liveGlass, liveWeight);
 #else
       float occl = 1.0;
+      vec3 lampGlass = vec3(1.0);
 #endif
 
       // Blend occlusion out as the light fades, so a shadow can never be more
@@ -1240,6 +1284,8 @@ export const MAIN_GLSL = `void main() {
       float photometric = mix(1.0, iesGain, step(0.0, iesProfile));
 
       float shape = (uLightFalloff == 1 ? falloff : falloff * falloff) * coneFalloff * photometric;
+      glassGlow += lightColor * backNdl * shape * lightWeight * shaded * lampGlass;
+      if (ndl <= 0.0) continue;
       /*
        * The cookie tints rather than scales, because a mask may be coloured — a stained window is
        * the case that makes the difference — and a greyscale one is exactly a scale. Applied to
@@ -1278,7 +1324,7 @@ export const MAIN_GLSL = `void main() {
        */
       vec3 lampDiffuse = albedo * lightColor * ndl * shape * lightWeight * (1.0 - metal);
       lampOpen += lampDiffuse;
-      lampShadowed += lampDiffuse * shaded;
+      lampShadowed += lampDiffuse * shaded * lampGlass;
 
       /*
        * A lamp reflected in a polished surface, which point lights could not do at all.
@@ -1313,7 +1359,7 @@ export const MAIN_GLSL = `void main() {
           lightColor * sphereLobe(max(dot(n, lampHalfway), 0.0), surfaceRoughness, lightSourceRadius, dist)
           * lampSpec * shape * lightWeight;
         lampOpen += lampHighlight;
-        lampShadowed += lampHighlight * shaded;
+        lampShadowed += lampHighlight * shaded * lampGlass;
       }
       /*
        * The most any light in range shadows this point, for the emissive term below —
@@ -1374,7 +1420,11 @@ export const MAIN_GLSL = `void main() {
        */
       float signedForm = quadFormFactor(n, vWorldPos, c0, c1, c2, c3);
       float form = mix(max(0.0, signedForm), abs(signedForm), uAreaLightTwoSided[a]);
-      if (form <= 0.0) continue;
+      /* The form factor is linear in the normal, so the one seen from behind is its negation. */
+      float backForm = glassTransmission > 0.0
+        ? mix(max(0.0, -signedForm), abs(signedForm), uAreaLightTwoSided[a])
+        : 0.0;
+      if (form <= 0.0 && backForm <= 0.0) continue;
 
       /*
        * **How much of the rectangle this fragment can actually see past whatever is in the way.**
@@ -1401,6 +1451,7 @@ export const MAIN_GLSL = `void main() {
        * is a constant nobody has measured. \`docs/IMPROVEMENTS.md\` carries the row.
        */
       float areaOccl = 1.0;
+      vec3 areaGlass = vec3(1.0);
 #if POINT_SHADOWS
       /*
        * The sample position is pushed along the surface normal before the lookup, and it scales
@@ -1441,6 +1492,12 @@ export const MAIN_GLSL = `void main() {
           ),
           uAreaShadowWeight[a]
         );
+        /* What the panes before the rectangle let through, faded in as its occlusion is. */
+        areaGlass = mix(
+          vec3(1.0),
+          areaGlassTint(float(areaLayer), areaShadowFrom, uAreaShadowFar[a], uAreaShadowNear[a], right, up, halfSize),
+          uAreaShadowWeight[a]
+        );
       }
       int areaLiveLayer = uLiveAreaShadowLayer[a];
       if (areaLiveLayer >= 0) {
@@ -1458,13 +1515,28 @@ export const MAIN_GLSL = `void main() {
           ),
           uLiveAreaShadowWeight[a]
         );
+        areaGlass *= mix(
+          vec3(1.0),
+          areaGlassTint(
+            float(areaLiveLayer),
+            areaShadowFrom,
+            uLiveAreaShadowFar[a],
+            uLiveAreaShadowNear[a],
+            right,
+            up,
+            halfSize
+          ),
+          uLiveAreaShadowWeight[a]
+        );
       }
 #endif
 
+      glassGlow += uAreaLightColor[a] * backForm * areaOccl * areaGlass;
+      if (form <= 0.0) continue;
       /* Held back with the point lamps', and shadowed by the same term it always was. */
       vec3 areaDiffuse = albedo * uAreaLightColor[a] * form * (1.0 - metal);
       lampOpen += areaDiffuse;
-      lampShadowed += areaDiffuse * areaOccl;
+      lampShadowed += areaDiffuse * areaOccl * areaGlass;
 
       if (vSpecular > 0.0 || metal > 0.0) {
         /*
@@ -1491,7 +1563,7 @@ export const MAIN_GLSL = `void main() {
           vec3 areaSpec = specColor * areaDfg.x + vec3(areaDfg.y);
           vec3 areaHighlight = areaSpec * uAreaLightColor[a] * coverage;
           lampOpen += areaHighlight;
-          lampShadowed += areaHighlight * areaOccl;
+          lampShadowed += areaHighlight * areaOccl * areaGlass;
         }
       }
     }
@@ -1551,6 +1623,9 @@ export const MAIN_GLSL = `void main() {
      * \`driftLight.ts\`.
      */
     if (driftShare > 0.0) {
+      if (glassTransmission > 0.0) {
+        glassGlow += driftLightIrradiance(vWorldPos, -n) * (driftShare * uDriftLight.w);
+      }
       lit += albedo * driftLightIrradiance(vWorldPos, n) * (driftShare * uDriftLight.w) * (1.0 - metal);
     }
 
@@ -1738,14 +1813,39 @@ export const MAIN_GLSL = `void main() {
    * splitting the specular out before the fog, which is a larger change to the one shader every
    * draw uses.
    */
-  if (uRefractStrength > 0.0) {
+  if (uSeeThrough.x > 0.0 || glassTransmission > 0.0) {
     vec3 refractN = normalize(vNormal);
     vec3 refractV = normalize(uCameraPos - vWorldPos);
-    vec2 screenUv = gl_FragCoord.xy / vec2(textureSize(uRefractScene, 0));
-    vec2 bent = clamp(screenUv + refractN.xy * uRefractStrength, vec2(0.0), vec2(1.0));
-    vec3 behind = texture(uRefractScene, bent).rgb;
-    float pathLength = uRefractThickness * vThickness / max(dot(refractN, refractV), 0.05);
-    shaded = behind * pow(uRefractTint, vec3(pathLength));
+    ivec2 snapSize = textureSize(uRefractScene, 0);
+    vec2 screenUv = gl_FragCoord.xy / vec2(snapSize);
+    vec2 bent = clamp(screenUv + refractN.xy * uSeeThrough.x, vec2(0.0), vec2(1.0));
+    /*
+     * **An explicit level, and frost is what picks it** — the 2026-08-07 rule, and the reason a
+     * frosted pane blurs rather than fades: the copy carries a mip chain on a frame that draws glass,
+     * so a milkier pane reads a coarser level of it. Level 0 on a copy with one level is exactly what
+     * \`texture()\` read here before, so plain refraction draws as it did.
+     */
+    /* Two short of the last level: a fully frosted pane still shows the large light and dark of what
+       is behind it, where the chain's last level is one texel, the whole frame's average. */
+    float levels = max(floor(log2(float(max(snapSize.x, snapSize.y)))) - 2.0, 0.0);
+    vec3 behind = textureLod(uRefractScene, bent, glassFrost * levels).rgb;
+    /* Unsigned: a pane passes the same light seen from either side, and so does its Fresnel. */
+    float cosView = max(abs(dot(refractN, refractV)), 0.05);
+    float pathLength = uSeeThrough.y * vThickness / cosView;
+    vec3 seen = behind * pow(uRefractTint, vec3(pathLength));
+    if (glassTransmission > 0.0) {
+      /*
+       * **Glass keeps its own surface and shows what is behind over it**, by how much it lets
+       * through and how little it reflects at this angle — Schlick's Fresnel at 0.04, the arithmetic
+       * \`glass.ts\` states. So a clear pane keeps its highlight, and a pane seen edge-on is a mirror.
+       * The glow of the lights behind it is added last, by how frosted it is.
+       */
+      float fresnel = 0.04 + 0.96 * pow(1.0 - cosView, 5.0);
+      shaded = mix(shaded, seen * uGlassTint, glassTransmission * (1.0 - fresnel)) +
+        applyOutputTransform(glassGlow * uGlassTint * (glassFrost * glassTransmission) * (1.0 - fog));
+    } else {
+      shaded = seen;
+    }
   }
   /*
    * The per-vertex alpha lane, folded in here rather than given an expression of its own so the

package/src/render/shaders/flat/pointShadow.ts

@@ -14,6 +14,7 @@
  */
 import { MAX_SHADOW_FILTER_TAPS } from '../../renderQuality.ts';
 import { OUTPUT_TRANSFORM_GLSL } from '../outputTransform.ts';
+import { LAMP_GLASS_GLSL } from './lampGlass.ts';
 
 export const POINTSHADOW_GLSL = `/**
  * How much of one tap's occlusion survives its own penumbra.
@@ -338,6 +339,7 @@ float areaShadow(
   }
   return lit / float(max(uShadowFilterTaps, 1));
 }
+${LAMP_GLASS_GLSL}
 #endif
 
 out vec4 outColor;