@driftengine/core 4.4.2 → 4.6.0

package/dist/render/lightGrid.js

@@ -0,0 +1,87 @@
+/** The most cells a grid may span, which keeps a stray light far away from costing a gigabyte. */
+export const LIGHT_GRID_MAX_CELLS = 1 << 22;
+/** Bucket `sources` into cells of `cell` metres. Built once; not a frame path. */
+export function createLightGrid(sources, cell) {
+    if (!(cell > 0))
+        throw new Error(`createLightGrid: a cell of ${String(cell)} metres`);
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    let maxRadius = 0;
+    for (const light of sources) {
+        minX = Math.min(minX, light.x);
+        minY = Math.min(minY, light.y);
+        minZ = Math.min(minZ, light.z);
+        maxX = Math.max(maxX, light.x);
+        maxY = Math.max(maxY, light.y);
+        maxZ = Math.max(maxZ, light.z);
+        maxRadius = Math.max(maxRadius, light.radius);
+    }
+    if (sources.length === 0)
+        minX = minY = minZ = maxX = maxY = maxZ = 0;
+    const dims = [
+        Math.floor((maxX - minX) / cell) + 1,
+        Math.floor((maxY - minY) / cell) + 1,
+        Math.floor((maxZ - minZ) / cell) + 1,
+    ];
+    const cells = dims[0] * dims[1] * dims[2];
+    if (cells > LIGHT_GRID_MAX_CELLS) {
+        throw new Error(`createLightGrid: these lights span ${dims.join(' × ')} cells of ${cell} m, past ` +
+            `${LIGHT_GRID_MAX_CELLS}; a larger cell fits them.`);
+    }
+    const cellOf = (light) => Math.floor((light.x - minX) / cell) +
+        dims[0] * (Math.floor((light.y - minY) / cell) + dims[1] * Math.floor((light.z - minZ) / cell));
+    const start = new Uint32Array(cells + 1);
+    for (const light of sources) {
+        const c = cellOf(light);
+        start[c + 1] = start[c + 1] + 1;
+    }
+    for (let c = 0; c < cells; c++)
+        start[c + 1] = start[c + 1] + start[c];
+    const lights = new Uint32Array(sources.length);
+    const cursor = start.slice(0, cells);
+    for (let index = 0; index < sources.length; index++) {
+        const c = cellOf(sources[index]);
+        lights[cursor[c]] = index;
+        cursor[c] = cursor[c] + 1;
+    }
+    return {
+        sources,
+        cell,
+        origin: [minX, minY, minZ],
+        dims,
+        start,
+        lights,
+        maxRadius,
+        gathered: new Int32Array(sources.length),
+    };
+}
+/**
+ * Gather into `grid.gathered`, cell by cell, every light whose cell lies within `reach` metres of
+ * (x, y, z) on each axis, and answer how many.
+ */
+export function gatherLights(grid, x, y, z, reach) {
+    const { cell, origin, dims, start, lights, gathered } = grid;
+    const x0 = Math.max(0, Math.floor((x - reach - origin[0]) / cell));
+    const x1 = Math.min(dims[0] - 1, Math.floor((x + reach - origin[0]) / cell));
+    const y0 = Math.max(0, Math.floor((y - reach - origin[1]) / cell));
+    const y1 = Math.min(dims[1] - 1, Math.floor((y + reach - origin[1]) / cell));
+    const z0 = Math.max(0, Math.floor((z - reach - origin[2]) / cell));
+    const z1 = Math.min(dims[2] - 1, Math.floor((z + reach - origin[2]) / cell));
+    let count = 0;
+    for (let cz = z0; cz <= z1; cz++) {
+        for (let cy = y0; cy <= y1; cy++) {
+            const row = dims[0] * (cy + dims[1] * cz);
+            for (let cx = x0; cx <= x1; cx++) {
+                const c = row + cx;
+                for (let at = start[c]; at < start[c + 1]; at++) {
+                    gathered[count++] = lights[at];
+                }
+            }
+        }
+    }
+    return count;
+}

package/dist/render/mesh.d.ts

