@driftengine/core 4.4.2 → 4.6.0

package/src/render/glassCasters.ts

@@ -0,0 +1,164 @@
+/**
+ * The glass a shadow pass was offered, kept aside to be drawn twice once the opaque casters are in:
+ * where the nearest pane is, and what the panes let through. See `glassShadow.ts`.
+ *
+ * **Recorded rather than drawn at once**, because the two glass passes each need the whole set and
+ * a pass of their own, and the caster enumeration is the consumer's to run exactly once per pass.
+ * A pool of entries grown on demand and never shrunk, so a steady scene records into the entries
+ * the frame before it made — no allocation per frame, the house rule for a per-pass path.
+ *
+ * What it keeps by reference is only what outlives the pass that recorded it: the mesh, the batch
+ * and its instance data, a skinned caster's palette, and the material. The model matrix is copied,
+ * because a caller is entitled to reuse one scratch matrix between sink calls.
+ */
+import type { ReadonlyMat4 } from 'gl-matrix';
+import type { ResolvedGlass } from './glass.ts';
+import type { InstancedHandle, MeshHandle } from './backend/api.ts';
+import type { MeshInstances } from './instances.ts';
+import type { SceneCasterMaterial } from './shadowCasters.ts';
+
+const MESH = 0;
+const INSTANCED = 1;
+const SKINNED = 2;
+
+interface GlassEntry {
+  kind: number;
+  mesh: MeshHandle | null;
+  batch: InstancedHandle | null;
+  data: MeshInstances | null;
+  palette: Float32Array | null;
+  readonly model: Float32Array;
+  material: SceneCasterMaterial | undefined;
+  readonly glass: ResolvedGlass;
+}
+
+/** Where a replay goes: each entry with its own glass, as the depth and tint passes want it. */
+export interface GlassReplaySink {
+  mesh(
+    mesh: MeshHandle,
+    model: ReadonlyMat4,
+    material: SceneCasterMaterial | undefined,
+    glass: ResolvedGlass,
+  ): void;
+  instanced(
+    batch: InstancedHandle,
+    data: MeshInstances,
+    material: SceneCasterMaterial | undefined,
+    glass: ResolvedGlass,
+  ): void;
+  skinnedMesh(
+    mesh: MeshHandle,
+    model: ReadonlyMat4,
+    palette: Float32Array,
+    material: SceneCasterMaterial | undefined,
+    glass: ResolvedGlass,
+  ): void;
+}
+
+export class GlassCasterList {
+  private readonly pool: GlassEntry[] = [];
+  private used = 0;
+
+  /** How many glass casters this pass has recorded. */
+  get count(): number {
+    return this.used;
+  }
+
+  /** How many entries the pool holds, recorded or not: what a steady scene stops growing. */
+  get pooled(): number {
+    return this.pool.length;
+  }
+
+  recordMesh(
+    mesh: MeshHandle,
+    model: ReadonlyMat4,
+    material: SceneCasterMaterial | undefined,
+    glass: ResolvedGlass,
+  ): void {
+    const entry = this.take(MESH, material, glass);
+    entry.mesh = mesh;
+    entry.model.set(model as ArrayLike<number>);
+  }
+
+  recordInstanced(
+    batch: InstancedHandle,
+    data: MeshInstances,
+    material: SceneCasterMaterial | undefined,
+    glass: ResolvedGlass,
+  ): void {
+    const entry = this.take(INSTANCED, material, glass);
+    entry.batch = batch;
+    entry.data = data;
+  }
+
+  recordSkinned(
+    mesh: MeshHandle,
+    model: ReadonlyMat4,
+    palette: Float32Array,
+    material: SceneCasterMaterial | undefined,
+    glass: ResolvedGlass,
+  ): void {
+    const entry = this.take(SKINNED, material, glass);
+    entry.mesh = mesh;
+    entry.palette = palette;
+    entry.model.set(model as ArrayLike<number>);
+  }
+
+  /** Every recorded caster, in the order it was offered. */
+  replay(sink: GlassReplaySink): void {
+    for (let i = 0; i < this.used; i++) {
+      const entry = this.pool[i] as GlassEntry;
+      if (entry.kind === INSTANCED && entry.batch !== null && entry.data !== null) {
+        sink.instanced(entry.batch, entry.data, entry.material, entry.glass);
+      } else if (entry.kind === SKINNED && entry.mesh !== null && entry.palette !== null) {
+        sink.skinnedMesh(entry.mesh, entry.model, entry.palette, entry.material, entry.glass);
+      } else if (entry.mesh !== null) {
+        sink.mesh(entry.mesh, entry.model, entry.material, entry.glass);
+      }
+    }
+  }
+
+  /** Forget this pass's casters; the entries stay for the next one. */
+  clear(): void {
+    for (let i = 0; i < this.used; i++) {
+      const entry = this.pool[i] as GlassEntry;
+      /* Released so a disposed mesh is not held alive by a list nobody will replay again. */
+      entry.mesh = null;
+      entry.batch = null;
+      entry.data = null;
+      entry.palette = null;
+      entry.material = undefined;
+    }
+    this.used = 0;
+  }
+
+  private take(
+    kind: number,
+    material: SceneCasterMaterial | undefined,
+    glass: ResolvedGlass,
+  ): GlassEntry {
+    let entry = this.pool[this.used];
+    if (entry === undefined) {
+      entry = {
+        kind,
+        mesh: null,
+        batch: null,
+        data: null,
+        palette: null,
+        model: new Float32Array(16),
+        material,
+        glass: { transmission: 0, frost: 0, tint: [1, 1, 1] },
+      };
+      this.pool.push(entry);
+    }
+    this.used++;
+    entry.kind = kind;
+    entry.material = material;
+    entry.glass.transmission = glass.transmission;
+    entry.glass.frost = glass.frost;
+    entry.glass.tint[0] = glass.tint[0];
+    entry.glass.tint[1] = glass.tint[1];
+    entry.glass.tint[2] = glass.tint[2];
+    return entry;
+  }
+}

