@driftengine/core 4.4.2 → 4.6.0

package/dist/render/pointGlassTint.js

@@ -0,0 +1,198 @@
+import { mat3 } from 'gl-matrix';
+import { createEmptyTexture2D } from './emptyTexture.js';
+import { pointShadowFaceRotation } from './pointShadowImage.js';
+import { compileProgram, uniformLocations } from './shader.js';
+import { OCTAHEDRAL_RESOLVE_TINT_FRAG, OCTAHEDRAL_RESOLVE_VERT, } from './shaders/octahedralResolve.js';
+/** Filled per resolved face, at module scope, because a bake runs inside the frame's budget. */
+const faceRotation = mat3.create();
+const CLEAR = new Float32Array([1, 1, 1, 1]);
+/**
+ * What a lamp's light keeps through glass: an RGBA8 array of one layer a light, parallel to the
+ * point shadow array and indexed by the light, not by the interleaved depth layer. RGB is the
+ * product of every pane's `transmission × (1 − F) × tint`, A the product of their clarities
+ * (`glassShadow.ts`).
+ *
+ * **Drawn a face at a time, as the depth is**: into a face-sized colour scratch cleared to white,
+ * with a multiplying blend and no depth test, then resolved into the face's region of the layer by
+ * `OCTAHEDRAL_RESOLVE_TINT_FRAG`. One scratch for the whole engine, for the reason
+ * `PointShadowArray` gives for its own.
+ *
+ * **Which faces hold glass is remembered, six bits a layer**, so a face with no glass and none to
+ * forget costs nothing, and a face that inherited a previous owner's glass is cleared. **The chain
+ * frost reads is rebuilt once a round**, for the layers the round touched, through a 2D staging
+ * chain: `generateMipmap` on an array rebuilds every layer, which is the whole pool's texels for one
+ * lamp's glass. What that costs is one layer of memory with its chain — 5.6 MB at 1024, 1.4 MB at
+ * `'half'` — and a copy out and back per touched layer.
+ */
+export class PointGlassTint {
+    texture;
+    edge;
+    layers;
+    levels;
+    faceSize;
+    scratch;
+    scratchFramebuffer;
+    staging;
+    framebuffer;
+    readFramebuffer;
+    /** Parked on the resolve's unit while the scratch is a render target; see `beginFace`. */
+    parked;
+    program;
+    uniforms;
+    vao;
+    /** Six bits a layer: which faces' regions hold glass. */
+    heldFaces;
+    /** Layers whose level 0 changed since the chain was last rebuilt. */
+    dirty;
+    constructor(gl, faceSize, edge, layers) {
+        this.edge = edge;
+        this.layers = layers;
+        this.faceSize = faceSize;
+        this.levels = Math.floor(Math.log2(Math.max(1, edge))) + 1;
+        this.heldFaces = new Uint8Array(layers);
+        this.dirty = new Uint8Array(layers);
+        this.texture = colourTexture(gl, gl.TEXTURE_2D_ARRAY, this.levels, edge, layers);
+        this.scratch = colourTexture(gl, gl.TEXTURE_2D, 1, faceSize, 1);
+        this.staging = colourTexture(gl, gl.TEXTURE_2D, this.levels, edge, 1);
+        this.parked = createEmptyTexture2D(gl);
+        this.scratchFramebuffer = framebufferOf(gl);
+        this.framebuffer = framebufferOf(gl);
+        this.readFramebuffer = framebufferOf(gl);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.scratchFramebuffer);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.scratch, 0);
+        this.program = compileProgram(gl, OCTAHEDRAL_RESOLVE_VERT, OCTAHEDRAL_RESOLVE_TINT_FRAG, 'octahedralResolveTint');
+        this.uniforms = uniformLocations(gl, this.program, 'octahedralResolveTint');
+        const vao = gl.createVertexArray();
+        if (vao === null)
+            throw new Error('PointGlassTint: createVertexArray failed');
+        this.vao = vao;
+        /* Every layer born clear: a light no pane has reached lets everything through. */
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+        for (let layer = 0; layer < layers; layer++) {
+            gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, this.texture, 0, layer);
+            gl.clearBufferfv(gl.COLOR, 0, CLEAR);
+        }
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        /* Once, for every layer: white all the way down. */
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.texture);
+        gl.generateMipmap(gl.TEXTURE_2D_ARRAY);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
+    }
+    /** Whether `face` of `layer` holds glass: a face that does must be cleared before it is reused. */
+    held(layer, face) {
+        return (((this.heldFaces[layer] ?? 0) >> face) & 1) === 1;
+    }
+    /**
+     * Bind the colour scratch, clear it to white, and set the multiplying state.
+     *
+     * The previous resolve left the scratch bound for sampling on unit 0, and it is about to be the
+     * target: parked first, for the reason `PointShadowArray.beginFace` gives.
+     */
+    beginFace(gl) {
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this.parked);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.scratchFramebuffer);
+        gl.viewport(0, 0, this.faceSize, this.faceSize);
+        gl.clearBufferfv(gl.COLOR, 0, CLEAR);
+        gl.disable(gl.DEPTH_TEST);
+        gl.depthMask(false);
+        gl.enable(gl.BLEND);
+        gl.blendEquation(gl.FUNC_ADD);
+        gl.blendFuncSeparate(gl.DST_COLOR, gl.ZERO, gl.DST_ALPHA, gl.ZERO);
+    }
+    /**
+     * Copy the scratch into `face`'s region of `layer`, and remember whether it held glass.
+     *
+     * Leaves depth testing and writing on, which is what the next face's casters expect: the depth
+     * resolve that runs before them turns both on, and this one ran after it and turned them off.
+     */
+    resolveFace(gl, layer, face, drawn) {
+        gl.disable(gl.BLEND);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
+        gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, this.texture, 0, layer);
+        gl.viewport(0, 0, this.edge, this.edge);
+        gl.useProgram(this.program);
+        gl.bindVertexArray(this.vao);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this.scratch);
+        gl.uniform1i(this.uniforms['uFace'] ?? null, 0);
+        gl.uniform1i(this.uniforms['uFaceIndex'] ?? null, face);
+        gl.uniformMatrix3fv(this.uniforms['uFaceRotation'] ?? null, false, pointShadowFaceRotation(face, faceRotation));
+        gl.uniform1f(this.uniforms['uEdge'] ?? null, this.edge);
+        gl.drawArrays(gl.TRIANGLES, 0, 3);
+        gl.bindVertexArray(null);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.enable(gl.DEPTH_TEST);
+        gl.depthMask(true);
+        const bit = 1 << face;
+        const was = this.heldFaces[layer] ?? 0;
+        this.heldFaces[layer] = drawn ? was | bit : was & ~bit;
+        this.dirty[layer] = 1;
+    }
+    /** Rebuild the chain of every layer touched since the last call, one layer at a time. */
+    fillMips(gl) {
+        for (let layer = 0; layer < this.layers; layer++) {
+            if (this.dirty[layer] !== 1)
+                continue;
+            this.dirty[layer] = 0;
+            /* Level 0 out into the staging chain, which mipmaps as one 2D texture. */
+            gl.bindFramebuffer(gl.READ_FRAMEBUFFER, this.readFramebuffer);
+            gl.framebufferTextureLayer(gl.READ_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, this.texture, 0, layer);
+            gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this.framebuffer);
+            gl.framebufferTexture2D(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.staging, 0);
+            blit(gl, this.edge, this.edge);
+            gl.bindTexture(gl.TEXTURE_2D, this.staging);
+            gl.generateMipmap(gl.TEXTURE_2D);
+            gl.bindTexture(gl.TEXTURE_2D, null);
+            /* And every level after it back into the layer. */
+            for (let level = 1; level < this.levels; level++) {
+                const size = Math.max(1, this.edge >> level);
+                gl.framebufferTexture2D(gl.READ_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, this.staging, level);
+                gl.framebufferTextureLayer(gl.DRAW_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, this.texture, level, layer);
+                blit(gl, size, size);
+            }
+            gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null);
+            gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
+        }
+    }
+    dispose(gl) {
+        gl.deleteFramebuffer(this.scratchFramebuffer);
+        gl.deleteFramebuffer(this.framebuffer);
+        gl.deleteFramebuffer(this.readFramebuffer);
+        gl.deleteTexture(this.texture);
+        gl.deleteTexture(this.scratch);
+        gl.deleteTexture(this.staging);
+        gl.deleteTexture(this.parked);
+        gl.deleteProgram(this.program);
+        gl.deleteVertexArray(this.vao);
+    }
+}
+/** A colour texture with `levels` levels: nearest for a single level, trilinear for a chain. */
+function colourTexture(gl, target, levels, edge, layers) {
+    const texture = gl.createTexture();
+    if (texture === null)
+        throw new Error('PointGlassTint: createTexture failed');
+    gl.bindTexture(target, texture);
+    if (target === gl.TEXTURE_2D_ARRAY) {
+        gl.texStorage3D(target, levels, gl.RGBA8, edge, edge, layers);
+    }
+    else {
+        gl.texStorage2D(target, levels, gl.RGBA8, edge, edge);
+    }
+    gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, levels > 1 ? gl.LINEAR_MIPMAP_LINEAR : gl.NEAREST);
+    gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, levels > 1 ? gl.LINEAR : gl.NEAREST);
+    gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.bindTexture(target, null);
+    return texture;
+}
+function framebufferOf(gl) {
+    const framebuffer = gl.createFramebuffer();
+    if (framebuffer === null)
+        throw new Error('PointGlassTint: createFramebuffer failed');
+    return framebuffer;
+}
+/** The bound read framebuffer's colour into the bound draw framebuffer's, texel for texel. */
+function blit(gl, width, height) {
+    gl.blitFramebuffer(0, 0, width, height, 0, 0, width, height, gl.COLOR_BUFFER_BIT, gl.NEAREST);
+}