@@ -7,6 +7,9 @@ import type { MeshData } from '@driftengine/drft';
 export declare class Mesh {
     private readonly vao;
     private readonly buffers;
+    /** Every attribute bound from a buffer, so a batch can build a vertex array of its own. */
+    private readonly layout;
+    private indexBuffer;
     /**
      * The position and normal buffers, kept so `update` can rewrite them.
      *
@@ -16,7 +19,8 @@ export declare class Mesh {
     private readonly deformable;
     /** How many floats the position buffer holds, so an update of the wrong size is refused. */
     private readonly positionFloats;
-    private readonly indexCount;
+    /** Indices one draw of it issues; the batch-size rule reads it (`cullsInstances`). */
+    readonly indexCount: number;
     /**
      * The constant values this mesh's *absent* attributes are shaded with, re-applied on
      * every draw.
@@ -94,30 +98,18 @@ export declare class Mesh {
     /** Caller is responsible for having the flat program + uniforms bound. */
     draw(gl: WebGL2RenderingContext): void;
     /**
-     * Bind one buffer's per-instance attributes to this mesh's vertex array.
-     *
-     * **One batch per mesh, and the vertex array is why.** A `Mesh` owns exactly one, so a second
-     * batch would rebind locations 11 to 15 on the array the first still draws through — and what
-     * comes out is one batch's instances placed by the other's matrices, which reads as a transform
-     * bug in the consumer's own code rather than as a misuse of this.
-     *
-     * **What would make it wrong** is a consumer legitimately wanting two batches of one mesh,
-     * which wants a vertex array per batch rather than a flag here.
-     */
-    attachInstances(gl: WebGL2RenderingContext, buffer: WebGLBuffer, stride: number): void;
-    /** The instance columns, bound. Called at attach and again after a plain draw disabled them. */
-    private bindInstanceColumns;
-    private instanceBuffer;
-    private instanceStride;
-    /** Whether `attachInstances` has already claimed locations 11 to 15 on this mesh's array. */
-    private instanced;
-    /**
-     * Draw `count` instances through the attributes `attachInstances` bound.
-     *
-     * The constants are re-applied exactly as `draw` does — a vertex array restores the arrays and
-     * not the constant attributes, and an absent optional attribute is a constant here.
+     * A vertex array for one instanced batch: every attribute this mesh binds from a buffer, its index
+     * buffer, and the batch's instance columns — the model matrix at 11 to 14, the tint at 15.
+     *
+     * **A batch owns its own array**, which is what lets a mesh have more than one batch: a prop drawn
+     * once per region is one mesh and a batch per region. With one array a mesh had one batch, since a
+     * second would rebind the columns the first draws through and place one batch's instances by the
+     * other's matrices. The arrays share every buffer, so a batch costs its instances and nothing of
+     * the geometry. The caller deletes what this returns.
      */
-    drawInstances(gl: WebGL2RenderingContext, count: number): void;
+    createInstanceArray(gl: WebGL2RenderingContext, instances: WebGLBuffer, stride: number): WebGLVertexArrayObject;
+    /** Draw `count` instances through a batch's own vertex array. See `createInstanceArray`. */
+    drawInstancesThrough(gl: WebGL2RenderingContext, vao: WebGLVertexArrayObject, count: number): void;
     dispose(gl: WebGL2RenderingContext): void;
     /**
      * Rewrite this mesh's positions, and its normals where the caller has them.
@@ -179,3 +171,5 @@ export interface IncrementalMesh {
  * them before a byte of it has landed.
  */
 export declare function createMeshIncremental(gl: WebGL2RenderingContext, data: MeshData, dynamic?: boolean): IncrementalMesh;
+/** Texture coordinates and layers interleaved as (u, v, layer), one row a vertex. */
+export declare function packUvLayers(uvs: Float32Array, layers: Float32Array): Float32Array;

package/dist/render/mesh.js

@@ -49,14 +49,6 @@ const ATTR_JOINTS = 11;
  * setting sway, watching nothing move, and having nothing to read about why.
  */
 const ATTR_CHANNEL = 13;
-/**
- * The locations `attachInstances` claims, which a plain draw through the same array must not read.
- *
- * Eleven to fourteen are the model matrix's columns and fifteen is the tint. **Thirteen is also
- * the channel**, and eleven and twelve are the skinning pair — which cannot collide, because
- * `flatVert` refuses skinning with instancing. See `draw`.
- */
-const INSTANCE_COLUMNS = [11, 12, 13, 14, 15];
 const ATTR_WEIGHTS = 12;
 /**
  * One absent attribute's constant, at the width the table gave it.
@@ -84,6 +76,9 @@ function applyConstant(gl, location, value) {
 export class Mesh {
     vao;
     buffers = [];
+    /** Every attribute bound from a buffer, so a batch can build a vertex array of its own. */
+    layout = [];
+    indexBuffer = null;
     /**
      * The position and normal buffers, kept so `update` can rewrite them.
      *
@@ -93,6 +88,7 @@ export class Mesh {
     deformable = null;
     /** How many floats the position buffer holds, so an update of the wrong size is refused. */
     positionFloats;
+    /** Indices one draw of it issues; the batch-size rule reads it (`cullsInstances`). */
     indexCount;
     /**
      * The constant values this mesh's *absent* attributes are shaded with, re-applied on
@@ -211,7 +207,14 @@ export class Mesh {
             gl.disableVertexAttribArray(ATTR_UV);
             this.constants.push({ location: ATTR_UV, value: ABSENT_ATTRIBUTE['uvs'] });
         }
+        else if (data.layers !== undefined) {
+            /* The texture-array layer rides as the third coordinate — every vertex location is spent —
+               so a layered mesh uploads (u, v, layer) packed. See `MeshData.layers`. */
+            this.attachAttribute(gl, ATTR_UV, packUvLayers(data.uvs, data.layers), 3);
+        }
         else {
+            /* Two components; the shader's vec3 reads z as 0 by the GL rule for a missing component,
+               which is layer 0 — the only layer a plain texture has. */
             this.attachAttribute(gl, ATTR_UV, data.uvs, 2);
         }
         /* Absent means "inherit albedo", supplied as the constant the shader tests for. */
