@drawcall/lod 0.1.2 → 0.3.0

package/dist/index.js

@@ -1,16 +1,22 @@
-export { LodLoader } from "./loader.js";
-export { setViewportHeight } from "./view.js";
+export { LodLoader } from "./loader/index.js";
+export {} from "./loader/request.js";
+export {} from "./loader/cache.js";
+export { encodeMeshAsync, decodeMeshAsync } from "./codec/mesh.js";
+export { LodGpu } from "./gpu.js";
 export { Lod } from "./lod.js";
-export { LazyImpostor } from "./lazy.js";
-export { cachedImpostor } from "./impostor/cache.js";
 export { Wind } from "./wind/index.js";
 export { InstancedLod } from "./instanced/index.js";
-export {} from "./levels.js";
-export { simplify } from "./simplify.js";
+export {} from "./instanced/cull.js";
+export { InstancedLodChunk } from "./instanced/chunk.js";
+export {} from "./instanced/raycast.js";
+export {} from "./levels/index.js";
+export { simplify } from "./simplify/index.js";
 export { bakeMesh } from "./baked/index.js";
-export { encodeBakedMesh, decodeBakedMesh } from "./baked/codec.js";
+export { encodeBakedMeshAsync, decodeBakedMeshAsync } from "./baked/codec.js";
 export { bakeImpostor } from "./impostor/bake/index.js";
+export { createBakeRenderer } from "./bake.js";
 export { ImpostorMesh } from "./impostor/mesh/index.js";
+export { cosine } from "./impostor/mesh/surface.js";
 export {} from "./impostor/impostor.js";
-export { decodeImpostor, decodeImpostorAsync, encodeImpostor } from "./impostor/codec.js";
+export { encodeImpostorAsync, decodeImpostorAsync } from "./impostor/codec.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4D,SAAS,EAAE,MAAM,aAAa,CAAC;AAClG,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,YAAY,EAA4B,MAAM,WAAW,CAAC;AACnE,OAAO,EAAE,cAAc,EAA6B,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,IAAI,EAAsC,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAiB,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAwB,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAwB,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAA4B,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAClF,OAAO,EAA4B,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAClF,OAAO,EAAwD,MAAM,wBAAwB,CAAC;AAC9F,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAyC,MAAM,qBAAqB,CAAC;AAC5E,OAAO,EAAwB,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,MAAM,EAAsB,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,GAAG,EAAmB,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,IAAI,EAAsC,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAA4B,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAqB,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,iBAAiB,EAAoC,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EAAiC,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAiB,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAwB,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAwB,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EAA4B,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAA4B,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAClF,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAwD,MAAM,wBAAwB,CAAC;AAC9F,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/instanced/camera.d.ts