package/src/render/glassShadow.ts

@@ -0,0 +1,153 @@
+/**
+ * Coloured light through glass: how one pane filters light, how panes combine, which receivers a
+ * pane tints, and how far frost spreads the colour — the reference the shaders state term for term.
+ *
+ * **Frost spreads light, it does not remove it.** Etched glass passes 88–91% of visible light
+ * against clear float glass's ~90%, so a frosted pane passes `transmission × (1 − F) × tint` like a
+ * clear one and only the filter widens. What it gives up: the spread stays inside the opaque frame's
+ * shadow, so light from a frosted pane does not reach past the outline of the frame around it. What
+ * would make it wrong is glass that genuinely absorbs as it diffuses — opal glass, milk glass — for
+ * which a lower `transmission` is the honest statement.
+ *
+ * **What else it does not reach**: light that bounces. DriftRay's probe bake and DriftLight's summed
+ * far field see a pane as absent, so the light a tinted window sends round a room by bouncing is its
+ * sun's own colour; only the direct light through the pane takes the tint.
+ */
+import { schlickFresnel, type ResolvedGlass } from './glass.ts';
+
+/** One tint texel: the light a stack of panes lets through, and how clear the stack is. */
+export interface GlassTexel {
+  r: number;
+  g: number;
+  b: number;
+  clarity: number;
+}
+
+/** No glass: everything passes, perfectly clear. What a tint map is cleared to. */
+export const CLEAR_TEXEL: Readonly<GlassTexel> = { r: 1, g: 1, b: 1, clarity: 1 };
+
+/** How widely a fully frosted pane spreads its colour: a 30° half-angle cone behind it. */
+export const FROST_SPREAD = Math.tan(Math.PI / 6);
+
+/**
+ * The spread never exceeds this many base filter radii, and the tap count never changes.
+ *
+ * **Sixty-four, because the tint is read from the mip level the spread asks for**: each tap is then
+ * already an average over its own share of the spread, so taps far apart do not alias into grain.
+ * It was eight before the tint had mips, and on a sun map a few centimetres a texel that capped a
+ * frosted pane's spread at seven centimetres — frost that nobody saw. What the cap still bounds is
+ * a pane so frosted and so far above a floor that its colour would wash over a room.
+ */
+export const FROST_RADIUS_CAP = 64;
+
+/** One pane as a tint texel, lit at `cosLight` to its normal. Fresnel as `glass.ts` states it. */
+export function paneTexel(glass: ResolvedGlass, cosLight: number, out: GlassTexel): GlassTexel {
+  const passes = glass.transmission * (1 - schlickFresnel(cosLight));
+  out.r = passes * glass.tint[0];
+  out.g = passes * glass.tint[1];
+  out.b = passes * glass.tint[2];
+  out.clarity = 1 - glass.frost;
+  return out;
+}
+
+/** Two stacks of glass on one ray: a product, so the order they are drawn in cannot matter. */
+export function combinePanes(a: GlassTexel, b: GlassTexel, out: GlassTexel): GlassTexel {
+  out.r = a.r * b.r;
+  out.g = a.g * b.g;
+  out.b = a.b * b.b;
+  out.clarity = a.clarity * b.clarity;
+  return out;
+}
+
+/**
+ * What one filter tap contributes: the glass's texel where the receiver is behind the pane, and
+ * nothing where it is on the light's side of it — or is the pane, which the bias keeps untinted.
+ */
+export function tapTint(
+  receiverDepth: number,
+  glassDepth: number,
+  bias: number,
+  glass: GlassTexel,
+  out: GlassTexel,
+): GlassTexel {
+  const behind = receiverDepth > glassDepth + bias;
+  out.r = behind ? glass.r : 1;
+  out.g = behind ? glass.g : 1;
+  out.b = behind ? glass.b : 1;
+  out.clarity = behind ? glass.clarity : 1;
+  return out;
+}
+
+/**
+ * A frosted pane's tint at a receiver: the outline from the taps at the base radius, the colour
+ * from the spread taps that found glass — nothing else.
+ *
+ * **Split because a tint cannot carry light out past a pane.** Blurring the tint map whole pulls in
+ * the white of the unobstructed ground around a pane, which brightens the patch — measured at 10%
+ * more light over a frosted window than a clear one — while the pane's own light, which should
+ * spread onto that ground, has no way to exceed full sun there. So the outline stays where the
+ * clear pane's is (`coverage`, the share of outline taps behind glass) and only the colour spreads,
+ * averaged over glass alone (`colourSum` over `colourCount`, the summed pane shares `unmixTint`
+ * reports — continuous, so a colour crossing between panes blends rather than stepping): neighbouring
+ * panes mix, a pattern blurs, and the light through the patch is what it was. What it gives up is
+ * spread past the outline, which the spec states; with no glass found by the spread the colour is
+ * clear.
+ */
+export function spreadTint(
+  coverage: number,
+  colourSum: GlassTexel,
+  colourCount: number,
+  out: GlassTexel,
+): GlassTexel {
+  const r = colourCount > 0 ? colourSum.r / colourCount : 1;
+  const g = colourCount > 0 ? colourSum.g / colourCount : 1;
+  const b = colourCount > 0 ? colourSum.b / colourCount : 1;
+  out.r = 1 + (r - 1) * coverage;
+  out.g = 1 + (g - 1) * coverage;
+  out.b = 1 + (b - 1) * coverage;
+  out.clarity = 1;
+  return out;
+}
+
+/**
+ * A coarse level of the tint, with the open ground's white taken back out: returns the pane's share
+ * of the texel and writes the pane's own colour to `out`.
+ *
+ * **Why a level needs this**: it averages a pane with whatever lies beside it, and beside a pane is
+ * usually open ground, which the tint holds as white — so a frosted patch read coarse is paler than
+ * the pane, and measured 6% more light than the clear pane over the same floor. The clarity channel
+ * says how much of the texel was pane: open ground holds 1, the pane its own `centreClarity`, so
+ * the pane's share is `(1 − a) / (1 − centreClarity)` and its colour follows by subtraction. What it
+ * assumes is that the frost around a receiver is the frost at its centre, which is true within a
+ * pane and blends where two panes of different frost meet; a clear pane (`centreClarity` 1) is
+ * never read coarse, so it is returned as it stands.
+ */
+export function unmixTint(mip: GlassTexel, centreClarity: number, out: GlassTexel): number {
+  if (centreClarity >= 1) {
+    out.r = mip.r;
+    out.g = mip.g;
+    out.b = mip.b;
+    out.clarity = mip.clarity;
+    return 1;
+  }
+  const share = Math.min(1, Math.max(0, (1 - mip.clarity) / (1 - centreClarity)));
+  if (share <= 0) {
+    out.r = 1;
+    out.g = 1;
+    out.b = 1;
+    out.clarity = 1;
+    return 0;
+  }
+  const ground = 1 - share;
+  out.r = Math.min(1, Math.max(0, (mip.r - ground) / share));
+  out.g = Math.min(1, Math.max(0, (mip.g - ground) / share));
+  out.b = Math.min(1, Math.max(0, (mip.b - ground) / share));
+  out.clarity = centreClarity;
+  return share;
+}
+
+/** The filter radius for a receiver `paneToReceiver` behind a pane of this clarity. */
+export function frostRadius(clarity: number, paneToReceiver: number, baseRadius: number): number {
+  const spread = (1 - clarity) * FROST_SPREAD * Math.max(paneToReceiver, 0);
+  return Math.min(Math.max(baseRadius, spread), baseRadius * FROST_RADIUS_CAP);
+}

