@driftengine/core 4.5.0 → 4.6.0

package/dist/render/driftLight/lightField.d.ts

@@ -29,6 +29,7 @@ import type { GlobalFieldInstance } from '../gi/globalField.ts';
 import type { FieldLight } from './bake.ts';
 import type { PointLightFalloff } from './falloff.ts';
 import type { LightFieldLayout } from './layout.ts';
+import type { DriftLightVolumes } from './presence.ts';
 /** Seconds the summed light takes to fade in once the field is whole. */
 export declare const FIELD_FADE_SEC = 0.5;
 /** A light a field sums: a `PointLightSource`, whose `inLightField` the field sets. */
@@ -51,7 +52,7 @@ export interface LightFieldOptions {
      */
     readonly fadeSec?: number;
 }
-export declare class LightField {
+export declare class LightField implements DriftLightVolumes {
     readonly layout: LightFieldLayout;
     /** Texels on each axis of the atlas. */
     readonly atlasSize: readonly [number, number, number];
@@ -67,17 +68,14 @@ export declare class LightField {
     readonly fadeSec: number;
     /** The summed light's brightness, for a scene that dims all its lamps at once: dawn, a switch. */
     scale: number;
-    /** Where the frame's choice was centred, which the shader measures the radius from. */
-    readonly centre: Float32Array<ArrayBuffer>;
     private readonly lights;
     private readonly falloff;
     private readonly distance;
     private readonly lightBlock;
     private readonly directionBlock;
+    private readonly showing;
     private baked;
     private taken;
-    private eased;
-    private shown;
     constructor(lights: readonly LightFieldSource[], options: LightFieldOptions);
     /** Whether every brick has been baked. */
     get ready(): boolean;
@@ -87,6 +85,13 @@ export declare class LightField {
     get radius(): number;
     /** How much of the summed light is in the frame, 0 until the field is whole, then up to 1. */
     get presence(): number;
+    /** Where the frame's choice was centred, which the shader measures the radius from. */
+    get centre(): Float32Array;
+    get empty(): boolean;
+    get indexDims(): readonly [number, number, number];
+    get index(): Uint32Array;
+    get sampleOrigin(): readonly [number, number, number];
+    get signedSpacing(): number;
     /** The texel at which brick `brick`'s light block starts; its direction block is 4 along x. */
     atlasCorner(brick: number): [number, number, number];
     /** Bake up to `bricks` more bricks into the atlas, and answer how many were baked. */

package/dist/render/driftLight/lightField.js

@@ -29,10 +29,9 @@ import { distanceToInstances } from '../gi/globalField.js';
 import { halfBits } from '../halfFloat.js';
 import { BRICK_TEXELS, bakeBrick } from './bake.js';
 import { BRICK_SAMPLES, layoutLightField } from './layout.js';
+import { FieldPresence } from './presence.js';
 /** Seconds the summed light takes to fade in once the field is whole. */
 export const FIELD_FADE_SEC = 0.5;
-/** How fast the shading radius grows back, per second, when the choice reaches further again. */
-const RADIUS_GROWTH_PER_SEC = 2;
 /** Bricks along each axis of the atlas: 256 texels a side, the least 3D texture WebGL2 promises. */
 const ATLAS_BRICKS = [32, 64, 64];
 /** A brick's footprint in the atlas: its light block and its direction block side by side. */
@@ -53,17 +52,14 @@ export class LightField {
     fadeSec;
     /** The summed light's brightness, for a scene that dims all its lamps at once: dawn, a switch. */
     scale = 1;
-    /** Where the frame's choice was centred, which the shader measures the radius from. */
-    centre = new Float32Array(3);
     lights;
     falloff;
     distance;
     lightBlock = new Float32Array(BRICK_TEXELS * 4);
     directionBlock = new Float32Array(BRICK_TEXELS * 4);
+    showing;
     baked = 0;
     taken = 0;
-    eased = 0;
-    shown = 0;
     constructor(lights, options) {
         for (const light of lights)
             light.inLightField = true;
@@ -80,6 +76,7 @@ export class LightField {
         this.falloff = options.falloff;
         this.band = options.band ?? 2;
         this.fadeSec = Math.max(0, options.fadeSec ?? FIELD_FADE_SEC);
+        this.showing = new FieldPresence(this.fadeSec);
         const fields = options.fields ?? [];
         this.occluded = fields.length > 0;
         this.distance = this.occluded ? distanceToInstances(fields) : null;
@@ -107,11 +104,30 @@ export class LightField {
     }
     /** The radius, in metres from `centre`, inside which lights are shaded exactly. */
     get radius() {
-        return this.eased;
+        return this.showing.radius;
     }
     /** How much of the summed light is in the frame, 0 until the field is whole, then up to 1. */
     get presence() {
-        return this.shown;
+        return this.showing.presence;
+    }
+    /** Where the frame's choice was centred, which the shader measures the radius from. */
+    get centre() {
+        return this.showing.centre;
+    }
+    get empty() {
+        return this.layout.count === 0;
+    }
+    get indexDims() {
+        return this.layout.dims;
+    }
+    get index() {
+        return this.layout.index;
+    }
+    get sampleOrigin() {
+        return this.layout.origin;
+    }
+    get signedSpacing() {
+        return this.layout.spacing;
     }
     /** The texel at which brick `brick`'s light block starts; its direction block is 4 along x. */
     atlasCorner(brick) {
@@ -146,17 +162,7 @@ export class LightField {
      * which is only less exact. While nothing is summed the radius simply follows.
      */
     follow(complete, x, y, z, dtSec) {
-        this.centre[0] = x;
-        this.centre[1] = y;
-        this.centre[2] = z;
-        const showing = this.shown > 0;
-        if (!showing || complete < this.eased)
-            this.eased = complete;
-        else
-            this.eased += (complete - this.eased) * (1 - Math.exp(-RADIUS_GROWTH_PER_SEC * dtSec));
-        if (this.ready) {
-            this.shown = this.fadeSec > 0 ? Math.min(1, this.shown + dtSec / this.fadeSec) : 1;
-        }
+        this.showing.follow(this.ready, complete, x, y, z, dtSec);
     }
     /** Write the brick just baked into its place in the atlas, as half floats. */
     place(brick) {

package/dist/render/driftLight/presence.d.ts

@@ -0,0 +1,50 @@
+/**
+ * How much of a DriftLight field is in the frame, and the radius inside which the frame's exact
+ * lights take over from it — the part every kind of field shares, kept once.
+ *
+ * **The radius shrinks at once and grows back slowly.** A pixel inside it that a left-out light
+ * reaches would be shaded short, so it cannot lag a shrink; a pixel it has not reached yet takes the
+ * summed light, which is only less exact, so a grow may ease. While nothing is summed the radius
+ * simply follows. The presence fades in over `fadeSec` once the field is whole, so a field
+ * completing in view does not pop — and a held clock never finishes a fade, so a field behind a
+ * loading screen asks for none.
+ */
+export declare class FieldPresence {
+    readonly fadeSec: number;
+    /** Where the frame's choice was centred, which the shader measures the radius from. */
+    readonly centre: Float32Array<ArrayBuffer>;
+    private eased;
+    private shown;
+    constructor(fadeSec: number);
+    /** The radius, in metres from `centre`, inside which lights are shaded exactly. */
+    get radius(): number;
+    /** How much of the summed light is in the frame, 0 until the field is whole, then up to 1. */
+    get presence(): number;
+    /** Follow the frame's choice: `complete` from the selection, centred at (x, y, z). */
+    follow(ready: boolean, complete: number, x: number, y: number, z: number, dtSec: number): void;
+}
+/**
+ * What a backend uploads and binds for a field of either kind, and what the uniforms are made of.
+ *
+ * A sparse field's index finds its bricks; a dense one brings a 1×1×1 index of nothing, so the
+ * upload and the bind are one code path, and says it is dense by a negative spacing.
+ */
+export interface DriftLightVolumes {
+    readonly ready: boolean;
+    /** Nothing summed at all: nothing to upload. */
+    readonly empty: boolean;
+    readonly indexDims: readonly [number, number, number];
+    readonly index: Uint32Array;
+    readonly atlasSize: readonly [number, number, number];
+    /** Half floats, four channels a texel, x fastest. */
+    readonly atlas: Uint16Array;
+    readonly presence: number;
+    readonly radius: number;
+    readonly band: number;
+    readonly scale: number;
+    readonly centre: Float32Array;
+    /** The world position of the first sample. */
+    readonly sampleOrigin: readonly [number, number, number];
+    /** Metres between samples, negative for a dense volume: the shader's mode. */
+    readonly signedSpacing: number;
+}

package/dist/render/driftLight/presence.js

@@ -0,0 +1,43 @@
+/**
+ * How much of a DriftLight field is in the frame, and the radius inside which the frame's exact
+ * lights take over from it — the part every kind of field shares, kept once.
+ *
+ * **The radius shrinks at once and grows back slowly.** A pixel inside it that a left-out light
+ * reaches would be shaded short, so it cannot lag a shrink; a pixel it has not reached yet takes the
+ * summed light, which is only less exact, so a grow may ease. While nothing is summed the radius
+ * simply follows. The presence fades in over `fadeSec` once the field is whole, so a field
+ * completing in view does not pop — and a held clock never finishes a fade, so a field behind a
+ * loading screen asks for none.
+ */
+/** How fast the shading radius grows back, per second, when the choice reaches further again. */
+const RADIUS_GROWTH_PER_SEC = 2;
+export class FieldPresence {
+    fadeSec;
+    /** Where the frame's choice was centred, which the shader measures the radius from. */
+    centre = new Float32Array(3);
+    eased = 0;
+    shown = 0;
+    constructor(fadeSec) {
+        this.fadeSec = fadeSec;
+    }
+    /** The radius, in metres from `centre`, inside which lights are shaded exactly. */
+    get radius() {
+        return this.eased;
+    }
+    /** How much of the summed light is in the frame, 0 until the field is whole, then up to 1. */
+    get presence() {
+        return this.shown;
+    }
+    /** Follow the frame's choice: `complete` from the selection, centred at (x, y, z). */
+    follow(ready, complete, x, y, z, dtSec) {
+        this.centre[0] = x;
+        this.centre[1] = y;
+        this.centre[2] = z;
+        if (this.shown <= 0 || complete < this.eased)
+            this.eased = complete;
+        else
+            this.eased += (complete - this.eased) * (1 - Math.exp(-RADIUS_GROWTH_PER_SEC * dtSec));
+        if (ready)
+            this.shown = this.fadeSec > 0 ? Math.min(1, this.shown + dtSec / this.fadeSec) : 1;
+    }
+}

package/dist/render/driftLight/uniforms.d.ts

@@ -13,11 +13,11 @@
  * pixel the shader shades exactly inside the radius the selection promised. A mirror's camera, far
  * from the centre, gets a smaller radius and more of the volume, which is the safe direction.
  */
-import type { LightField } from './lightField.ts';
+import type { DriftLightVolumes } from './presence.ts';
 export interface DriftLightUniforms {
     /** How much of the summed light is in, the radius, the band, the scale. */
     readonly light: Float32Array;
-    /** The first brick's first sample, and the metres between samples. */
+    /** The first sample, and the metres between samples — negative for a dense volume. */
     readonly origin: Float32Array;
 }
 export declare function createDriftLightUniforms(): DriftLightUniforms;
@@ -25,4 +25,4 @@ export declare function createDriftLightUniforms(): DriftLightUniforms;
  * Fill `out` for `field`, or for no field, seen from `eye`; `probePass` while a probe's faces are
  * being drawn.
  */
-export declare function resolveDriftLight(field: LightField | null, probePass: boolean, eye: ArrayLike<number>, out: DriftLightUniforms): void;
+export declare function resolveDriftLight(field: DriftLightVolumes | null, probePass: boolean, eye: ArrayLike<number>, out: DriftLightUniforms): void;

package/dist/render/driftLight/uniforms.js

@@ -24,18 +24,17 @@ export function createDriftLightUniforms() {
  * being drawn.
  */
 export function resolveDriftLight(field, probePass, eye, out) {
-    if (field === null || !field.ready || field.presence <= 0 || field.layout.count === 0) {
+    if (field === null || !field.ready || field.presence <= 0 || field.empty) {
         out.light.fill(0);
         return;
     }
-    const { layout } = field;
     const offset = Math.hypot((eye[0] ?? 0) - field.centre[0], (eye[1] ?? 0) - field.centre[1], (eye[2] ?? 0) - field.centre[2]);
     out.light[0] = field.presence;
     out.light[1] = probePass ? 0 : Math.max(0, field.radius - offset);
     out.light[2] = field.band;
     out.light[3] = field.scale;
-    out.origin[0] = layout.origin[0];
-    out.origin[1] = layout.origin[1];
-    out.origin[2] = layout.origin[2];
-    out.origin[3] = layout.spacing;
+    out.origin[0] = field.sampleOrigin[0];
+    out.origin[1] = field.sampleOrigin[1];
+    out.origin[2] = field.sampleOrigin[2];
+    out.origin[3] = field.signedSpacing;
 }

package/dist/render/driftLight/worldLightField.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A world's DriftLight: a dense volume baked offline (`bakeDenseField`), handed to the renderer
+ * whole, standing in for every fixed light past the frame's exact choice.
+ *
+ * **Whole from the start**, because nothing is baked in the page: `ready` is true on construction
+ * and the volume fades in over `fadeSec` from the first `follow`. The lights it summed are the
+ * scene's to mark `inLightField`, so the selection knows not to count them twice — a volume carries
+ * no list of the lights it came from.
+ *
+ * **Light and direction side by side along y**, the short axis: a city is 256 samples across and a
+ * few dozen up, and a 3D texture promises 256 on every axis, so stacking the two there keeps both
+ * inside one texture and one sampler. The shader keeps each lookup inside its own half.
+ */
+import type { DenseLightVolume } from './denseField.ts';
+import type { DriftLightVolumes } from './presence.ts';
+export interface WorldLightFieldOptions {
+    /** Metres over which exact and summed light crossfade at the shading radius. Two by default. */
+    readonly band?: number;
+    /** Seconds the volume fades in over; zero behind a loading screen, whose clock may be held. */
+    readonly fadeSec?: number;
+}
+export declare class WorldLightField implements DriftLightVolumes {
+    readonly ready = true;
+    readonly empty = false;
+    readonly indexDims: readonly [number, number, number];
+    readonly index: Uint32Array<ArrayBuffer>;
+    readonly atlasSize: readonly [number, number, number];
+    readonly atlas: Uint16Array;
+    readonly band: number;
+    readonly sampleOrigin: readonly [number, number, number];
+    readonly signedSpacing: number;
+    /** The summed light's brightness, for a scene that dims all its lamps at once. */
+    scale: number;
+    private readonly showing;
+    constructor(volume: DenseLightVolume, options?: WorldLightFieldOptions);
+    get radius(): number;
+    get presence(): number;
+    get centre(): Float32Array;
+    /** Follow the frame's choice, as `LightField.follow` does. */
+    follow(complete: number, x: number, y: number, z: number, dtSec: number): void;
+}

package/dist/render/driftLight/worldLightField.js

@@ -0,0 +1,66 @@
+/**
+ * A world's DriftLight: a dense volume baked offline (`bakeDenseField`), handed to the renderer
+ * whole, standing in for every fixed light past the frame's exact choice.
+ *
+ * **Whole from the start**, because nothing is baked in the page: `ready` is true on construction
+ * and the volume fades in over `fadeSec` from the first `follow`. The lights it summed are the
+ * scene's to mark `inLightField`, so the selection knows not to count them twice — a volume carries
+ * no list of the lights it came from.
+ *
+ * **Light and direction side by side along y**, the short axis: a city is 256 samples across and a
+ * few dozen up, and a 3D texture promises 256 on every axis, so stacking the two there keeps both
+ * inside one texture and one sampler. The shader keeps each lookup inside its own half.
+ */
+import { halfBits } from '../halfFloat.js';
+import { FieldPresence } from './presence.js';
+/** The index a dense volume binds in the sparse one's place: one cell, no brick. */
+const NO_INDEX = new Uint32Array(1);
+export class WorldLightField {
+    ready = true;
+    empty = false;
+    indexDims = [1, 1, 1];
+    index = NO_INDEX;
+    atlasSize;
+    atlas;
+    band;
+    sampleOrigin;
+    signedSpacing;
+    /** The summed light's brightness, for a scene that dims all its lamps at once. */
+    scale = 1;
+    showing;
+    constructor(volume, options = {}) {
+        const [x, y, z] = volume.dims;
+        this.atlasSize = [x, y * 2, z];
+        this.atlas = new Uint16Array(x * y * 2 * z * 4);
+        for (let k = 0; k < z; k++) {
+            for (let j = 0; j < y; j++) {
+                for (let i = 0; i < x; i++) {
+                    const from = (i + x * (j + y * k)) * 4;
+                    const light = (i + x * (j + 2 * y * k)) * 4;
+                    const direction = (i + x * (j + y + 2 * y * k)) * 4;
+                    for (let c = 0; c < 4; c++) {
+                        this.atlas[light + c] = halfBits(volume.light[from + c]);
+                        this.atlas[direction + c] = halfBits(volume.direction[from + c]);
+                    }
+                }
+            }
+        }
+        this.band = options.band ?? 2;
+        this.sampleOrigin = volume.origin;
+        this.signedSpacing = -volume.spacing;
+        this.showing = new FieldPresence(Math.max(0, options.fadeSec ?? 0.5));
+    }
+    get radius() {
+        return this.showing.radius;
+    }
+    get presence() {
+        return this.showing.presence;
+    }
+    get centre() {
+        return this.showing.centre;
+    }
+    /** Follow the frame's choice, as `LightField.follow` does. */
+    follow(complete, x, y, z, dtSec) {
+        this.showing.follow(true, complete, x, y, z, dtSec);
+    }
+}

package/dist/render/fixtureAtlas.d.ts

@@ -0,0 +1,20 @@
+export interface FixtureAtlasLayout {
+    readonly width: number;
+    readonly height: number;
+    /** Rows of cookie tiles at the top: `COOKIE_TILE`, or 0 with none loaded. */
+    readonly cookieRows: number;
+    /** The first row of the profiles, below the cookies. */
+    readonly iesTop: number;
+}
+/** The atlas for `iesRows` rows of profile and `cookieTiles` cookies. */
+export declare function fixtureAtlasLayout(iesRows: number, cookieTiles: number): FixtureAtlasLayout;
+/**
+ * The profiles' rows as the atlas holds them: `data` one float a texel, `width` across and `rows`
+ * down, spread into the red channel of a four-channel image the atlas's size, the rest ones. The
+ * cookie band is left zero for the backend to fill from its images.
+ */
+export declare function fixtureAtlasTexels(layout: FixtureAtlasLayout, ies: {
+    readonly data: Float32Array;
+    readonly width: number;
+    readonly height: number;
+}): Float32Array;

package/dist/render/fixtureAtlas.js

@@ -0,0 +1,49 @@
+/**
+ * What a light fixture throws, in one texture: its spot cookies in the top band, its photometric
+ * profiles in the rows below.
+ *
+ * **One binding for two tables, because the lit stage had one sampler left.** The cookie atlas and
+ * the photometric atlas were two small float textures read with `textureLod`, and the widest lit
+ * shader bound fifteen of the sixteen fragment samplers WebGL2 guarantees — so the next sampler had
+ * to be found by folding two into one, which is what this is. Both describe a fixture's emission
+ * pattern, and both are 128 texels across, which is what lets them share a texture exactly.
+ *
+ * **Cookies on top, profiles at the bottom, and the order is load-bearing.** A profile's row blend
+ * only ever reaches forward — to the next plane, and from the last to the repeat of the first — so
+ * past its last row it meets the texture's edge and the clamp, never a cookie. A cookie's own
+ * half-texel inset keeps it inside its band on both axes. The shader finds the bands from
+ * `textureSize` and `uIesAtlasRows`, so the fold cost no uniform.
+ *
+ * **What it gives up**: every texel is four half floats where a profile needed one, a few kilobytes
+ * a scene; and setting either table rebuilds the whole texture, which a consumer does once per set.
+ */
+import { IES_ATLAS_WIDTH } from './iesProfile.js';
+import { COOKIE_TILE } from './lightBudget.js';
+/** The atlas for `iesRows` rows of profile and `cookieTiles` cookies. */
+export function fixtureAtlasLayout(iesRows, cookieTiles) {
+    const cookieRows = cookieTiles > 0 ? COOKIE_TILE : 0;
+    return {
+        width: Math.max(IES_ATLAS_WIDTH, COOKIE_TILE * cookieTiles),
+        height: cookieRows + iesRows,
+        cookieRows,
+        iesTop: cookieRows,
+    };
+}
+/**
+ * The profiles' rows as the atlas holds them: `data` one float a texel, `width` across and `rows`
+ * down, spread into the red channel of a four-channel image the atlas's size, the rest ones. The
+ * cookie band is left zero for the backend to fill from its images.
+ */
+export function fixtureAtlasTexels(layout, ies) {
+    const out = new Float32Array(layout.width * layout.height * 4);
+    for (let row = 0; row < ies.height; row++) {
+        for (let x = 0; x < ies.width; x++) {
+            const at = ((layout.iesTop + row) * layout.width + x) * 4;
+            out[at] = ies.data[row * ies.width + x];
+            out[at + 1] = 1;
+            out[at + 2] = 1;
+            out[at + 3] = 1;
+        }
+    }
+    return out;
+}

package/dist/render/instanceCull.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Which instances of a batch can be seen: the decision both backends make, and the reference the
+ * WebGPU compute cull is held to.
+ *
+ * **An instance's bounds are the mesh's, placed by its matrix** — the mesh's bounding sphere with its
+ * centre through the model matrix and its radius scaled by the largest axis, exactly as
+ * `boundsVisible` treats one mesh — so a batch needs no bounds of its own and a caller supplies none.
+ * The test is `sphereInFrustum`'s: kept unless wholly beyond one plane.
+ *
+ * WebGL2 runs `cullInstances` on the CPU; WebGPU runs `CULL_INSTANCES_WGSL`, the same arithmetic, on
+ * the device. Both keep what this keeps: `gpu-parity.mjs` compares them on a device. What this gives
+ * up is shape: a long thin mesh is culled by the sphere around it, which keeps it in more views than
+ * its box would. What would make that wrong is a batch of long thin things seen end on, where a box
+ * test pays; nothing in the engine draws those instanced today.
+ *
+ * Per frame and allocation-free: everything writes into arrays the caller owns.
+ */
+import type { MeshInstances } from './instances.ts';
+import type { Bounds } from '../math/bounds.ts';
+import type { FrustumPlanes } from '../math/frustum.ts';
+/**
+ * Indices a culling batch must draw, all its instances together, before culling it instance by
+ * instance pays; below it the batch is drawn whole once its box is seen (`batchBoxVisible`).
+ *
+ * **What a per-instance cull costs is fixed a batch, and what it saves grows with the batch.** On
+ * WebGPU it is a dispatch and an indirect draw, and Chrome validates every indirect draw in its GPU
+ * process — measured at 8 µs apiece in a city frame whose six hundred small prop batches took one
+ * each, 52 fps against 70 with those draws gone. On WebGL2 it is a loop over the instances and an
+ * upload of the survivors. A few thousand indices cost a device less than either.
+ *
+ * What it gives up is the instances of a small batch that stand out of view once its box is in it,
+ * which the device transforms and clips for nothing. What would make it wrong is a device whose
+ * vertex stage limits the frame while the CPU idles — where this wants to come down.
+ */
+export declare const INSTANCE_CULL_MIN_INDICES: number;
+/**
+ * Whether a culling batch of `count` instances of a mesh of `indexCount` indices is culled instance
+ * by instance, or drawn whole once its box is seen. See `INSTANCE_CULL_MIN_INDICES`.
+ */
+export declare function cullsInstances(count: number, indexCount: number): boolean;
+/**
+ * Keep the instances of `data` whose spheres meet `frustum`, compacted in order into `out`, and
+ * return how many. `out` must hold as many as `data` does; its count is set.
+ */
+export declare function cullInstances(data: MeshInstances, local: Bounds, frustum: FrustumPlanes, out: MeshInstances): number;
+/**
+ * The world box around every instance's sphere, for testing a whole batch at once: (minX, minY,
+ * minZ, maxX, maxY, maxZ) into `out`. A batch holding nothing writes a min above its max.
+ *
+ * **A box, not a sphere, and the difference is the whole point for a flat batch.** A region of props
+ * a hundred metres square has a sphere seventy metres deep underground, where nothing occludes it,
+ * so a sphere test never finds a region hidden. The box stays as flat as the props are.
+ */
+export declare function instancesBox(data: MeshInstances, local: Bounds, out: Float32Array): void;
+/** What the batch test asks of an occlusion buffer. `OcclusionBuffer` and both renderers answer it. */
+export interface BoxOccluder {
+    occludedBox(min: ArrayLike<number>, max: ArrayLike<number>): boolean;
+}
+/**
+ * Whether a batch's box (`instancesBox`) can be seen at all: inside the frustum, and not behind the
+ * declared occluders. One test for a whole region's props, run before any instance is looked at.
+ */
+export declare function batchBoxVisible(box: Float32Array, frustum: FrustumPlanes, occluder: BoxOccluder | null): boolean;