@@ -297,6 +300,7 @@ export class Mesh {
             throw new Error('createBuffer failed');
         this.buffers.push(indexBuffer);
         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+        this.indexBuffer = indexBuffer;
         this.allocate(gl, gl.ELEMENT_ARRAY_BUFFER, indexBuffer, data.indices, gl.STATIC_DRAW);
         gl.bindVertexArray(null);
     }
@@ -304,29 +308,11 @@ export class Mesh {
     draw(gl) {
         gl.bindVertexArray(this.vao);
         /*
-         * **A mesh with a batch has the instance columns enabled on this very array, and location 13
-         * is the channel.** `attachInstances` claims 11 to 14 for the model matrix and 15 for the
-         * tint; a `Mesh` owns one vertex array, so those bindings are still live for a *plain* draw
-         * through it — and `aChannel` then reads the third column of instance zero's matrix instead
-         * of the absent-attribute constant. For a placement with no rotation that column is
-         * `(0, 0, 1, 0)`, so `aChannel.y` is zero, `vSkyDirect = aChannel.y` scales the directional
-         * term to nothing, and the mesh renders lit by the hemispheric ambient alone — correct
-         * normals, correct albedo, no error, no warning.
-         *
-         * Found on `demo/instancing.ts`, which exists to draw two ranks of one box the two ways and
-         * compare them: the `drawMesh` rank's top face read (51, 30, 21) against the `drawInstanced`
-         * rank's (218, 110, 59), and 51 is exactly the ambient. WebGPU has no array to share and drew
-         * them alike, which is what made it visible at all.
-         *
-         * Disabled here and put back by `drawInstances`, rather than given the batch an array of its
-         * own: that is the larger change this class's own note about two batches already contemplates,
-         * and it wants one for a different reason. Three calls on a mesh that has a batch and none on
-         * a mesh that does not.
+         * No instance columns to disable: a batch draws through a vertex array of its own
+         * (`createInstanceArray`), so this array never carries them. It used to, and location 13 — the
+         * channel — then read the third column of instance zero's matrix on a plain draw, which lit a
+         * mesh by ambient alone on this backend and not the other.
          */
-        if (this.instanced) {
-            for (const location of INSTANCE_COLUMNS)
-                gl.disableVertexAttribArray(location);
-        }
         // The VAO restores the arrays; these it cannot. See `constants`.
         for (const constant of this.constants) {
             const value = constant.value;
@@ -335,32 +321,27 @@ export class Mesh {
         gl.drawElements(gl.TRIANGLES, this.indexCount, gl.UNSIGNED_INT, 0);
     }
     /**
-     * Bind one buffer's per-instance attributes to this mesh's vertex array.
-     *
-     * **One batch per mesh, and the vertex array is why.** A `Mesh` owns exactly one, so a second
-     * batch would rebind locations 11 to 15 on the array the first still draws through — and what
-     * comes out is one batch's instances placed by the other's matrices, which reads as a transform
-     * bug in the consumer's own code rather than as a misuse of this.
+     * A vertex array for one instanced batch: every attribute this mesh binds from a buffer, its index
+     * buffer, and the batch's instance columns — the model matrix at 11 to 14, the tint at 15.
      *
-     * **What would make it wrong** is a consumer legitimately wanting two batches of one mesh,
-     * which wants a vertex array per batch rather than a flag here.
+     * **A batch owns its own array**, which is what lets a mesh have more than one batch: a prop drawn
+     * once per region is one mesh and a batch per region. With one array a mesh had one batch, since a
+     * second would rebind the columns the first draws through and place one batch's instances by the
+     * other's matrices. The arrays share every buffer, so a batch costs its instances and nothing of
+     * the geometry. The caller deletes what this returns.
      */
-    attachInstances(gl, buffer, stride) {
-        if (this.instanced) {
-            throw new Error('Mesh: this mesh already has an instanced batch — a Mesh owns one vertex array, so a ' +
-                'second batch would rebind the attributes the first draws through.');
+    createInstanceArray(gl, instances, stride) {
+        const vao = gl.createVertexArray();
+        if (vao === null)
+            throw new Error('createVertexArray failed');
+        gl.bindVertexArray(vao);
+        for (const attribute of this.layout) {
+            gl.bindBuffer(gl.ARRAY_BUFFER, attribute.buffer);
+            gl.enableVertexAttribArray(attribute.location);
+            gl.vertexAttribPointer(attribute.location, attribute.size, gl.FLOAT, false, 0, 0);
         }
-        this.instanced = true;
-        this.instanceBuffer = buffer;
-        this.instanceStride = stride;
-        gl.bindVertexArray(this.vao);
-        this.bindInstanceColumns(gl, buffer);
-        gl.bindVertexArray(null);
-    }
-    /** The instance columns, bound. Called at attach and again after a plain draw disabled them. */
-    bindInstanceColumns(gl, buffer) {
-        const stride = this.instanceStride;
-        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer);
+        gl.bindBuffer(gl.ARRAY_BUFFER, instances);
         /* Four vec4 columns then a vec3 tint: a mat4 is not a vertex attribute in GLSL ES 300. */
         for (let column = 0; column < 4; column += 1) {
             const location = 11 + column;
@@ -371,22 +352,12 @@ export class Mesh {
         gl.enableVertexAttribArray(15);
         gl.vertexAttribPointer(15, 3, gl.FLOAT, false, stride, 64);
         gl.vertexAttribDivisor(15, 1);
+        gl.bindVertexArray(null);
+        return vao;
     }
-    instanceBuffer = null;
-    instanceStride = 0;
-    /** Whether `attachInstances` has already claimed locations 11 to 15 on this mesh's array. */
-    instanced = false;
-    /**
-     * Draw `count` instances through the attributes `attachInstances` bound.
-     *
-     * The constants are re-applied exactly as `draw` does — a vertex array restores the arrays and
-     * not the constant attributes, and an absent optional attribute is a constant here.
-     */
-    drawInstances(gl, count) {
-        gl.bindVertexArray(this.vao);
-        /* Put back what `draw` disabled, if a plain draw of this mesh came first. See its note. */
-        if (this.instanceBuffer !== null)
-            this.bindInstanceColumns(gl, this.instanceBuffer);
+    /** Draw `count` instances through a batch's own vertex array. See `createInstanceArray`. */
+    drawInstancesThrough(gl, vao, count) {
+        gl.bindVertexArray(vao);
         for (const constant of this.constants) {
             const value = constant.value;
             applyConstant(gl, constant.location, value);
@@ -438,6 +409,7 @@ export class Mesh {
         this.allocate(gl, gl.ARRAY_BUFFER, buffer, data, usage);
         gl.enableVertexAttribArray(location);
         gl.vertexAttribPointer(location, size, gl.FLOAT, false, 0, 0);
+        this.layout.push({ location, buffer, size });
         return buffer;
     }
     /**
@@ -508,3 +480,14 @@ export function createMeshIncremental(gl, data, dynamic = false) {
     const mesh = new Mesh(gl, data, dynamic, true);
     return { mesh, upload: mesh.uploads(gl) };
 }
+/** Texture coordinates and layers interleaved as (u, v, layer), one row a vertex. */
+export function packUvLayers(uvs, layers) {
+    const count = layers.length;
+    const packed = new Float32Array(count * 3);
+    for (let v = 0; v < count; v++) {
+        packed[v * 3] = uvs[v * 2];
+        packed[v * 3 + 1] = uvs[v * 2 + 1];
+        packed[v * 3 + 2] = layers[v];
+    }
+    return packed;
+}

package/dist/render/occlusion.d.ts

@@ -51,6 +51,16 @@ export declare class OcclusionBuffer {
      * something hidden costs a draw call; culling something visible is a hole.
      */
     occluded(bounds: Bounds, model: ReadonlyMat4): boolean;
+    /**
+     * Whether a world-space box is entirely behind the declared occluders — the tighter question for
+     * something that is a box, where the cube around its sphere reaches far past it. **A flat region
+     * is the case it exists for**: a city block's sphere is half as deep underground as it is wide,
+     * nothing there occludes it, and the sphere test abstains for every block in the city. False
+     * whenever anything is uncertain, exactly as `occluded`.
+     */
+    occludedBox(min: ArrayLike<number>, max: ArrayLike<number>): boolean;
+    /** The shared test: a world box's corners projected, its rectangle tested against the pyramid. */
+    private boxBehind;
     /**
      * A world point into buffer coordinates and depth, written into `CORNERS` at `slot`.
      *

package/dist/render/occlusion.js

@@ -33,6 +33,8 @@
  */
 /** What an unwritten texel holds: the far plane, which occludes nothing. */
 const FAR = 1;
+/** Texels a tested rectangle may span at the level it is read from. See `boxBehind`. */
+const TEXELS_ACROSS = 8;
 export class OcclusionBuffer {
     /**
      * The pyramid, level 0 first, each level a quarter of the one before.
@@ -169,15 +171,33 @@ export class OcclusionBuffer {
         const sz = Math.sqrt(m8 * m8 + m9 * m9 + m10 * m10);
         const radius = bounds.radius * Math.max(sx, sy, sz);
         /* The cube that contains the sphere, which contains the object. Conservative twice over. */
+        return this.boxBehind(x - radius, y - radius, z - radius, x + radius, y + radius, z + radius);
+    }
+    /**
+     * Whether a world-space box is entirely behind the declared occluders — the tighter question for
+     * something that is a box, where the cube around its sphere reaches far past it. **A flat region
+     * is the case it exists for**: a city block's sphere is half as deep underground as it is wide,
+     * nothing there occludes it, and the sphere test abstains for every block in the city. False
+     * whenever anything is uncertain, exactly as `occluded`.
+     */
+    occludedBox(min, max) {
+        if (this.occluders === 0)
+            return false;
+        if (!this.built)
+            this.buildPyramid();
+        return this.boxBehind(min[0] ?? 0, min[1] ?? 0, min[2] ?? 0, max[0] ?? 0, max[1] ?? 0, max[2] ?? 0);
+    }
+    /** The shared test: a world box's corners projected, its rectangle tested against the pyramid. */
+    boxBehind(loX, loY, loZ, hiX, hiY, hiZ) {
         let minX = Infinity;
         let minY = Infinity;
         let minZ = Infinity;
         let maxX = -Infinity;
         let maxY = -Infinity;
         for (let corner = 0; corner < 8; corner++) {
-            const px = corner & 1 ? x + radius : x - radius;
-            const py = corner & 2 ? y + radius : y - radius;
-            const pz = corner & 4 ? z + radius : z - radius;
+            const px = corner & 1 ? hiX : loX;
+            const py = corner & 2 ? hiY : loY;
+            const pz = corner & 4 ? hiZ : loZ;
             if (!this.project(px, py, pz, 0))
                 return false;
             minX = Math.min(minX, CORNERS[0] ?? 0);
@@ -192,13 +212,22 @@ export class OcclusionBuffer {
         if (minX < 0 || minY < 0 || maxX > width || maxY > height)
             return false;
         /*
-         * The coarsest level whose texel is at least as wide as the rectangle, so the test reads at
-         * most two texels each way. `Math.log2` would say the same thing and is one of the calls this
-         * repository's determinism gate refuses elsewhere; a shift loop says it in integers.
+         * The coarsest level at which the rectangle spans at most `TEXELS_ACROSS` texels, so the test
+         * reads at most that many plus one each way. `Math.log2` would say the same thing and is one of
+         * the calls this repository's determinism gate refuses elsewhere; a shift loop says it in integers.
+         *
+         * **Eight, not one, since 2026-09-30.** At one the level's texel was as wide as the rectangle, and
+         * two such texels aligned to the grid span up to twice it — so anything whose rectangle came near
+         * an occluder's edge, or the buffer's own unwritten border row, read unwritten texels and
+         * abstained. That was every city region behind a row of buildings, whose rectangle sits just
+         * under the skyline; measured on a box seven metres wide behind a wall filling the view, which
+         * one abstained at and eight culls. Reading up to 81 texels instead of 4 costs a few dozen
+         * compares and keeps the answer exactly as conservative: the maximum over every texel the
+         * rectangle touches.
          */
         let level = 0;
         let span = Math.max(maxX - minX, maxY - minY);
-        while (span > 1 && level + 1 < this.levels.length) {
+        while (span > TEXELS_ACROSS && level + 1 < this.levels.length) {
             span *= 0.5;
             level++;
         }

package/dist/render/pointGlassTint.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 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 declare class PointGlassTint {
+    readonly texture: WebGLTexture;
+    readonly edge: number;
+    private readonly layers;
+    private readonly levels;
+    private readonly faceSize;
+    private readonly scratch;
+    private readonly scratchFramebuffer;
+    private readonly staging;
+    private readonly framebuffer;
+    private readonly readFramebuffer;
+    /** Parked on the resolve's unit while the scratch is a render target; see `beginFace`. */
+    private readonly parked;
+    private readonly program;
+    private readonly uniforms;
+    private readonly vao;
+    /** Six bits a layer: which faces' regions hold glass. */
+    private readonly heldFaces;
+    /** Layers whose level 0 changed since the chain was last rebuilt. */
+    private readonly dirty;
+    constructor(gl: WebGL2RenderingContext, faceSize: number, edge: number, layers: number);
+    /** Whether `face` of `layer` holds glass: a face that does must be cleared before it is reused. */
+    held(layer: number, face: number): boolean;
+    /**
+     * 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: WebGL2RenderingContext): void;
+    /**
+     * 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: WebGL2RenderingContext, layer: number, face: number, drawn: boolean): void;
+    /** Rebuild the chain of every layer touched since the last call, one layer at a time. */
+    fillMips(gl: WebGL2RenderingContext): void;
+    dispose(gl: WebGL2RenderingContext): void;
+}