@@ -0,0 +1,46 @@
+import { Matrix4, type Camera, type Vector3 } from "three/webgpu";
+import type { d } from "typegpu";
+import type { EncodedLevels } from "../levels/index.js";
+import type { DrawLevels } from "../levels/draw.js";
+import type { ChunkSet } from "./chunks.js";
+import type { Cull } from "./cull.js";
+import type { CameraLists } from "./lists.js";
+import type { InstanceShape } from "./shape.js";
+/** A camera in an InstancedLod's space (see `localCamera`). */
+export interface LocalCamera {
+    levels: d.Infer<typeof DrawLevels>;
+    eye: Vector3;
+    /** Pixels per unit of subtense (or of size, orthographic). */
+    scale: number;
+    ortho: boolean;
+}
+/** The level loading state levelsToDraw reads (see LodLevelLoadManager). */
+export interface Loading {
+    loaded: number;
+    before: number;
+    progress: number;
+}
+/**
+ * `camera`, drawing into a target `height` pixels tall (see screenOf), in the space of `space`, an InstancedLod's world matrix: the
+ * levels of `encoded` as levelsToDraw reads them for it, `forced` drawn alone if not null, where it looks from and its
+ * pixels per unit.
+ */
+export declare function localCamera(camera: Camera, height: number, space: Matrix4, encoded: EncodedLevels, forced: number | null): LocalCamera;
+/**
+ * Work out into `found`, a camera's lists, the heights `chunks`' instances can have on its screen and the levels it
+ * needs loaded for them, in one walk of the chunks, only once what that reads changed.
+ */
+export declare function walk(found: CameraLists, { levels, eye, scale, ortho, cull }: LocalCamera & {
+    cull: Cull | null;
+}, { chunks, shape, encoded }: {
+    chunks: ChunkSet;
+    shape: InstanceShape;
+    encoded: EncodedLevels;
+}): void;
+/**
+ * The levels whose meshes draw for the camera of `found` with what is loaded: those levelsToDraw draws at a height
+ * some chunk's instances can have, with the levels of `loaded`, and while an arrival is under way those of `before`
+ * too, as levelsToDraw draws only what one or the other draws until the arrival ends. Sets `found.onlyLevel` too.
+ * Worked out again only once what that reads changed.
+ */
+export declare function shownBy(found: CameraLists, levels: LocalCamera["levels"], encoded: EncodedLevels, { loaded, before, progress }: Loading): number;

package/dist/instanced/camera.js

@@ -0,0 +1,70 @@
+import { Matrix4 } from "three/webgpu";
+import { levelsToLoad } from "../levels/load.js";
+import { screenOf } from "../levels/screen.js";
+import { Lod } from "../lod.js";
+/** How much wider than ChunkSet.heights gives them the heights a level mesh is shown for are, relatively. */
+const SLACK = 1e-4;
+const inverse = new Matrix4();
+/**
+ * `camera`, drawing into a target `height` pixels tall (see screenOf), in the space of `space`, an InstancedLod's world matrix: the
+ * levels of `encoded` as levelsToDraw reads them for it, `forced` drawn alone if not null, where it looks from and its
+ * pixels per unit.
+ */
+export function localCamera(camera, height, space, encoded, forced) {
+    const screen = screenOf(camera, height);
+    // Checked before anything reads the thresholds.
+    const levels = encoded.get(forced, !screen.ortho);
+    const eye = screen.eye.applyMatrix4(inverse.copy(space).invert());
+    // Heights are measured in the InstancedLod's space: an orthographic camera's size scales with it.
+    const scale = screen.scale * Lod.quality * (screen.ortho ? space.getMaxScaleOnAxis() : 1);
+    return { levels, eye, scale, ortho: screen.ortho };
+}
+/**
+ * Work out into `found`, a camera's lists, the heights `chunks`' instances can have on its screen and the levels it
+ * needs loaded for them, in one walk of the chunks, only once what that reads changed.
+ */
+export function walk(found, { levels, eye, scale, ortho, cull }, { chunks, shape, encoded }) {
+    const key = found.heightsKey.start();
+    // An orthographic camera measures heights alike from anywhere.
+    if (!ortho)
+        key.put(eye.x).put(eye.y).put(eye.z);
+    if (!key.screen(scale, ortho, levels, cull, shape.source).put(chunks.version).end())
+        return;
+    found.heights = Array.from(chunks.heights(shape.source, eye, scale, ortho, cull));
+    found.wanted = levelsToLoad(found.heights, encoded.heights(levels));
+    found.heightsVersion++;
+}
+/**
+ * The levels whose meshes draw for the camera of `found` with what is loaded: those levelsToDraw draws at a height
+ * some chunk's instances can have, with the levels of `loaded`, and while an arrival is under way those of `before`
+ * too, as levelsToDraw draws only what one or the other draws until the arrival ends. Sets `found.onlyLevel` too.
+ * Worked out again only once what that reads changed.
+ */
+export function shownBy(found, levels, encoded, { loaded, before, progress }) {
+    const arriving = progress < 1 && before !== loaded;
+    if (!found.shownKey
+        .start()
+        .put(found.heightsVersion)
+        .put(loaded)
+        .put(arriving ? before : loaded)
+        .end())
+        return found.shown;
+    const now = encoded.heights(levels, loaded);
+    const then = arriving ? encoded.heights(levels, before) : null;
+    let shown = 0;
+    // What every chunk draws.
+    let common = found.heights.length > 0 ? ~0 : 0;
+    for (const [shortest, tallest] of found.heights) {
+        // The GPU measures an instance's height in f32: a range a little wider holds every height it gets.
+        const low = shortest * (1 - SLACK);
+        const high = tallest * (1 + SLACK);
+        const drawn = now.drawnIn(low, high) | (then?.drawnIn(low, high) ?? 0);
+        shown |= drawn;
+        common &= drawn;
+    }
+    found.shown = shown;
+    // One level alone: drawnIn holds a fading level's finer neighbour too.
+    found.onlyLevel = !arriving && common === shown && (shown & (shown - 1)) === 0 ? shown : 0;
+    return shown;
+}
+//# sourceMappingURL=camera.js.map