package/src/render/globalMediumPass.ts

@@ -19,9 +19,8 @@ export interface MediumLight {
   readonly sunShadow: number;
   /** World → light clip, **uncorrected**: the shader does its own `* 0.5 + 0.5`. */
   readonly lightViewProj: ReadonlyMat4;
-  readonly staticShadowMap: WebGLTexture;
-  readonly peeledShadowMap: WebGLTexture;
-  readonly dynamicShadowMap: WebGLTexture;
+  /** The sun's static, moving and peeled maps, as one array. See `shadowMap.ts`. */
+  readonly sunShadows: WebGLTexture;
   readonly peeledEnabled: boolean;
 }
 
@@ -210,14 +209,8 @@ export class GlobalMediumPass {
     gl.bindTexture(gl.TEXTURE_2D, depth);
     gl.uniform1i(u['uDepth'] ?? null, 0);
     gl.activeTexture(gl.TEXTURE1);
-    gl.bindTexture(gl.TEXTURE_2D, light.staticShadowMap);
-    gl.uniform1i(u['uStaticShadowMap'] ?? null, 1);
-    gl.activeTexture(gl.TEXTURE2);
-    gl.bindTexture(gl.TEXTURE_2D, light.peeledShadowMap);
-    gl.uniform1i(u['uPeeledShadowMap'] ?? null, 2);
-    gl.activeTexture(gl.TEXTURE3);
-    gl.bindTexture(gl.TEXTURE_2D, light.dynamicShadowMap);
-    gl.uniform1i(u['uDynamicShadowMap'] ?? null, 3);
+    gl.bindTexture(gl.TEXTURE_2D_ARRAY, light.sunShadows);
+    gl.uniform1i(u['uSunShadows'] ?? null, 1);
 
     gl.uniformMatrix4fv(u['uDepthToWorld'] ?? null, false, this.depthToWorld);
     gl.uniform3f(u['uCameraPos'] ?? null, eye[0] ?? 0, eye[1] ?? 0, eye[2] ?? 0);

package/src/render/gpudriven/lit.ts

@@ -2,6 +2,7 @@
 
 import { EMISSIVE_SHADOW_SHARE, MIN_LOBE_ALPHA } from '../shaders/flat/lobes.ts';
 import { environmentWeight } from './ibl.ts';
+import { schlickFresnel, type ResolvedGlass } from '../glass.ts';
 
 /**
  * **The lit expression had no reference until 2026-09-16, and that was a gap rather than a policy.**
@@ -327,3 +328,33 @@ export function litColour(
   }
   return out;
 }
+
+/**
+ * Glass over its own shading: what is behind it shown by how much it lets through and how little it
+ * reflects at this angle, and the light behind it glowing through by how frosted it is — the forward
+ * path's glass branch (`flat/main.ts`) and `glass.ts`'s arithmetic, for the blended raster's twin.
+ *
+ * **`cosView` is taken unsigned**, because a pane passes the same light seen from either side.
+ * `sunGlow` is the light arriving at the pane's far side from the eye, which frost scatters toward
+ * it; a clear pane shows that light's source in `seen` instead. Allocates nothing: `out` is the
+ * caller's, and may be `own`.
+ */
+export function glassShade(
+  own: readonly [number, number, number],
+  seen: readonly [number, number, number],
+  glass: ResolvedGlass,
+  cosView: number,
+  sunGlow: readonly [number, number, number],
+  out: [number, number, number],
+): [number, number, number] {
+  const t = glass.transmission;
+  const shown = t * (1 - schlickFresnel(Math.abs(cosView)));
+  const glowing = glass.frost * t;
+  for (let c = 0; c < 3; c++) {
+    const tint = glass.tint[c] as number;
+    const mine = own[c] as number;
+    out[c] =
+      mine + ((seen[c] as number) * tint - mine) * shown + (sunGlow[c] as number) * tint * glowing;
+  }
+  return out;
+}

package/src/render/gpudriven/materialTable.ts

@@ -1,6 +1,7 @@
-/** A GPU-driven material as the shading pass reads it: five blocks, one of them integers. */
+/** A GPU-driven material as the shading pass reads it: seven blocks, one of them integers. */
 
 import type { GpuDrivenMaterial } from '../backend/webgpu/gpuDrivenPass.ts';
+import { resolveGlass, type ResolvedGlass } from '../glass.ts';
 import { DECODE_NO_PROGRAM } from '../shaders/gpudriven/decode.wgsl.ts';
 import type { GpuDrivenProgram } from './decodeTables.ts';
 
@@ -34,17 +35,18 @@ export interface GpuDrivenTextures {
 
 /**
  * Words a material entry: tint and emissive, the surface scalars, four program indices, the UV
- * scale and two strengths, the two ORM scales with the cutout and blend flags, and
- * the opacity with three spare.
+ * scale and two strengths, the two ORM scales with the cutout and blend flags, the opacity with the
+ * glass's transmission and frost and one spare, and the glass's tint with one spare.
  *
  * **It was eight until 2026-09-17**, and metalness took its last spare lane the same day, so the
  * programs and the scales needed three more blocks rather than squeezing into what was left. It
  * became twenty-four on 2026-09-18, when transparency arrived and there was nowhere left to put an
  * opacity: the cutout took lane 18 and the blend flag took 19, and lane 11 is a reserved program
  * slot rather than a gap. A sixteen-byte block is 1 kB across the whole table, against the 64 kB a
- * uniform buffer may hold.
+ * uniform buffer may hold. **Twenty-eight on 2026-09-29**, for glass: its transmission and frost
+ * took two of the opacity block's spares and its tint needed a block of its own.
  */
-export const GPU_DRIVEN_MATERIAL_FLOATS = 24;
+export const GPU_DRIVEN_MATERIAL_FLOATS = 28;
 
 /**
  * Below this base-colour alpha the raster discards a fragment. Zero means no test.
@@ -74,6 +76,16 @@ export const MATERIAL_BLEND = 19;
  */
 export const MATERIAL_OPACITY = 20;
 
+/**
+ * Glass (`glass.ts`): how much light passes, and how milky it is. Zero transmission is not glass,
+ * and a material that is glass is drawn in the blended half whatever `blend` says — a visibility
+ * buffer holds one surface a pixel, and glass is two.
+ */
+export const MATERIAL_GLASS_TRANSMISSION = 21;
+export const MATERIAL_GLASS_FROST = 22;
+/** The colour light takes through the glass: three lanes, white where the material is not glass. */
+export const MATERIAL_GLASS_TINT = 24;
+
 /**
  * Where a material's emissive program is: the fourth program lane, which the table reserved and
  * initialised to none before anything used it.
@@ -155,10 +167,20 @@ export function writeMaterialTable(
     float(m, 17, textures?.metallicScale ?? 1);
     /* Zero is off, so a material that says nothing about cutout writes the table it wrote before. */
     float(m, MATERIAL_ALPHA_CUTOFF, material.alphaCutoff ?? 0);
+    /* Glass A's clamps and its test of what is glass at all, so both pipelines agree on it. */
+    const glass = resolveGlass(material.glass, glassScratch);
     /* Zero is opaque, so a material that says nothing about blending stays in the opaque half. */
-    float(m, MATERIAL_BLEND, material.blend === true ? 1 : 0);
+    float(m, MATERIAL_BLEND, material.blend === true || glass ? 1 : 0);
     /* One, so a material that asked to blend and said nothing else is as solid as an opaque one. */
     float(m, MATERIAL_OPACITY, material.opacity ?? 1);
+    float(m, MATERIAL_GLASS_TRANSMISSION, glassScratch.transmission);
+    float(m, MATERIAL_GLASS_FROST, glassScratch.frost);
+    float(m, MATERIAL_GLASS_TINT, glassScratch.tint[0]);
+    float(m, MATERIAL_GLASS_TINT + 1, glassScratch.tint[1]);
+    float(m, MATERIAL_GLASS_TINT + 2, glassScratch.tint[2]);
   });
   return buffer;
 }
