@driftengine/core 4.4.1 → 4.5.0

package/dist/render/backend/webgpu/scatterPass.js

@@ -255,7 +255,8 @@ export function createScatterDepthBindGroupLayout(device, fragBinding, fragSize,
             {
                 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/dist/render/backend/webgpu/skinPaletteRing.d.ts

@@ -13,6 +13,10 @@
  * **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 declare const MAX_SKIN_PALETTES = 128;
 /**

package/dist/render/backend/webgpu/skinPaletteRing.js

@@ -14,6 +14,10 @@ import { SkinPaletteTexture } from './skinPaletteTexture.js';
  * **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/dist/render/backend/webgpu/snapshotMips.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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';
+export declare class SnapshotMips {
+    private readonly label;
+    private readonly pipeline;
+    private readonly targets;
+    private readonly groups;
+    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, label?: string);
+    /** Fill every level from level 0, in `encoder`, after whatever wrote level 0 there. */
+    record(encoder: GPUCommandEncoder): void;
+}

package/dist/render/backend/webgpu/snapshotMips.js

@@ -0,0 +1,52 @@
+import { mipBlitPipeline } from './surfaceTexturePass.js';
+export class SnapshotMips {
+    label;
+    pipeline;
+    targets = [];
+    groups = [];
+    constructor(device, pipelines, texture, format, 
+    /** One layer of an array texture, where the chain is a layer's rather than the texture's. */
+    layer = null, label = 'refract.mips') {
+        this.label = label;
+        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', 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) {
+        for (let i = 0; i < this.targets.length; i++) {
+            const pass = encoder.beginRenderPass({
+                label: this.label,
+                colorAttachments: [
+                    {
+                        view: this.targets[i],
+                        loadOp: 'clear',
+                        storeOp: 'store',
+                        clearValue: [0, 0, 0, 0],
+                    },
+                ],
+            });
+            pass.setPipeline(this.pipeline);
+            pass.setBindGroup(0, this.groups[i]);
+            pass.draw(3);
+            pass.end();
+        }
+    }
+}

package/dist/render/backend/webgpu/surfaceTexturePass.d.ts

@@ -30,6 +30,11 @@ export interface MipPipelines {
  * thing, and the second copy is the one that would quietly disagree about the format.
  */
 export declare function generateMipChain(device: GPUDevice, pipelines: MipPipelines, texture: GPUTexture, format: GPUTextureFormat, levels: number): void;
+/**
+ * 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.
+ */
+export declare function mipBlitPipeline(device: GPUDevice, pipelines: MipPipelines, format: GPUTextureFormat): GPURenderPipeline;
 /** An image uploaded once and bound per material. */
 export declare class GpuSurfaceTexture {
     private readonly device;

package/dist/render/backend/webgpu/surfaceTexturePass.js

@@ -101,7 +101,7 @@ export function generateMipChain(device, pipelines, texture, format, levels) {
  * 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(device, pipelines, format) {
+export function mipBlitPipeline(device, pipelines, format) {
     return pipelines.get(`surface.mip:${format}`, () => ({
         label: `surface.mip:${format}`,
         layout: 'auto',

package/dist/render/flameLight.js

@@ -11,6 +11,7 @@ export function flameFrequencyHz(diameterM) {
 export function createFlame(options) {
     const height = HEIGHT_PER_DIAMETER * options.diameterM;
     const centre = [options.x, options.y + height / 3, options.z];
+    const swayM = (options.sway ?? SWAY_PER_HEIGHT) * height;
     /* A seed spread over the whole turn, so seeds 1 and 2 are not neighbours in phase. */
     const phase = ((options.seed ?? 0) * 2.399963) % (Math.PI * 2);
     const light = {
@@ -23,7 +24,19 @@ export function createFlame(options) {
         radius: options.radius,
         /* Off, because this helper is the flicker; the selection's own would apply a second one. */
         flicker: 0,
-        shadowNear: Math.max(0.05, options.diameterM),
+        /*
+         * **Clear of what the fire burns from wherever the light has wandered**, which is the sway added
+         * to the near plane a still flame would want. The shadow map is baked from where the light
+         * stood, so the cut moves with it, and each axis moves by at most `swayM`: a near plane of D
+         * alone left a brazier's bowl 7 mm inside it at the top of the sway and 13 cm outside at the
+         * bottom, and the bowl's shadow on the floor under the brazier came and went with every
+         * re-bake — a dark disc on some, none on others.
+         *
+         * What it gives up is `swayM` of shadow nearest the light, which is inside the fixture. What
+         * would make it wrong is a fixture reaching further below the flame than D / 6: this clears
+         * that far and no further, so a deep bowl sets its own `shadowNear` from its own depth.
+         */
+        shadowNear: Math.max(0.05, options.diameterM) + swayM,
         sourceRadius: options.diameterM / 2,
         ...(options.castsShadow === false ? { castsShadow: false } : {}),
     };
@@ -41,7 +54,7 @@ export function createFlame(options) {
         color: [options.color[0], options.color[1], options.color[2]],
         flicker: options.flicker ?? 0.18,
         phase,
-        swayM: (options.sway ?? SWAY_PER_HEIGHT) * height,
+        swayM,
     };
 }
 /** Where the flame's light is and how bright, at `timeSeconds`. Writes `flame.light` in place. */

package/dist/render/glass.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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];
+}
+/**
+ * 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 declare function resolveGlass(options: GlassOptions | undefined, out: ResolvedGlass): boolean;
+/**
+ * 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 declare function schlickFresnel(cosView: number): number;
+/** How much of what is behind a pane is seen through it at a view angle. */
+export declare function glassSeenShare(transmission: number, cosView: number): number;

package/dist/render/glass.js

@@ -0,0 +1,39 @@
+const clamp01 = (value) => 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, out) {
+    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) {
+    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, cosView) {
+    return transmission * (1 - schlickFresnel(cosView));
+}

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