@driftengine/core 4.4.2 → 4.5.0

package/src/render/backend/webgpu/scatterPass.ts

@@ -334,7 +334,8 @@ export function createScatterDepthBindGroupLayout(
       {
         binding: previous.texture,
         visibility: VISIBILITY_FRAGMENT,
-        texture: { sampleType: 'unfilterable-float' },
+        /* The depth program's peel read, an array since the sun's maps became one. */
+        texture: { sampleType: 'unfilterable-float', viewDimension: '2d-array' },
       },
       {
         binding: previous.sampler,

package/src/render/backend/webgpu/skinPaletteRing.ts

@@ -15,6 +15,10 @@ import { SkinPaletteTexture } from './skinPaletteTexture.ts';
  * **What would make it wrong** is a genuine crowd — a stadium, a swarm of rigged birds — and the
  * fix is then the one `skinPalette.ts` names: one texture holding every palette with a per-draw
  * row offset, which spends a uniform and a shader change to stop spending textures.
+ *
+ * **A reconstructing frame spends one more per skinned mover**: last frame's pose is uploaded into
+ * a slot of its own for the motion pass. So the same budget is about twelve such characters with a
+ * reflection and three shadow layers each.
  */
 export const MAX_SKIN_PALETTES = 128;
 

package/src/render/backend/webgpu/snapshotMips.ts

@@ -0,0 +1,80 @@
+/**
+ * The mip chain of the frame's refraction copy, recorded into the frame's own encoder.
+ *
+ * **Frosted glass reads a blurrier level of what is behind it** (`glass.ts`), so on a frame that draws
+ * glass the copy needs every level filled from the one above. `generateMipChain` does that for an
+ * upload, on an encoder of its own that it submits at once — which here would run before the frame's
+ * encoder had even made the copy, and would build views and bind groups on every call. So this
+ * makes them once per copy texture and records one pass per level wherever the copy was taken.
+ *
+ * What it costs is a render pass per level on every frame that takes the copy — about a dozen for a
+ * 1080p copy, each a quarter of the one before, together about a third of the copy itself — and
+ * nothing on a frame that shows nothing through anything. **A frame that refracts and draws no glass
+ * pays it too**, and that is the trade: the copy is taken at the first draw that asks and shared by
+ * every later one, so a glass pane drawn after a refracting one would otherwise read levels nothing
+ * filled. WebGL2 fills its chain on the first glass draw instead, because a `generateMipmap` there
+ * ends no pass. What would change it is knowing at the copy whether glass follows in the frame.
+ */
+import type { MipPipelines } from './surfaceTexturePass.ts';
+import { mipBlitPipeline } from './surfaceTexturePass.ts';
+
+export class SnapshotMips {
+  private readonly pipeline: GPURenderPipeline;
+  private readonly targets: GPUTextureView[] = [];
+  private readonly groups: GPUBindGroup[] = [];
+
+  constructor(
+    device: GPUDevice,
+    pipelines: MipPipelines,
+    texture: GPUTexture,
+    format: GPUTextureFormat,
+    /** One layer of an array texture, where the chain is a layer's rather than the texture's. */
+    layer: number | null = null,
+    private readonly label = 'refract.mips',
+  ) {
+    this.pipeline = mipBlitPipeline(device, pipelines, format);
+    const sampler = device.createSampler({
+      label: 'refract.mips.sampler',
+      magFilter: 'linear',
+      minFilter: 'linear',
+    });
+    const layout = this.pipeline.getBindGroupLayout(0);
+    const at =
+      layer === null ? {} : { dimension: '2d' as const, baseArrayLayer: layer, arrayLayerCount: 1 };
+    for (let level = 1; level < texture.mipLevelCount; level++) {
+      const source = texture.createView({ ...at, baseMipLevel: level - 1, mipLevelCount: 1 });
+      this.targets.push(texture.createView({ ...at, baseMipLevel: level, mipLevelCount: 1 }));
+      this.groups.push(
+        device.createBindGroup({
+          label: `refract.mips.${String(level)}`,
+          layout,
+          entries: [
+            { binding: 0, resource: source },
+            { binding: 1, resource: sampler },
+          ],
+        }),
+      );
+    }
+  }
+
+  /** Fill every level from level 0, in `encoder`, after whatever wrote level 0 there. */
+  record(encoder: GPUCommandEncoder): void {
+    for (let i = 0; i < this.targets.length; i++) {
+      const pass = encoder.beginRenderPass({
+        label: this.label,
+        colorAttachments: [
+          {
+            view: this.targets[i] as GPUTextureView,
+            loadOp: 'clear',
+            storeOp: 'store',
+            clearValue: [0, 0, 0, 0],
+          },
+        ],
+      });
+      pass.setPipeline(this.pipeline);
+      pass.setBindGroup(0, this.groups[i] as GPUBindGroup);
+      pass.draw(3);
+      pass.end();
+    }
+  }
+}

package/src/render/backend/webgpu/surfaceTexturePass.ts

@@ -128,7 +128,7 @@ export function generateMipChain(
  * Cached per format, because the two differ: an `-srgb` target encodes on write, and blitting a
  * linear chain through a pipeline declared for the other one is a gamma error per level.
  */
-function mipBlitPipeline(
+export function mipBlitPipeline(
   device: GPUDevice,
   pipelines: MipPipelines,
   format: GPUTextureFormat,

package/src/render/glass.ts

@@ -0,0 +1,74 @@
+/**
+ * Glass: how much light a surface lets through, how milky it is, and the colour it takes.
+ *
+ * **A thin pane, not a volume.** Glass here is a surface that shows the scene behind it — by
+ * `transmission`, blurred by `frost`, tinted — keeps its own highlight and reflection, and glows
+ * with the lights behind it in proportion to how frosted it is. The one depth it has is the path
+ * absorption refraction already applies (`TranslucentMeshOptions.thicknessM`). What it gives up is
+ * everything a solid of glass does inside itself: a sculpture or a thick block under-darkens and
+ * does not bend light twice. What would make it wrong is a scene whose glass is mostly that.
+ *
+ * **Zero transmission is not glass**, whatever the frost says: a surface letting nothing through is
+ * opaque, and every branch the shader gates on transmission is skipped for it. This module is also
+ * the reference the shader's Fresnel is held to (`schlickFresnel`), stated once in TypeScript.
+ */
+import type { Vec3 } from '../math/color.ts';
+
+export interface GlassOptions {
+  /** Share of light that passes, 0 (opaque) to 1 (clear). */
+  readonly transmission: number;
+  /** How milky, 0 (see-through) to 1 (fully diffusing: what is behind is blurred away). */
+  readonly frost: number;
+  /** The colour light takes through it. White, the default, is clear glass. */
+  readonly tint?: Vec3;
+}
+
+/** A `GlassOptions` clamped and defaulted, in a caller-owned object so a draw allocates nothing. */
+export interface ResolvedGlass {
+  transmission: number;
+  frost: number;
+  tint: [number, number, number];
+}
+
+const clamp01 = (value: number): number => Math.min(1, Math.max(0, value));
+
+/**
+ * Resolve `options` into `out`, and say whether it is glass at all.
+ *
+ * Not glass — absent, or letting nothing through — zeroes `out` and tints it white, so a binder that
+ * uploads `out` either way uploads the state that switches the shader's glass branch off.
+ */
+export function resolveGlass(options: GlassOptions | undefined, out: ResolvedGlass): boolean {
+  const transmission = clamp01(options?.transmission ?? 0);
+  if (options === undefined || transmission <= 0) {
+    out.transmission = 0;
+    out.frost = 0;
+    out.tint[0] = 1;
+    out.tint[1] = 1;
+    out.tint[2] = 1;
+    return false;
+  }
+  out.transmission = transmission;
+  out.frost = clamp01(options.frost);
+  const tint = options.tint;
+  out.tint[0] = tint === undefined ? 1 : clamp01(tint[0]);
+  out.tint[1] = tint === undefined ? 1 : clamp01(tint[1]);
+  out.tint[2] = tint === undefined ? 1 : clamp01(tint[2]);
+  return true;
+}
+
+/**
+ * Schlick's Fresnel for glass, `F0 = 0.04`: the share of light a pane reflects at a view angle.
+ *
+ * `cosView` is clamped at 0.05, the floor the shader's path length already uses, so a silhouette
+ * seen exactly edge-on is a very reflective pane rather than a division by zero.
+ */
+export function schlickFresnel(cosView: number): number {
+  const c = Math.min(1, Math.max(0.05, cosView));
+  return 0.04 + 0.96 * (1 - c) ** 5;
+}
+
+/** How much of what is behind a pane is seen through it at a view angle. */
+export function glassSeenShare(transmission: number, cosView: number): number {
+  return transmission * (1 - schlickFresnel(cosView));
+}

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]],