@driftengine/core 4.4.2 → 4.6.0

package/dist/render/glassCasters.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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';
+/** 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 declare class GlassCasterList {
+    private readonly pool;
+    private used;
+    /** How many glass casters this pass has recorded. */
+    get count(): number;
+    /** How many entries the pool holds, recorded or not: what a steady scene stops growing. */
+    get pooled(): number;
+    recordMesh(mesh: MeshHandle, model: ReadonlyMat4, material: SceneCasterMaterial | undefined, glass: ResolvedGlass): void;
+    recordInstanced(batch: InstancedHandle, data: MeshInstances, material: SceneCasterMaterial | undefined, glass: ResolvedGlass): void;
+    recordSkinned(mesh: MeshHandle, model: ReadonlyMat4, palette: Float32Array, material: SceneCasterMaterial | undefined, glass: ResolvedGlass): void;
+    /** Every recorded caster, in the order it was offered. */
+    replay(sink: GlassReplaySink): void;
+    /** Forget this pass's casters; the entries stay for the next one. */
+    clear(): void;
+    private take;
+}

package/dist/render/glassCasters.js

@@ -0,0 +1,84 @@
+const MESH = 0;
+const INSTANCED = 1;
+const SKINNED = 2;
+export class GlassCasterList {
+    pool = [];
+    used = 0;
+    /** How many glass casters this pass has recorded. */
+    get count() {
+        return this.used;
+    }
+    /** How many entries the pool holds, recorded or not: what a steady scene stops growing. */
+    get pooled() {
+        return this.pool.length;
+    }
+    recordMesh(mesh, model, material, glass) {
+        const entry = this.take(MESH, material, glass);
+        entry.mesh = mesh;
+        entry.model.set(model);
+    }
+    recordInstanced(batch, data, material, glass) {
+        const entry = this.take(INSTANCED, material, glass);
+        entry.batch = batch;
+        entry.data = data;
+    }
+    recordSkinned(mesh, model, palette, material, glass) {
+        const entry = this.take(SKINNED, material, glass);
+        entry.mesh = mesh;
+        entry.palette = palette;
+        entry.model.set(model);
+    }
+    /** Every recorded caster, in the order it was offered. */
+    replay(sink) {
+        for (let i = 0; i < this.used; i++) {
+            const entry = this.pool[i];
+            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() {
+        for (let i = 0; i < this.used; i++) {
+            const entry = this.pool[i];
+            /* 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;
+    }
+    take(kind, material, glass) {
+        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/dist/render/glassShadow.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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 { 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 declare const CLEAR_TEXEL: Readonly<GlassTexel>;
+/** How widely a fully frosted pane spreads its colour: a 30° half-angle cone behind it. */
+export declare const FROST_SPREAD: number;
+/**
+ * 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 declare const FROST_RADIUS_CAP = 64;
+/** One pane as a tint texel, lit at `cosLight` to its normal. Fresnel as `glass.ts` states it. */
+export declare function paneTexel(glass: ResolvedGlass, cosLight: number, out: GlassTexel): GlassTexel;
+/** Two stacks of glass on one ray: a product, so the order they are drawn in cannot matter. */
+export declare function combinePanes(a: GlassTexel, b: GlassTexel, out: GlassTexel): GlassTexel;
+/**
+ * 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 declare function tapTint(receiverDepth: number, glassDepth: number, bias: number, glass: GlassTexel, out: GlassTexel): GlassTexel;
+/**
+ * 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 declare function spreadTint(coverage: number, colourSum: GlassTexel, colourCount: number, out: GlassTexel): GlassTexel;
+/**
+ * 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 declare function unmixTint(mip: GlassTexel, centreClarity: number, out: GlassTexel): number;
+/** The filter radius for a receiver `paneToReceiver` behind a pane of this clarity. */
+export declare function frostRadius(clarity: number, paneToReceiver: number, baseRadius: number): number;

package/dist/render/glassShadow.js

@@ -0,0 +1,125 @@
+/**
+ * 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 } from './glass.js';
+/** No glass: everything passes, perfectly clear. What a tint map is cleared to. */
+export const CLEAR_TEXEL = { 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, cosLight, out) {
+    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, b, out) {
+    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, glassDepth, bias, glass, out) {
+    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, colourSum, colourCount, out) {
+    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, centreClarity, out) {
+    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, paneToReceiver, baseRadius) {
+    const spread = (1 - clarity) * FROST_SPREAD * Math.max(paneToReceiver, 0);
+    return Math.min(Math.max(baseRadius, spread), baseRadius * FROST_RADIUS_CAP);
+}

package/dist/render/globalMediumPass.d.ts

@@ -11,9 +11,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;
 }
 /**

package/dist/render/globalMediumPass.js

@@ -158,14 +158,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);
         gl.uniform3f(u['uSunDir'] ?? null, light.sunDir[0] ?? 0, light.sunDir[1] ?? 1, light.sunDir[2] ?? 0);

package/dist/render/gpudriven/lit.d.ts

@@ -1,4 +1,5 @@
 /** What the second pipeline's shading pass computes, in TypeScript, so something can disagree. */
+import { type ResolvedGlass } from '../glass.ts';
 /**
  * **The lit expression had no reference until 2026-09-16, and that was a gap rather than a policy.**
  *
@@ -163,3 +164,14 @@ export declare function newLitColour(): Float32Array;
  * so the two orders had never been asked to differ.
  */
 export declare function litColour(surface: LitSurface, environment: LitEnvironment, out: Float32Array): Float32Array;
+/**
+ * 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 declare 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];

package/dist/render/gpudriven/lit.js

@@ -1,6 +1,7 @@
 /** What the second pipeline's shading pass computes, in TypeScript, so something can disagree. */
 import { EMISSIVE_SHADOW_SHARE, MIN_LOBE_ALPHA } from '../shaders/flat/lobes.js';
 import { environmentWeight } from './ibl.js';
+import { schlickFresnel } from '../glass.js';
 /**
  * How much of the sky a normal sees, against how much of the ground.
  *
@@ -163,3 +164,25 @@ export function litColour(surface, environment, out) {
     }
     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, seen, glass, cosView, sunGlow, out) {
+    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];
+        const mine = own[c];
+        out[c] =
+            mine + (seen[c] * tint - mine) * shown + sunGlow[c] * tint * glowing;
+    }
+    return out;
+}

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

@@ -1,4 +1,4 @@
-/** 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 type { GpuDrivenProgram } from './decodeTables.ts';
 /**
@@ -30,17 +30,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 declare const GPU_DRIVEN_MATERIAL_FLOATS = 24;
+export declare const GPU_DRIVEN_MATERIAL_FLOATS = 28;
 /**
  * Below this base-colour alpha the raster discards a fragment. Zero means no test.
  *
@@ -66,6 +67,15 @@ export declare const MATERIAL_BLEND = 19;
  * all. A material that does not blend never reads this.
  */
 export declare 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 declare const MATERIAL_GLASS_TRANSMISSION = 21;
+export declare const MATERIAL_GLASS_FROST = 22;
+/** The colour light takes through the glass: three lanes, white where the material is not glass. */
+export declare 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.

package/dist/render/gpudriven/materialTable.js

@@ -1,18 +1,20 @@
-/** 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 { resolveGlass } from '../glass.js';
 import { DECODE_NO_PROGRAM } from '../shaders/gpudriven/decode.wgsl.js';
 /**
  * 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.
  *
@@ -38,6 +40,15 @@ export const MATERIAL_BLEND = 19;
  * all. A material that does not blend never reads this.
  */
 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.
@@ -106,10 +117,19 @@ export function writeMaterialTable(materials, indices, slots) {
         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 = { transmission: 0, frost: 0, tint: [1, 1, 1] };

package/dist/render/gpudriven/pipeline.d.ts

@@ -83,7 +83,7 @@ export declare const GPU_DRIVEN_RESOURCES: GpuDrivenResources;
  * What each stage is called, in the order they are recorded — one render or compute pass each, or
  * one copy between them.
  */
-export declare const GPU_DRIVEN_PASSES: readonly ['clearColour', 'shadow', 'instanceCull', 'cut', 'phaseOneDraw', 'pyramid', 'phaseTwoCull', 'phaseTwoDraw', 'blendCull', 'blendDraw', 'visibilityCopy', 'bin', 'cursorCopy', 'shade', 'blendResolve'];
+export declare const GPU_DRIVEN_PASSES: readonly ['clearColour', 'shadow', 'instanceCull', 'cut', 'phaseOneDraw', 'pyramid', 'phaseTwoCull', 'phaseTwoDraw', 'blendCull', 'visibilityCopy', 'bin', 'cursorCopy', 'shade', 'blendDraw', 'blendResolve'];
 export type GpuDrivenPassName = (typeof GPU_DRIVEN_PASSES)[number];
 /**
  * **Every stage is ordered, so none merges with a neighbour.** Two adjacent compute stages could

package/dist/render/gpudriven/pipeline.js

@@ -82,11 +82,11 @@ export const GPU_DRIVEN_PASSES = [
     'phaseTwoCull',
     'phaseTwoDraw',
     'blendCull',
-    'blendDraw',
     'visibilityCopy',
     'bin',
     'cursorCopy',
     'shade',
+    'blendDraw',
     'blendResolve',
 ];
 /**
@@ -148,10 +148,11 @@ function edgesFor(res) {
         /*
          * **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/dist/render/gpudriven/sunGlass.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { type GlassTexel } from '../glassShadow.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;
+}
+/** What the sun keeps through glass at a receiver at map position (u, v) and light depth `depth`. */
+export declare function glassTintAt(u: number, v: number, depth: number, maps: SunGlassMaps, settings: SunGlassSettings, out: GlassTexel): GlassTexel;