package/dist/instanced/camera.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.js","sourceRoot":"","sources":["../../src/instanced/camera.ts"],"names":[],"mappings":"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"}

package/dist/instanced/chunk.d.ts

@@ -0,0 +1,97 @@
+import { Box3, type Camera, type Color, type InstancedBufferAttribute, Matrix4, type StorageBufferAttribute, type StorageInstancedBufferAttribute } from "three/webgpu";
+/** The instances of a chunk to add (see `InstancedLod.addChunk`), as an InstancedMesh holds its own. */
+export interface InstancedLodChunkParameters {
+    /**
+     * 16 floats per instance, as InstancedMesh.instanceMatrix holds them. From the CPU, an InstancedBufferAttribute that
+     * stays live as an InstancedMesh's does: edit it (see `setMatrixAt`) and set `needsUpdate` (after `addUpdateRange`
+     * to upload part of it), and the next render takes the change in. The InstancedLod takes and clears its update
+     * ranges, so an InstancedMesh also drawing it uploads it whole. From the GPU, a StorageInstancedBufferAttribute an
+     * app's pass writes (such as `instancedArray(n, "mat4")`), read once, in the first render that updates the
+     * InstancedLod (see `InstancedLod.update`): the app may reuse it after that render. A matrix of scale 0 is no
+     * instance.
+     */
+    instanceMatrix: InstancedBufferAttribute | StorageInstancedBufferAttribute;
+    /**
+     * RGB floats per instance, as InstancedMesh.instanceColor holds them, of the same kind as `instanceMatrix`, live or
+     * read once as it is, its update ranges taken alike; white without.
+     */
+    instanceColor?: InstancedBufferAttribute | StorageInstancedBufferAttribute;
+    /** The first instance of the attributes to read, and how many: the whole attributes by default, as a drawRange. */
+    start?: number;
+    count?: number;
+    /**
+     * From the GPU only: a u32 storage attribute (such as `attributeArray(n, "uint")`) whose item `instanceCountIndex`
+     * the app's pass wrote, at most `count`, as drawIndirect's instanceCount: only that many are read. Without it all
+     * `count` are.
+     */
+    instanceCount?: StorageBufferAttribute | StorageInstancedBufferAttribute;
+    instanceCountIndex?: number;
+    /**
+     * From the GPU, required, as the CPU cannot measure the GPU's instances; from the CPU, measured, so not given: a box
+     * holding every instance's origin (its matrix's translation) in the InstancedLod's space, and bounds on how much
+     * the matrices scale: none shorter than `minScale` along its longest axis, none stretching any direction more than
+     * `maxScale`. Which levels load is judged by them.
+     */
+    originBox?: Box3;
+    minScale?: number;
+    maxScale?: number;
+}
+/**
+ * What an InstancedLod keeps of one of its chunks, which the chunk shows: its bounds, re-measured as its CPU attributes
+ * change, and how it finds the level an instance draws, while the InstancedLod holds it.
+ */
+export interface ChunkState {
+    /** Whether its attributes are the GPU's, told once: binding a CPU attribute through storage() flags it as storage. */
+    readonly gpu: boolean;
+    readonly originBox: Box3;
+    minScale: number;
+    maxScale: number;
+    readonly boundingBox: Box3;
+    levelAt: ((index: number, camera: Camera) => number | null) | null;
+}
+/**
+ * Instances added to an InstancedLod in one call and removed whole (see `InstancedLod.addChunk`). An instance's index
+ * is its index in the chunk's range of its attributes, stable while other chunks come and go. The methods reading or
+ * writing instances work for a chunk from the CPU only: a GPU chunk's instances live on the GPU, and its methods throw.
+ */
+export declare class InstancedLodChunk {
+    private readonly state;
+    readonly instanceMatrix: InstancedBufferAttribute | StorageInstancedBufferAttribute;
+    readonly instanceColor: InstancedBufferAttribute | StorageInstancedBufferAttribute | null;
+    readonly start: number;
+    readonly count: number;
+    readonly instanceCount: StorageBufferAttribute | StorageInstancedBufferAttribute | null;
+    readonly instanceCountIndex: number;
+    /** Made by `InstancedLod.addChunk`. */
+    constructor(parameters: InstancedLodChunkParameters, state: ChunkState);
+    /** Holds every instance's origin, in the InstancedLod's space: given for a GPU chunk, measured for a CPU one. */
+    get originBox(): Box3;
+    /** No matrix scales its longest axis less: given for a GPU chunk, measured for a CPU one. */
+    get minScale(): number;
+    /** No matrix stretches any direction more: given for a GPU chunk, measured for a CPU one. */
+    get maxScale(): number;
+    /**
+     * Bounds every instance's every level, swaying included, in the InstancedLod's space: the box of its origins grown
+     * by the largest level.
+     */
+    get boundingBox(): Box3;
+    /** Write instance `index`'s matrix into `instanceMatrix`; set its `needsUpdate` to draw it. */
+    setMatrixAt(index: number, value: Matrix4): void;
+    getMatrixAt(index: number, target: Matrix4): Matrix4;
+    /** Write instance `index`'s colour into `instanceColor`; set its `needsUpdate` to draw it. */
+    setColorAt(index: number, color: Color): void;
+    /** Instance `index`'s colour: white without `instanceColor`. */
+    getColorAt(index: number, color: Color): Color;
+    /**
+     * The level that draws most of instance `index`'s pixels for `camera` from where it is now, with the levels loaded
+     * now and no arrival under way, as Lod.getLevel tells; null at scale 0, thinned out by `cullDistance`, or while no
+     * level it could draw is loaded. From the attributes as they are, edits not yet drawn included. It throws for every
+     * instance while `cullDistance` or the thresholds are invalid.
+     */
+    getLevelAt(index: number, camera: Camera): number | null;
+    /** This chunk, whose instances the CPU holds, after checking `index` is one of them. */
+    private cpu;
+    private colors;
+}
+/** Measure into `state` the origins and scales of `chunk`'s instances at a scale above 0, from its CPU attributes. */
+export declare function measureChunk(chunk: InstancedLodChunk, state: ChunkState): void;