package/dist/render/pointLightSelection.d.ts

@@ -1,4 +1,5 @@
 /** Allocation-free selection and packing of point lights for a fixed shader budget. */
+import type { LightGrid } from './lightGrid.ts';
 export declare const DEFAULT_POINT_LIGHT_VIEW_RANGE = 180;
 export interface PointLightSource {
     x: number;
@@ -189,3 +190,9 @@ export declare function createPointLightBuffer(capacity?: number): PointLightBuf
  * makes the distance the *same arithmetic on the same operands*, not merely a close number.
  */
 export declare function selectPointLights(sources: readonly PointLightSource[], x: number, y: number, z: number, out: PointLightBuffer, timeSeconds?: number, viewRange?: number, castX?: number, castY?: number, castZ?: number): void;
+/**
+ * `selectPointLights` over a grid's sources, looking only at the lights near the eye: the same
+ * choice, tie for tie, for a world of thousands of fixed lights that the plain scan would visit
+ * every frame. See `lightGrid.ts` for why the result is the scan's exactly.
+ */
+export declare function selectGridLights(grid: LightGrid, x: number, y: number, z: number, out: PointLightBuffer, timeSeconds?: number, viewRange?: number, castX?: number, castY?: number, castZ?: number): void;

package/dist/render/pointLightSelection.js

@@ -1,6 +1,7 @@
 /** Allocation-free selection and packing of point lights for a fixed shader budget. */
 import { POINT_LIGHT_COS_INNER, POINT_LIGHT_COS_OUTER } from './clusteredLights.js';
 import { MAX_POINT_LIGHTS, POINT_SHADOW_POOL } from './lightBudget.js';
+import { gatherLights } from './lightGrid.js';
 export const DEFAULT_POINT_LIGHT_VIEW_RANGE = 180;
 /**
  * How far out a light fades to nothing, in metres before its cull distance.
@@ -38,8 +39,15 @@ const FADE_BAND_M = 40;
  * while it is still too dim to show one.
  */
 const CONTENTION_BAND_M = 3;
-/** Sort keys for the shadow list, which is ordered independently of the shaded one. */
-const shadowRank = new Float32Array(POINT_SHADOW_POOL);
+/**
+ * Sort keys for the shadow list, which is ordered independently of the shaded one.
+ *
+ * **Float64, and ties broken by source index**, the shaded list's rule. These were single precision
+ * compared against a double, so which of two lamps exactly as far away came first depended on
+ * which way the distance happened to round — and on the order the lamps were met, which is what a
+ * grid changes. Now the list is the same whatever order its candidates arrive in.
+ */
+const shadowRank = new Float64Array(POINT_SHADOW_POOL);
 /**
  * Every light in range this frame, by source index and squared distance, before the nearest are
  * chosen. Grown when a world offers more than it has held, and never shrunk, so a frame allocates
@@ -177,6 +185,19 @@ export function createPointLightBuffer(capacity = MAX_POINT_LIGHTS) {
  * makes the distance the *same arithmetic on the same operands*, not merely a close number.
  */
 export function selectPointLights(sources, x, y, z, out, timeSeconds = 0, viewRange = DEFAULT_POINT_LIGHT_VIEW_RANGE, castX = x, castY = y, castZ = z) {
+    choose(sources, null, sources.length, x, y, z, out, timeSeconds, viewRange, castX, castY, castZ);
+}
+/**
+ * `selectPointLights` over a grid's sources, looking only at the lights near the eye: the same
+ * choice, tie for tie, for a world of thousands of fixed lights that the plain scan would visit
+ * every frame. See `lightGrid.ts` for why the result is the scan's exactly.
+ */
+export function selectGridLights(grid, x, y, z, out, timeSeconds = 0, viewRange = DEFAULT_POINT_LIGHT_VIEW_RANGE, castX = x, castY = y, castZ = z) {
+    const count = gatherLights(grid, x, y, z, viewRange + grid.maxRadius);
+    choose(grid.sources, grid.gathered, count, x, y, z, out, timeSeconds, viewRange, castX, castY, castZ);
+}
+/** The choice itself, over every source or over the ones `visit` names, in source order. */
+function choose(sources, visit, visitCount, x, y, z, out, timeSeconds, viewRange, castX, castY, castZ) {
     out.count = 0;
     out.shadowCount = 0;
     /*
@@ -193,7 +214,8 @@ export function selectPointLights(sources, x, y, z, out, timeSeconds = 0, viewRa
      */
     let cutSq = Infinity;
     let candidateCount = 0;
-    for (let sourceIndex = 0; sourceIndex < sources.length; sourceIndex++) {
+    for (let visited = 0; visited < visitCount; visited++) {
+        const sourceIndex = visit === null ? visited : visit[visited];
         const light = sources[sourceIndex];
         if (light === undefined)
             continue;
@@ -265,7 +287,10 @@ export function selectPointLights(sources, x, y, z, out, timeSeconds = 0, viewRa
         if (castDistanceSq >= light.radius * light.radius)
             continue;
         let shadowSlot = out.shadowCount;
-        while (shadowSlot > 0 && (shadowRank[shadowSlot - 1] ?? 0) > castDistanceSq)
+        while (shadowSlot > 0 &&
+            ((shadowRank[shadowSlot - 1] ?? 0) > castDistanceSq ||
+                ((shadowRank[shadowSlot - 1] ?? 0) === castDistanceSq &&
+                    (out.shadowIndex[shadowSlot - 1] ?? -1) > sourceIndex)))
             shadowSlot--;
         if (shadowSlot >= POINT_SHADOW_POOL)
             continue;

package/dist/render/pointShadowArray.d.ts

@@ -16,7 +16,25 @@ export declare const OCTAHEDRAL_EDGE = 1024;
 export interface PointShadowTarget {
     beginFace(gl: WebGL2RenderingContext): void;
     resolveFace(gl: WebGL2RenderingContext, layer: number, face: number, far: number, near: number): void;
+    /** Whether the array has grown its glass layers: `growForGlass`. */
+    readonly hasGlass: boolean;
+    /** Whether `face` of `layer` holds glass, which a face that offers none must clear. */
+    heldGlass(layer: number, face: number): boolean;
+    /** The depth scratch again, cleared, for the face's glass. */
+    beginGlassFace(gl: WebGL2RenderingContext): void;
+    resolveGlassFace(gl: WebGL2RenderingContext, layer: number, face: number, far: number, near: number): void;
+    /** The colour scratch, cleared to white, for what the face's glass lets through. */
+    beginTintFace(gl: WebGL2RenderingContext): void;
+    resolveTintFace(gl: WebGL2RenderingContext, layer: number, face: number, drawn: boolean): void;
 }
+/**
+ * Every published layer as the array stores it: `layer × stride`, and −1 left as −1.
+ *
+ * **Applied to the resolved arrays right after each resolve**, so every consumer of an uploaded
+ * index reads the physical layer: once glass arrives, light L's depth is at 2L and its glass at
+ * 2L + 1 (`PointShadowArray.growForGlass`). In place, because the resolve rewrites these every time.
+ */
+export declare function strideLayers(layers: Int32Array, stride: number): void;
 /**
  * Every point light's shadow as one array texture, and the scratch that fills it.
  *
@@ -34,12 +52,16 @@ export interface PointShadowTarget {
  * never the same object.
  */
 export declare class PointShadowArray implements PointShadowTarget {
-    readonly texture: WebGLTexture;
     /**
-     * How many layers this array holds: the point pool, the two live transition maps, and two more
-     * for each rectangle a world said would cast. See the constructor's `extraLayers`.
+     * How many lights this array holds: the point pool, the two live transition maps, and two more
+     * for each rectangle a world said would cast. See the constructor's `extraLayers`. Counted in
+     * lights, so it does not move when glass doubles the storage under it.
      */
     readonly layers: number;
+    /** Replaced once, when glass first casts: see `growForGlass`. */
+    private current;
+    /** What the lights' glass lets through, made with the glass layers. */
+    private tint;
     private readonly framebuffer;
     private readonly scratchTexture;
     private readonly scratchFramebuffer;
@@ -62,6 +84,35 @@ export declare class PointShadowArray implements PointShadowTarget {
      * map.
      */
     extraLayers?: number);
+    /** The array texture the lit pass samples. Replaced once, when glass first casts. */
+    get texture(): WebGLTexture;
+    get hasGlass(): boolean;
+    /** Physical layers a light: 1, or 2 once glass has interleaved the array. */
+    get stride(): number;
+    /** The glass tint, one layer a light, once glass has cast; the lit pass samples it. */
+    get tintTexture(): WebGLTexture | null;
+    /**
+     * Interleave the array for glass: light L's depth moves to 2L and its glass takes 2L + 1, and
+     * the tint is made. Returns whether it grew — once, on the first face whose casters held glass.
+     *
+     * **Interleaved rather than stacked above the opaque half** because a shader cannot ask an array
+     * its layer count under naga, so it cannot find `L + N`; `layer + 1` it can. **Every map already
+     * baked is carried across** by a depth blit, so nothing goes dark, and **no map needs baking
+     * again**: this runs on the first face that saw glass, so no map baked before it saw any, and a
+     * glass layer born at the far plane with a white tint is exactly what its bake would draw. What
+     * it costs is the doubled depth (4.19 MB a light at 1024) and the tint (5.6 MB a light with its
+     * chain, 1.4 MB at `'half'`), from then on.
+     */
+    growForGlass(gl: WebGL2RenderingContext, tintEdge: number): boolean;
+    heldGlass(layer: number, face: number): boolean;
+    /** The depth scratch, cleared, for the face's glass: `beginFace` exactly. */
+    beginGlassFace(gl: WebGL2RenderingContext): void;
+    /** The face's glass depth into light `layer`'s glass layer, 2L + 1. */
+    resolveGlassFace(gl: WebGL2RenderingContext, layer: number, face: number, far: number, near: number): void;
+    beginTintFace(gl: WebGL2RenderingContext): void;
+    resolveTintFace(gl: WebGL2RenderingContext, layer: number, face: number, drawn: boolean): void;
+    /** The chain frost reads, for every light whose tint a round touched: once a round. */
+    finishTints(gl: WebGL2RenderingContext): void;
     /**
      * Bind the scratch as the render target for one face of one bake, and clear it.
      *
@@ -91,5 +142,7 @@ export declare class PointShadowArray implements PointShadowTarget {
      * from an empty vertex array.
      */
     resolveFace(gl: WebGL2RenderingContext, layer: number, face: number, far: number, near: number): void;
+    /** The scratch into physical layer `physical`'s region for `face`. */
+    private resolveInto;
     dispose(gl: WebGL2RenderingContext): void;
 }

package/dist/render/pointShadowArray.js

@@ -1,6 +1,7 @@
 import { mat3 } from 'gl-matrix';
 import { createEmptyTexture2D } from './emptyTexture.js';
 import { LIVE_POINT_SHADOW_MAPS, POINT_SHADOW_POOL } from './lightBudget.js';
+import { PointGlassTint } from './pointGlassTint.js';
 import { pointShadowFaceRotation } from './pointShadowImage.js';
 import { compileProgram, uniformLocations } from './shader.js';
 import { OCTAHEDRAL_RESOLVE_FRAG, OCTAHEDRAL_RESOLVE_VERT } from './shaders/octahedralResolve.js';
@@ -15,6 +16,22 @@ import { OCTAHEDRAL_RESOLVE_FRAG, OCTAHEDRAL_RESOLVE_VERT } from './shaders/octa
 export const OCTAHEDRAL_EDGE = 1024;
 /** Filled per resolved face, at module scope, because a bake runs inside the frame's budget. */
 const faceRotation = mat3.create();
+/**
+ * Every published layer as the array stores it: `layer × stride`, and −1 left as −1.
+ *
+ * **Applied to the resolved arrays right after each resolve**, so every consumer of an uploaded
+ * index reads the physical layer: once glass arrives, light L's depth is at 2L and its glass at
+ * 2L + 1 (`PointShadowArray.growForGlass`). In place, because the resolve rewrites these every time.
+ */
+export function strideLayers(layers, stride) {
+    if (stride === 1)
+        return;
+    for (let i = 0; i < layers.length; i++) {
+        const layer = layers[i];
+        if (layer >= 0)
+            layers[i] = layer * stride;
+    }
+}
 /**
  * Every point light's shadow as one array texture, and the scratch that fills it.
  *
@@ -32,12 +49,16 @@ const faceRotation = mat3.create();
  * never the same object.
  */
 export class PointShadowArray {
-    texture;
     /**
-     * How many layers this array holds: the point pool, the two live transition maps, and two more
-     * for each rectangle a world said would cast. See the constructor's `extraLayers`.
+     * How many lights this array holds: the point pool, the two live transition maps, and two more
+     * for each rectangle a world said would cast. See the constructor's `extraLayers`. Counted in
+     * lights, so it does not move when glass doubles the storage under it.
      */
     layers;
+    /** Replaced once, when glass first casts: see `growForGlass`. */
+    current;
+    /** What the lights' glass lets through, made with the glass layers. */
+    tint = null;
     framebuffer;
     scratchTexture;
     scratchFramebuffer;
@@ -68,17 +89,8 @@ export class PointShadowArray {
          */
         this.layers =
             Math.min(lightCount, POINT_SHADOW_POOL) + LIVE_POINT_SHADOW_MAPS + Math.max(0, extraLayers);
-        const texture = gl.createTexture();
-        if (texture === null)
-            throw new Error('PointShadowArray: createTexture failed');
-        this.texture = texture;
-        gl.bindTexture(gl.TEXTURE_2D_ARRAY, texture);
-        gl.texStorage3D(gl.TEXTURE_2D_ARRAY, 1, gl.DEPTH_COMPONENT24, OCTAHEDRAL_EDGE, OCTAHEDRAL_EDGE, this.layers);
-        /* One storage level and no filtering, so textureLod(..., 0.0) is the only fetch there is. */
-        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-        gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        const texture = depthArray(gl, this.layers);
+        this.current = texture;
         const scratchTexture = gl.createTexture();
         if (scratchTexture === null)
             throw new Error('PointShadowArray: createTexture failed');
@@ -141,6 +153,86 @@ export class PointShadowArray {
         gl.bindTexture(gl.TEXTURE_2D, null);
         gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
     }
+    /** The array texture the lit pass samples. Replaced once, when glass first casts. */
+    get texture() {
+        return this.current;
+    }
+    get hasGlass() {
+        return this.tint !== null;
+    }
+    /** Physical layers a light: 1, or 2 once glass has interleaved the array. */
+    get stride() {
+        return this.tint === null ? 1 : 2;
+    }
+    /** The glass tint, one layer a light, once glass has cast; the lit pass samples it. */
+    get tintTexture() {
+        return this.tint?.texture ?? null;
+    }
+    /**
+     * Interleave the array for glass: light L's depth moves to 2L and its glass takes 2L + 1, and
+     * the tint is made. Returns whether it grew — once, on the first face whose casters held glass.
+     *
+     * **Interleaved rather than stacked above the opaque half** because a shader cannot ask an array
+     * its layer count under naga, so it cannot find `L + N`; `layer + 1` it can. **Every map already
+     * baked is carried across** by a depth blit, so nothing goes dark, and **no map needs baking
+     * again**: this runs on the first face that saw glass, so no map baked before it saw any, and a
+     * glass layer born at the far plane with a white tint is exactly what its bake would draw. What
+     * it costs is the doubled depth (4.19 MB a light at 1024) and the tint (5.6 MB a light with its
+     * chain, 1.4 MB at `'half'`), from then on.
+     */
+    growForGlass(gl, tintEdge) {
+        if (this.tint !== null)
+            return false;
+        const old = this.current;
+        const texture = depthArray(gl, this.layers * 2);
+        /* Off the unit it was made on, as the constructor leaves its own: see `beginFace`. */
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
+        const read = gl.createFramebuffer();
+        if (read === null)
+            throw new Error('PointShadowArray: createFramebuffer failed');
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, read);
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, this.framebuffer);
+        for (let layer = 0; layer < this.layers; layer++) {
+            gl.framebufferTextureLayer(gl.READ_FRAMEBUFFER, gl.DEPTH_ATTACHMENT, old, 0, layer);
+            gl.framebufferTextureLayer(gl.DRAW_FRAMEBUFFER, gl.DEPTH_ATTACHMENT, texture, 0, 2 * layer);
+            gl.blitFramebuffer(0, 0, OCTAHEDRAL_EDGE, OCTAHEDRAL_EDGE, 0, 0, OCTAHEDRAL_EDGE, OCTAHEDRAL_EDGE, gl.DEPTH_BUFFER_BIT, gl.NEAREST);
+        }
+        /* Nothing is nearer a lamp than a pane that has not been drawn. */
+        for (let layer = 0; layer < this.layers; layer++) {
+            gl.framebufferTextureLayer(gl.DRAW_FRAMEBUFFER, gl.DEPTH_ATTACHMENT, texture, 0, 2 * layer + 1);
+            gl.clearBufferfv(gl.DEPTH, 0, FAR_PLANE);
+        }
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, null);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+        gl.deleteFramebuffer(read);
+        gl.deleteTexture(old);
+        this.current = texture;
+        this.tint = new PointGlassTint(gl, this.faceSize, tintEdge, this.layers);
+        return true;
+    }
+    heldGlass(layer, face) {
+        return this.tint?.held(layer, face) ?? false;
+    }
+    /** The depth scratch, cleared, for the face's glass: `beginFace` exactly. */
+    beginGlassFace(gl) {
+        this.beginFace(gl);
+    }
+    /** The face's glass depth into light `layer`'s glass layer, 2L + 1. */
+    resolveGlassFace(gl, layer, face, far, near) {
+        if (this.tint === null)
+            return;
+        this.resolveInto(gl, 2 * layer + 1, face, far, near);
+    }
+    beginTintFace(gl) {
+        this.tint?.beginFace(gl);
+    }
+    resolveTintFace(gl, layer, face, drawn) {
+        this.tint?.resolveFace(gl, layer, face, drawn);
+    }
+    /** The chain frost reads, for every light whose tint a round touched: once a round. */
+    finishTints(gl) {
+        this.tint?.fillMips(gl);
+    }
     /**
      * Bind the scratch as the render target for one face of one bake, and clear it.
      *
@@ -176,8 +268,12 @@ export class PointShadowArray {
      * from an empty vertex array.
      */
     resolveFace(gl, layer, face, far, near) {
+        this.resolveInto(gl, layer * this.stride, face, far, near);
+    }
+    /** The scratch into physical layer `physical`'s region for `face`. */
+    resolveInto(gl, physical, face, far, near) {
         gl.bindFramebuffer(gl.FRAMEBUFFER, this.framebuffer);
-        gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, this.texture, 0, layer);
+        gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, this.current, 0, physical);
         gl.viewport(0, 0, OCTAHEDRAL_EDGE, OCTAHEDRAL_EDGE);
         gl.useProgram(this.program);
         gl.bindVertexArray(this.vao);
@@ -210,10 +306,25 @@ export class PointShadowArray {
     dispose(gl) {
         gl.deleteFramebuffer(this.framebuffer);
         gl.deleteFramebuffer(this.scratchFramebuffer);
-        gl.deleteTexture(this.texture);
+        gl.deleteTexture(this.current);
         gl.deleteTexture(this.scratchTexture);
+        this.tint?.dispose(gl);
         gl.deleteTexture(this.parked);
         gl.deleteProgram(this.program);
         gl.deleteVertexArray(this.vao);
     }
 }
+const FAR_PLANE = new Float32Array([1]);
+/** The depth array: one storage level and no filtering, so textureLod(..., 0.0) is the only fetch. */
+function depthArray(gl, layers) {
+    const texture = gl.createTexture();
+    if (texture === null)
+        throw new Error('PointShadowArray: createTexture failed');
+    gl.bindTexture(gl.TEXTURE_2D_ARRAY, texture);
+    gl.texStorage3D(gl.TEXTURE_2D_ARRAY, 1, gl.DEPTH_COMPONENT24, OCTAHEDRAL_EDGE, OCTAHEDRAL_EDGE, layers);
+    gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
+    gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    return texture;
+}

package/dist/render/pointShadowMap.d.ts

@@ -21,6 +21,18 @@ import { FACE_COUNT, POINT_SHADOW_NEAR } from './pointShadowImage.ts';
  * projection the shader reads. Nothing about the bake's cost, order or resumption moved.
  */
 export { FACE_COUNT, POINT_SHADOW_NEAR };
+/**
+ * What a bake asks of the renderer about glass, after each face's opaque depth.
+ *
+ * **Asked before it is drawn** because the answer decides whether the face binds a glass target at
+ * all: a face that offers no glass and holds none from a previous owner does no glass work.
+ */
+export interface PointGlassDraw {
+    /** Whether the face just drawn offered any glass. */
+    offered(): boolean;
+    /** Draw that glass: its depth, or what it lets through lit from the bake origin. */
+    draw(pass: 'depth' | 'tint', x: number, y: number, z: number): void;
+}
 export declare class PointShadowMap {
     readonly size: number;
     /**
@@ -85,7 +97,9 @@ export declare class PointShadowMap {
      * bake is not sampled at all until it completes, so this only matters for a re-bake,
      * where holding the old values keeps them matched to the old faces.
      */
-    bake(gl: WebGL2RenderingContext, x: number, y: number, z: number, range: number, drawCasters: (viewProj: mat4) => void, near?: number, sourceRadius?: number, maxFaces?: number): number;
+    bake(gl: WebGL2RenderingContext, x: number, y: number, z: number, range: number, drawCasters: (viewProj: mat4) => void, near?: number, sourceRadius?: number, maxFaces?: number, 
+    /** The face's glass, when glass shadows are on: `PointGlassDraw`. */
+    glass?: PointGlassDraw | null): number;
     /**
      * Nothing to free: every GPU object this map used to own belongs to `PointShadowArray` now.
      *
@@ -93,5 +107,13 @@ export declare class PointShadowMap {
      * needing disposal is exactly the shape of a leak nobody notices. The array is disposed by the
      * renderer that built it.
      */
+    /**
+     * The face's glass, twice: where the nearest pane is, then what the panes let through.
+     *
+     * A face that offers no glass still clears a region a previous owner's glass is in — the depth to
+     * the far plane and the tint to white, from scratches cleared and not drawn into — because a pool
+     * slot changes hands with its layer.
+     */
+    private bakeGlassFace;
     dispose(_gl: WebGL2RenderingContext): void;
 }

package/dist/render/pointShadowMap.js

@@ -113,7 +113,9 @@ export class PointShadowMap {
      * bake is not sampled at all until it completes, so this only matters for a re-bake,
      * where holding the old values keeps them matched to the old faces.
      */
-    bake(gl, x, y, z, range, drawCasters, near = POINT_SHADOW_NEAR, sourceRadius = DEFAULT_SOURCE_RADIUS, maxFaces = FACE_COUNT) {
+    bake(gl, x, y, z, range, drawCasters, near = POINT_SHADOW_NEAR, sourceRadius = DEFAULT_SOURCE_RADIUS, maxFaces = FACE_COUNT, 
+    /** The face's glass, when glass shadows are on: `PointGlassDraw`. */
+    glass = null) {
         /*
          * What to render now, **and what to render it for**. A bake in flight owns the parameters
          * it started with, so the arguments here are only a proposal for a bake that is not already
@@ -159,6 +161,8 @@ export class PointShadowMap {
              * next face's pass does care about.
              */
             array.resolveFace(gl, this.layer, face, plan.range, plan.near);
+            if (glass !== null)
+                this.bakeGlassFace(gl, array, glass, face, plan);
         }
         gl.enable(gl.CULL_FACE);
         gl.cullFace(gl.BACK);
@@ -173,5 +177,27 @@ export class PointShadowMap {
      * needing disposal is exactly the shape of a leak nobody notices. The array is disposed by the
      * renderer that built it.
      */
+    /**
+     * The face's glass, twice: where the nearest pane is, then what the panes let through.
+     *
+     * A face that offers no glass still clears a region a previous owner's glass is in — the depth to
+     * the far plane and the tint to white, from scratches cleared and not drawn into — because a pool
+     * slot changes hands with its layer.
+     */
+    bakeGlassFace(gl, array, glass, face, plan) {
+        if (!array.hasGlass)
+            return;
+        const offered = glass.offered();
+        if (!offered && !array.heldGlass(this.layer, face))
+            return;
+        array.beginGlassFace(gl);
+        if (offered)
+            glass.draw('depth', plan.x, plan.y, plan.z);
+        array.resolveGlassFace(gl, this.layer, face, plan.range, plan.near);
+        array.beginTintFace(gl);
+        if (offered)
+            glass.draw('tint', plan.x, plan.y, plan.z);
+        array.resolveTintFace(gl, this.layer, face, offered);
+    }
     dispose(_gl) { }
 }