+
+/** One resolution every material's glass is read through. */
+const glassScratch: ResolvedGlass = { transmission: 0, frost: 0, tint: [1, 1, 1] };

package/src/render/gpudriven/pipeline.ts

@@ -132,11 +132,11 @@ export const GPU_DRIVEN_PASSES = [
   'phaseTwoCull',
   'phaseTwoDraw',
   'blendCull',
-  'blendDraw',
   'visibilityCopy',
   'bin',
   'cursorCopy',
   'shade',
+  'blendDraw',
   'blendResolve',
 ] as const;
 
@@ -230,10 +230,11 @@ function edgesFor(res: GpuDrivenResources): {
     /*
      * **It reads the depth the opaque half wrote and does not write it.** A pane behind a wall is
      * rejected at the wall; nothing here writes depth, so two panes do not hide each other and
-     * there is something left to blend.
+     * there is something left to blend. **And it reads the shaded colour**, because glass shows the
+     * opaque picture behind it — which is why it is recorded after `shade` rather than before.
      */
     blendDraw: [
-      [res.blendList, res.clusters, res.depth],
+      [res.blendList, res.clusters, res.depth, res.colour],
       [res.oitAccum, res.oitReveal],
     ],
     visibilityCopy: [[res.visibility], [res.visibilityCopy]],

package/src/render/gpudriven/sunGlass.ts

@@ -0,0 +1,117 @@
+/**
+ * The second pipeline's sunlight through glass, as a reference: `glassTintAt` over the glass depth
+ * and tint maps the GPU-driven pass draws from the sun, for `shade.wgsl.ts`'s lookup to be read
+ * against.
+ *
+ * **The forward path's rule, not a second one** (`glassShadow.ts`, and `sunGlassLookup` in
+ * `flat/directionalShadow.ts`): the outline from taps at the base filter radius that count a pane
+ * only where the receiver is behind it, and the colour from spread taps read coarse, unmixed from
+ * the ground around the pane by its clarity and weighed by its share. Frost widens only the
+ * colour's taps, so the light a frosted pane passes is the light a clear one does.
+ *
+ * **What differs is where two numbers come from.** A compute invocation has no derivatives, so the
+ * map's scale in metres is the caller's (`uvPerMetre`, which an orthographic light matrix states
+ * outright); and a coarse level here is a box average over the spread's footprint, which is what a
+ * mip level approximates on the device. `scripts/gpu-parity.mjs` holds the device's per-tap
+ * arithmetic to `glassShadow.ts`; the sampling is what the glass page measures.
+ */
+import { frostRadius, spreadTint, unmixTint, type GlassTexel } from '../glassShadow.ts';
+import { SHADOW_DEPTH_BIAS, SHADOW_PCF_OFFSETS, SHADOW_TEXEL_SCALE } from './shadow.ts';
+
+/** The two maps the sun's glass pass draws, square, row-major from v = 0. */
+export interface SunGlassMaps {
+  readonly size: number;
+  /** The nearest pane's depth a texel, 1 where no pane was drawn. */
+  readonly glassDepth: Float32Array;
+  /** What the panes on a texel's ray let through, and their clarity: four floats a texel. */
+  readonly tint: Float32Array;
+}
+
+export interface SunGlassSettings {
+  /** Metres the light's depth range spans, which turns a depth difference into a distance. */
+  readonly depthSpan: number;
+  /** Map units a metre across the light, which turns a spread in metres into one on the map. */
+  readonly uvPerMetre: number;
+  readonly taps: number;
+}
+
+const centre: GlassTexel = { r: 1, g: 1, b: 1, clarity: 1 };
+const coarse: GlassTexel = { r: 1, g: 1, b: 1, clarity: 1 };
+const pane: GlassTexel = { r: 1, g: 1, b: 1, clarity: 1 };
+const found: GlassTexel = { r: 0, g: 0, b: 0, clarity: 0 };
+
+function index(maps: SunGlassMaps, u: number, v: number): number {
+  const x = Math.min(maps.size - 1, Math.max(0, Math.floor(u * maps.size)));
+  const y = Math.min(maps.size - 1, Math.max(0, Math.floor(v * maps.size)));
+  return y * maps.size + x;
+}
+
+/** The average of every texel within `radius` of (u, v): a mip level's footprint, in the large. */
+function coarseAt(maps: SunGlassMaps, u: number, v: number, radius: number, out: GlassTexel): void {
+  const reach = radius * maps.size;
+  const x0 = Math.max(0, Math.floor(u * maps.size - reach));
+  const x1 = Math.min(maps.size - 1, Math.floor(u * maps.size + reach));
+  const y0 = Math.max(0, Math.floor(v * maps.size - reach));
+  const y1 = Math.min(maps.size - 1, Math.floor(v * maps.size + reach));
+  out.r = 0;
+  out.g = 0;
+  out.b = 0;
+  out.clarity = 0;
+  let n = 0;
+  for (let y = y0; y <= y1; y++) {
+    for (let x = x0; x <= x1; x++) {
+      const at = (y * maps.size + x) * 4;
+      out.r += maps.tint[at] as number;
+      out.g += maps.tint[at + 1] as number;
+      out.b += maps.tint[at + 2] as number;
+      out.clarity += maps.tint[at + 3] as number;
+      n++;
+    }
+  }
+  out.r /= n;
+  out.g /= n;
+  out.b /= n;
+  out.clarity /= n;
+}
+
+/** What the sun keeps through glass at a receiver at map position (u, v) and light depth `depth`. */
+export function glassTintAt(
+  u: number,
+  v: number,
+  depth: number,
+  maps: SunGlassMaps,
+  settings: SunGlassSettings,
+  out: GlassTexel,
+): GlassTexel {
+  out.r = 1;
+  out.g = 1;
+  out.b = 1;
+  out.clarity = 1;
+  if (u < 0 || u > 1 || v < 0 || v > 1) return out;
+  const texel = SHADOW_TEXEL_SCALE / maps.size;
+  const bias = SHADOW_DEPTH_BIAS / settings.depthSpan;
+  const taps = Math.min(settings.taps, SHADOW_PCF_OFFSETS.length);
+
+  const at = index(maps, u, v);
+  centre.clarity = maps.tint[at * 4 + 3] as number;
+  const behind = Math.max(depth - (maps.glassDepth[at] as number), 0) * settings.depthSpan;
+  const radius = frostRadius(centre.clarity, behind * settings.uvPerMetre, texel);
+
+  let cover = 0;
+  found.r = 0;
+  found.g = 0;
+  found.b = 0;
+  let shares = 0;
+  for (let i = 0; i < taps; i++) {
+    const offset = SHADOW_PCF_OFFSETS[i] as readonly [number, number];
+    const nearest = maps.glassDepth[index(maps, u + offset[0] * texel, v + offset[1] * texel)];
+    if (depth > (nearest as number) + bias) cover++;
+    coarseAt(maps, u + offset[0] * radius, v + offset[1] * radius, radius, coarse);
+    const share = unmixTint(coarse, centre.clarity, pane);
+    found.r += pane.r * share;
+    found.g += pane.g * share;
+    found.b += pane.b * share;
+    shares += share;
+  }
+  return spreadTint(cover / Math.max(taps, 1), found, shares, out);
+}