package/dist/instanced/chunk.js

@@ -0,0 +1,156 @@
+import { Box3, Matrix4, Vector3, } from "three/webgpu";
+import { isStorageInstanced, stretch } from "../three.js";
+const matrix = new Matrix4();
+const origin = new Vector3();
+/**
+ * Instances added to an InstancedLod in one call and removed whole (see `InstancedLod.addChunk`). An instance's index
+ * is its index in the chunk's range of its attributes, stable while other chunks come and go. The methods reading or
+ * writing instances work for a chunk from the CPU only: a GPU chunk's instances live on the GPU, and its methods throw.
+ */
+export class InstancedLodChunk {
+    state;
+    instanceMatrix;
+    instanceColor;
+    start;
+    count;
+    instanceCount;
+    instanceCountIndex;
+    /** Made by `InstancedLod.addChunk`. */
+    constructor(parameters, state) {
+        this.state = state;
+        const { instanceMatrix, instanceColor = null, instanceCount = null, instanceCountIndex = 0 } = parameters;
+        const { gpu } = state;
+        if (isStorageInstanced(instanceMatrix) !== gpu)
+            throw new Error("InstancedLod: a chunk's state is of another kind than its instanceMatrix");
+        const { start = 0, count = instanceMatrix.count - start } = parameters;
+        if (instanceMatrix.itemSize !== 16)
+            throw new TypeError(`InstancedLod: a chunk's instanceMatrix holds 16 floats per instance, not ${instanceMatrix.itemSize}`);
+        if (!(instanceMatrix.array instanceof Float32Array) || instanceMatrix.normalized)
+            throw new TypeError("InstancedLod: a chunk's instanceMatrix holds floats, not normalized");
+        if (!Number.isInteger(start) || !Number.isInteger(count) || start < 0 || count < 0 || start + count > instanceMatrix.count)
+            throw new RangeError(`InstancedLod: a chunk's range of ${count} from ${start} passes the ${instanceMatrix.count} instances of its instanceMatrix`);
+        if (instanceColor) {
+            if (isStorageInstanced(instanceColor) !== gpu)
+                throw new TypeError("InstancedLod: a chunk's instanceColor is of another kind than its instanceMatrix");
+            // A storage attribute's vec3 is padded to four floats once on the GPU.
+            if (instanceColor.itemSize !== 3 && !(gpu && instanceColor.itemSize === 4))
+                throw new TypeError(`InstancedLod: a chunk's instanceColor holds RGB per instance, not ${instanceColor.itemSize} floats`);
+            if (!(instanceColor.array instanceof Float32Array) || instanceColor.normalized)
+                throw new TypeError("InstancedLod: a chunk's instanceColor holds floats, not normalized");
+            if (instanceColor.count < start + count)
+                throw new RangeError("InstancedLod: a chunk's instanceColor holds fewer instances than its range");
+        }
+        if (instanceCount) {
+            if (!gpu)
+                throw new TypeError("InstancedLod: only a GPU chunk takes an instanceCount");
+            if (!(instanceCount.array instanceof Uint32Array) || instanceCount.itemSize !== 1)
+                throw new TypeError("InstancedLod: a chunk's instanceCount holds u32 items");
+            if (!Number.isInteger(instanceCountIndex) || instanceCountIndex < 0 || instanceCountIndex >= instanceCount.count)
+                throw new RangeError(`InstancedLod: a chunk's instanceCountIndex ${instanceCountIndex} passes the end of its instanceCount`);
+        }
+        const { originBox, minScale, maxScale } = parameters;
+        const given = originBox !== undefined || minScale !== undefined || maxScale !== undefined;
+        if (gpu && (!originBox || minScale === undefined || maxScale === undefined))
+            throw new TypeError("InstancedLod: a GPU chunk needs its originBox, minScale and maxScale: the CPU cannot measure the GPU's instances");
+        if (!gpu && given)
+            throw new TypeError("InstancedLod: a CPU chunk's originBox, minScale and maxScale are measured from its instances, not given");
+        if (originBox && minScale !== undefined && maxScale !== undefined) {
+            if (!(minScale > 0 && minScale <= maxScale && Number.isFinite(maxScale)))
+                throw new RangeError(`InstancedLod: a chunk's scales must be 0 < minScale <= maxScale, got ${minScale}, ${maxScale}`);
+            if (originBox.isEmpty() || ![...originBox.min.toArray(), ...originBox.max.toArray()].every(Number.isFinite))
+                throw new RangeError("InstancedLod: a chunk's originBox must be finite and not empty");
+            state.originBox.copy(originBox);
+            state.minScale = minScale;
+            state.maxScale = maxScale;
+        }
+        this.instanceMatrix = instanceMatrix;
+        this.instanceColor = instanceColor;
+        this.start = start;
+        this.count = count;
+        this.instanceCount = instanceCount;
+        this.instanceCountIndex = instanceCountIndex;
+        if (!gpu)
+            measureChunk(this, state);
+    }
+    /** Holds every instance's origin, in the InstancedLod's space: given for a GPU chunk, measured for a CPU one. */
+    get originBox() {
+        return this.state.originBox;
+    }
+    /** No matrix scales its longest axis less: given for a GPU chunk, measured for a CPU one. */
+    get minScale() {
+        return this.state.minScale;
+    }
+    /** No matrix stretches any direction more: given for a GPU chunk, measured for a CPU one. */
+    get maxScale() {
+        return this.state.maxScale;
+    }
+    /**
+     * Bounds every instance's every level, swaying included, in the InstancedLod's space: the box of its origins grown
+     * by the largest level.
+     */
+    get boundingBox() {
+        return this.state.boundingBox;
+    }
+    /** Write instance `index`'s matrix into `instanceMatrix`; set its `needsUpdate` to draw it. */
+    setMatrixAt(index, value) {
+        value.toArray(this.cpu(index).instanceMatrix.array, (this.start + index) * 16);
+    }
+    getMatrixAt(index, target) {
+        return target.fromArray(this.cpu(index).instanceMatrix.array, (this.start + index) * 16);
+    }
+    /** Write instance `index`'s colour into `instanceColor`; set its `needsUpdate` to draw it. */
+    setColorAt(index, color) {
+        color.toArray(this.colors(index).array, (this.start + index) * 3);
+    }
+    /** Instance `index`'s colour: white without `instanceColor`. */
+    getColorAt(index, color) {
+        const { instanceColor } = this.cpu(index);
+        return instanceColor ? color.fromArray(instanceColor.array, (this.start + index) * 3) : color.setRGB(1, 1, 1);
+    }
+    /**
+     * The level that draws most of instance `index`'s pixels for `camera` from where it is now, with the levels loaded
+     * now and no arrival under way, as Lod.getLevel tells; null at scale 0, thinned out by `cullDistance`, or while no
+     * level it could draw is loaded. From the attributes as they are, edits not yet drawn included. It throws for every
+     * instance while `cullDistance` or the thresholds are invalid.
+     */
+    getLevelAt(index, camera) {
+        const { levelAt } = this.state;
+        if (!levelAt)
+            throw new Error("InstancedLod: the chunk was removed from its InstancedLod");
+        this.cpu(index);
+        return levelAt(index, camera);
+    }
+    /** This chunk, whose instances the CPU holds, after checking `index` is one of them. */
+    cpu(index) {
+        if (this.state.gpu)
+            throw new Error("InstancedLod: a GPU chunk's instances live on the GPU: the CPU cannot read or write them");
+        if (!Number.isInteger(index) || index < 0 || index >= this.count)
+            throw new RangeError(`InstancedLod: ${index} is not an instance of the chunk's ${this.count}`);
+        return this;
+    }
+    colors(index) {
+        const { instanceColor } = this.cpu(index);
+        if (!instanceColor)
+            throw new Error("InstancedLod: give the chunk an instanceColor to colour its instances");
+        return instanceColor;
+    }
+}
+/** Measure into `state` the origins and scales of `chunk`'s instances at a scale above 0, from its CPU attributes. */
+export function measureChunk(chunk, state) {
+    const { array } = chunk.instanceMatrix;
+    state.originBox.makeEmpty();
+    state.minScale = Infinity;
+    state.maxScale = 0;
+    for (let i = chunk.start; i < chunk.start + chunk.count; i++) {
+        matrix.fromArray(array, i * 16);
+        const scale = matrix.getMaxScaleOnAxis();
+        if (scale === 0)
+            continue;
+        state.originBox.expandByPoint(origin.setFromMatrixPosition(matrix));
+        state.minScale = Math.min(state.minScale, scale);
+        state.maxScale = Math.max(state.maxScale, stretch(matrix));
+    }
+    if (state.originBox.isEmpty())
+        state.minScale = state.maxScale = 0;
+}
+//# sourceMappingURL=chunk.js.map

package/dist/instanced/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sourceRoot":"","sources":["../../src/instanced/chunk.ts"],"names":[],"mappings":"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"}

package/dist/instanced/chunks.d.ts

@@ -0,0 +1,60 @@
+import { Box3, type Camera, type Sphere, type Vector3 } from "three/webgpu";
+import { InstancedLodChunk, type InstancedLodChunkParameters } from "./chunk.js";
+import type { Cull } from "./cull.js";
+import type { InstancePagePool } from "./pages/index.js";
+/**
+ * The chunks of one InstancedLod: their pool slots, the mirrors the pool reads CPU attributes through, and their
+ * bounds, which load levels and cull the level meshes.
+ */
+export declare class ChunkSet {
+    private readonly pool;
+    private readonly row;
+    private readonly bounds;
+    private readonly reach;
+    private readonly levelAt;
+    private readonly held;
+    private readonly mirrors;
+    /** Bumped whenever a chunk was added, removed or re-measured: what `heights` reads changed. */
+    version: number;
+    /**
+     * Chunks over `pool`, for the InstancedLod sorting as row `row`, whose instances `bounds` bounds in the InstancedLod's space; `reach` tells how far from an
+     * instance's origin, in its space, every level and its sway reach, and `levelAt` is what a chunk's getLevelAt asks.
+     */
+    constructor(pool: InstancePagePool, row: number, bounds: {
+        readonly sphere: Sphere;
+        readonly box: Box3;
+    }, reach: () => number, levelAt: (chunk: InstancedLodChunk, index: number, camera: Camera) => number | null);
+    get size(): number;
+    /** The chunks, in the order they were added. */
+    keys(): IterableIterator<InstancedLodChunk>;
+    /** The pool slots of the chunks. */
+    slots(): number[];
+    /** The chunks whose instances the CPU holds. */
+    cpu(): InstancedLodChunk[];
+    /**
+     * What makes chunks of their own with every chunk's instances, their attributes copied (see `InstancedLod.copy`). A
+     * GPU chunk cannot be copied: its instances live on the GPU.
+     */
+    copies(): InstancedLodChunkParameters[];
+    /** Hold `parameters`' instances as a chunk, copied into the pool at its next run; `bound` bounds it. */
+    add(parameters: InstancedLodChunkParameters): InstancedLodChunk;
+    /** Let go of `chunk`; its pages return to the pool at its next run. */
+    remove(chunk: InstancedLodChunk): void;
+    /**
+     * Take in the CPU attributes' edits, those whose versions moved, for every chunk reading them: re-measured, and
+     * copied into the pool again at its next run. Whether any changed; `bound` bounds them.
+     */
+    refresh(): boolean;
+    /** Bound every chunk, its box (see `InstancedLodChunk.boundingBox`), and all of them, survivors grown by up to `grow`. */
+    bound(grow: number): void;
+    /**
+     * The heights on a screen of `scale` from `eye`, both in the InstancedLod's space, that each chunk's instances can
+     * have, `source` an instance's source sphere: its shortest instance at its farthest, its tallest at its nearest.
+     */
+    heights(source: Sphere, eye: Vector3, scale: number, ortho: boolean, cull: Cull | null): Generator<[number, number]>;
+    /** Free the chunks' slots and release the mirrors; the chunks no longer find their levels. */
+    dispose(): void;
+    /** The mirror of `attribute`, which `chunk` reads too. */
+    private mirror;
+    private heldOf;
+}