@drawcall/lod 0.2.0 → 0.4.0

package/dist/levels/renderer.js

@@ -0,0 +1,57 @@
+import { isScene, isShadowPass } from "../three.js";
+// What a Lod learns of the renderer drawing it, and when. three r186 shows much of it through no public API: each
+// read of one of its private fields below says why none serves.
+/**
+ * How deep in renders `renderer` is: -1 outside them, 0 in a render of its own, 1 in one it draws inside another, as it
+ * draws shadow maps and post-processing. Read from r186's `_callDepth`: three keeps a draw's built shader per depth,
+ * and no public API tells which.
+ */
+export function callDepth(renderer) {
+    const depth = Reflect.get(renderer, "_callDepth");
+    if (typeof depth !== "number")
+        throw new Error("Lod: three's renderer keeps no call depth (lod mirrors three r186)");
+    return depth;
+}
+/**
+ * Whether `renderer` is rendering or compiling now, as it is while it updates what it draws; not while an app calls
+ * `update` itself or another renderer draws. A compile is told by r186's `_compilationPromises`, which no public API
+ * shows.
+ */
+export const busy = (renderer) => callDepth(renderer) >= 0 || Reflect.get(renderer, "_compilationPromises") != null;
+/**
+ * Throws unless `renderer` can draw a Lod, `who`: three's WebGPU backend, whose device has indirect-first-instance, as
+ * each level's draws start at its list (see update.ts).
+ */
+export function checkRenderer(renderer, who) {
+    if (Reflect.get(renderer.backend, "isWebGPUBackend") !== true)
+        throw new Error(`${who}: draws with WebGPU only, but its renderer runs another backend (WebGPURenderer falls back to WebGL2 where WebGPU is missing)`);
+    if (!renderer.hasFeature("indirect-first-instance"))
+        throw new Error(`${who}: needs the GPU feature indirect-first-instance, which this device lacks`);
+}
+/** The largest storage binding `renderer`'s device takes: r186's WebGPU backend's `device`, which three's types omit. */
+export function maxStorageBinding(renderer) {
+    const device = Reflect.get(renderer.backend, "device");
+    const limits = typeof device === "object" && device !== null ? Reflect.get(device, "limits") : null;
+    const size = typeof limits === "object" && limits !== null ? Reflect.get(limits, "maxStorageBufferBindingSize") : null;
+    if (typeof size !== "number")
+        throw new Error("Lod: its renderer has no WebGPU device (lod mirrors three r186)");
+    return size;
+}
+/**
+ * Whether the scene `node` is in is being drawn into a shadow map: three's shadow map render
+ * draws it with its own override material, and calls `update` on every LOD with the
+ * light's camera, which must not switch the levels the scene's camera chose.
+ */
+export function inShadowMap(node) {
+    for (let scene = node; scene; scene = scene.parent)
+        if (isScene(scene) && isShadowPass(scene.overrideMaterial))
+            return true;
+    return false;
+}
+/**
+ * Whether `target` is the framebuffer target r186 draws the canvas (or output target) through when tone mapping or
+ * the output colour space needs a final pass. A draw meant for the output sees it as the active target; a compile for
+ * the output leaves the target unset and lets three resolve it.
+ */
+export const isOutputPass = (target) => typeof target === "object" && target !== null && Reflect.get(target, "isPostProcessingRenderTarget") === true;
+//# sourceMappingURL=renderer.js.map

package/dist/levels/renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../../src/levels/renderer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEpD,kHAAkH;AAClH,gEAAgE;AAEhE;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,QAAkB;IAC1C,MAAM,KAAK,GAAY,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;IAC3D,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;IACrH,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,QAAkB,EAAW,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,sBAAsB,CAAC,IAAI,IAAI,CAAC;AAEvI;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,QAAkB,EAAE,GAAW;IAC3D,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC,KAAK,IAAI;QAC3D,MAAM,IAAI,KAAK,CAAC,GAAG,GAAG,+HAA+H,CAAC,CAAC;IACzJ,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,yBAAyB,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,GAAG,GAAG,0EAA0E,CAAC,CAAC;AACzJ,CAAC;AAED,yHAAyH;AACzH,MAAM,UAAU,iBAAiB,CAAC,QAAkB;IAClD,MAAM,MAAM,GAAY,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;IAChE,MAAM,MAAM,GAAY,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC7G,MAAM,IAAI,GAAY,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAChI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;IACjH,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,IAAc;IACxC,KAAK,IAAI,KAAK,GAAoB,IAAI,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM;QAAE,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,KAAK,CAAC,gBAAgB,CAAC;YAAE,OAAO,IAAI,CAAC;IAC7I,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,MAAe,EAAW,EAAE,CACvD,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,8BAA8B,CAAC,KAAK,IAAI,CAAC"}

package/dist/levels/requests.d.ts

@@ -0,0 +1,52 @@
+import type { Camera, Renderer, Scene } from "three/webgpu";
+import type { CameraRenders } from "./cameras.js";
+/**
+ * What the cameras rendering a Lod asked of it: per camera the levels it wants, and whether it still renders the Lod.
+ * The renderer's updates of the Lod are counted in rounds: a round ends when a camera updates it a second time, so a
+ * round holds one update by each camera that renders it once a frame, whatever their order. Shadow maps do not count.
+ */
+export declare class CameraRequests {
+    /** The renderer drawing the Lod. */
+    private readonly renderer;
+    /** What renders told of the cameras that drew the Lod. */
+    private readonly seen;
+    /** The frame a camera, not a shadow map's, last updated the Lod in. */
+    cameraFrame: number | null;
+    /** The cameras still rendering the Lod (see `fresh`), and what they asked for. */
+    private readonly requests;
+    private round;
+    /** The cameras that updated the Lod in the round under way. */
+    private readonly inRound;
+    constructor(
+    /** The renderer drawing the Lod. */
+    renderer: Renderer, 
+    /** What renders told of the cameras that drew the Lod. */
+    seen: CameraRenders);
+    /**
+     * `camera`, a shadow map's when `shadow`, rendering `scene`, wants the levels of the bits `wanted`: note it, drop the
+     * cameras that stopped rendering the Lod, and answer the renderer's frame.
+     */
+    set(scene: Scene, camera: Camera, wanted: number, shadow: boolean): number;
+    /** Note what a render of `scene` with `camera` tells: nothing outside the renderer's renders. */
+    private see;
+    /** The cameras still rendering the Lod. */
+    cameras(): Camera[];
+    /**
+     * The bits of the levels wanted by the cameras still rendering the Lod (see `rendering`): each camera that renders
+     * the scene once a frame counts, whatever their order, and one that stopped rendering it drops out.
+     */
+    needed(): number;
+    /**
+     * Whether `camera` still renders the Lod: it updated it in the current or last round, or it is a shadow map's whose
+     * target is not disposed (see `fresh`).
+     */
+    rendering(camera: Camera): boolean;
+    /**
+     * Whether `camera`'s `request` still counts: made in the current or last round, or a shadow map's while its map's
+     * target is not disposed, as the scene's cameras draw what its last update filled however seldom it is redrawn
+     * (three redraws a map whose `autoUpdate` is off only when asked). A shadow map's made this frame counts too, before
+     * a render notes its target: three draws a map at most once a frame, so a camera rendered again in the frame draws
+     * the map the update filled.
+     */
+    private fresh;
+}

package/dist/levels/requests.js

@@ -0,0 +1,97 @@
+import { busy, inShadowMap } from "./renderer.js";
+/**
+ * What the cameras rendering a Lod asked of it: per camera the levels it wants, and whether it still renders the Lod.
+ * The renderer's updates of the Lod are counted in rounds: a round ends when a camera updates it a second time, so a
+ * round holds one update by each camera that renders it once a frame, whatever their order. Shadow maps do not count.
+ */
+export class CameraRequests {
+    renderer;
+    seen;
+    /** The frame a camera, not a shadow map's, last updated the Lod in. */
+    cameraFrame = null;
+    /** The cameras still rendering the Lod (see `fresh`), and what they asked for. */
+    requests = new Map();
+    round = 0;
+    /** The cameras that updated the Lod in the round under way. */
+    inRound = new Set();
+    constructor(
+    /** The renderer drawing the Lod. */
+    renderer, 
+    /** What renders told of the cameras that drew the Lod. */
+    seen) {
+        this.renderer = renderer;
+        this.seen = seen;
+    }
+    /**
+     * `camera`, a shadow map's when `shadow`, rendering `scene`, wants the levels of the bits `wanted`: note it, drop the
+     * cameras that stopped rendering the Lod, and answer the renderer's frame.
+     */
+    set(scene, camera, wanted, shadow) {
+        this.see(scene, camera);
+        for (const [other, request] of this.requests)
+            if (!this.fresh(other, request))
+                this.requests.delete(other);
+        let request = this.requests.get(camera);
+        if (!request)
+            this.requests.set(camera, (request = { levels: 0, round: this.round, frame: null }));
+        request.round = this.round;
+        const frame = this.renderer.info.frame;
+        request.frame = shadow ? frame : null;
+        if (!shadow)
+            this.cameraFrame = frame;
+        request.levels = wanted;
+        return frame;
+    }
+    /** Note what a render of `scene` with `camera` tells: nothing outside the renderer's renders. */
+    see(scene, camera) {
+        const { renderer } = this;
+        if (!busy(renderer))
+            return;
+        this.seen.note(renderer, scene, camera);
+        if (inShadowMap(scene))
+            return;
+        if (this.inRound.has(camera)) {
+            this.round++;
+            this.inRound.clear();
+        }
+        this.inRound.add(camera);
+    }
+    /** The cameras still rendering the Lod. */
+    cameras() {
+        return [...this.requests].flatMap(([camera, request]) => (this.fresh(camera, request) ? [camera] : []));
+    }
+    /**
+     * The bits of the levels wanted by the cameras still rendering the Lod (see `rendering`): each camera that renders
+     * the scene once a frame counts, whatever their order, and one that stopped rendering it drops out.
+     */
+    needed() {
+        let bits = 0;
+        for (const [camera, request] of this.requests)
+            if (this.fresh(camera, request))
+                bits |= request.levels;
+        return bits;
+    }
+    /**
+     * Whether `camera` still renders the Lod: it updated it in the current or last round, or it is a shadow map's whose
+     * target is not disposed (see `fresh`).
+     */
+    rendering(camera) {
+        const request = this.requests.get(camera);
+        return request !== undefined && this.fresh(camera, request);
+    }
+    /**
+     * Whether `camera`'s `request` still counts: made in the current or last round, or a shadow map's while its map's
+     * target is not disposed, as the scene's cameras draw what its last update filled however seldom it is redrawn
+     * (three redraws a map whose `autoUpdate` is off only when asked). A shadow map's made this frame counts too, before
+     * a render notes its target: three draws a map at most once a frame, so a camera rendered again in the frame draws
+     * the map the update filled.
+     */
+    fresh(camera, request) {
+        if (request.round >= this.round - 1)
+            return true;
+        if (request.frame === null)
+            return false;
+        return request.frame === this.renderer.info.frame || this.seen.drawsShadowMap(camera);
+    }
+}
+//# sourceMappingURL=requests.js.map

package/dist/levels/requests.js.map

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

package/dist/levels/screen.d.ts

@@ -0,0 +1,14 @@
+import { Vector3, type Camera, type Matrix4, type Sphere } from "three/webgpu";
+/** How a camera measures heights: from where, and pixels per unit of subtense (perspective) or of size (orthographic). */
+export interface Screen {
+    readonly eye: Vector3;
+    ortho: boolean;
+    scale: number;
+}
+/** `camera`'s screen at `height`, the one it draws at, into `out`. */
+export declare function screenOf(camera: Camera, height: number, out?: Screen): Screen;
+/**
+ * The height on `screen` of `sphere`, given in the space `root` maps to world: its diameter, scaled by the largest axis
+ * scale of `root`, over its distance (small-angle), or its diameter alone in an orthographic camera.
+ */
+export declare function screenHeight(sphere: Sphere, root: Matrix4, screen: Screen): number;

package/dist/levels/screen.js

@@ -0,0 +1,21 @@
+import { Vector3 } from "three/webgpu";
+/** `camera`'s screen at `height`, the one it draws at, into `out`. */
+export function screenOf(camera, height, out = { eye: new Vector3(), ortho: false, scale: 0 }) {
+    const projection = camera.projectionMatrix.elements;
+    out.ortho = projection[15] === 1;
+    out.scale = ((projection[5] ?? 0) * height) / 2;
+    out.eye.setFromMatrixPosition(camera.matrixWorld);
+    return out;
+}
+const centre = new Vector3();
+/**
+ * The height on `screen` of `sphere`, given in the space `root` maps to world: its diameter, scaled by the largest axis
+ * scale of `root`, over its distance (small-angle), or its diameter alone in an orthographic camera.
+ */
+export function screenHeight(sphere, root, screen) {
+    const size = 2 * sphere.radius * root.getMaxScaleOnAxis();
+    if (screen.ortho)
+        return size * screen.scale;
+    return (size * screen.scale) / Math.max(screen.eye.distanceTo(centre.copy(sphere.center).applyMatrix4(root)), 1e-6);
+}
+//# sourceMappingURL=screen.js.map

package/dist/levels/screen.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.js","sourceRoot":"","sources":["../../src/levels/screen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAA0C,MAAM,cAAc,CAAC;AAW/E,sEAAsE;AACtE,MAAM,UAAU,QAAQ,CAAC,MAAc,EAAE,MAAc,EAAE,MAAc,EAAE,GAAG,EAAE,IAAI,OAAO,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE;IACnH,MAAM,UAAU,GAAG,MAAM,CAAC,gBAAgB,CAAC,QAAQ,CAAC;IACpD,GAAG,CAAC,KAAK,GAAG,UAAU,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;IACjC,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAChD,GAAG,CAAC,GAAG,CAAC,qBAAqB,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAClD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,MAAM,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;AAE7B;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,MAAc,EAAE,IAAa,EAAE,MAAc;IACxE,MAAM,IAAI,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC1D,IAAI,MAAM,CAAC,KAAK;QAAE,OAAO,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC;IAC7C,OAAO,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AACtH,CAAC"}

package/dist/loader/build.d.ts

@@ -0,0 +1,10 @@
+import type { Object3D, Renderer } from "three/webgpu";
+import type { Derived } from "./level.js";
+/**
+ * Build the level `request` asks for from `source`, with the baked level's `low` shell and `interior` rooms if it names
+ * them. `renderer` answers the renderer to bake with, asked for only by a bake that draws.
+ */
+export declare function buildLevel(source: Object3D, request: Derived, { low, interior }: {
+    low: Object3D | undefined;
+    interior: Object3D | undefined;
+}, renderer: () => Promise<Renderer>): Promise<Object3D>;

package/dist/loader/build.js

@@ -0,0 +1,28 @@
+import { bakeMesh } from "../baked/index.js";
+import { bakeImpostor } from "../impostor/bake/index.js";
+import { ImpostorMesh } from "../impostor/mesh/index.js";
+import { simplify } from "../simplify/index.js";
+import { placeLike } from "../three.js";
+/**
+ * Build the level `request` asks for from `source`, with the baked level's `low` shell and `interior` rooms if it names
+ * them. `renderer` answers the renderer to bake with, asked for only by a bake that draws.
+ */
+export async function buildLevel(source, request, { low, interior }, renderer) {
+    switch (request.type) {
+        case "simplify":
+            return simplify(source, { ratio: request.ratio });
+        case "impostor": {
+            const { type: _, draw: __, ...options } = request;
+            const object = new ImpostorMesh(await bakeImpostor(source, await renderer(), options));
+            object.name = `${source.name || "object"} impostor`;
+            placeLike(object, source);
+            return object;
+        }
+        case "baked": {
+            const shell = low ? { low } : { ratio: request.ratio };
+            const rooms = interior ? { interior, renderer: await renderer() } : {};
+            return bakeMesh(source, { textureSize: request.textureSize, ...shell, ...rooms });
+        }
+    }
+}
+//# sourceMappingURL=build.js.map

package/dist/loader/build.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.js","sourceRoot":"","sources":["../../src/loader/build.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC9B,MAAgB,EAChB,OAAgB,EAChB,EAAE,GAAG,EAAE,QAAQ,EAAiE,EAChF,QAAiC;IAEjC,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;QACrB,KAAK,UAAU;YACb,OAAO,QAAQ,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QACpD,KAAK,UAAU,CAAC,CAAC,CAAC;YAChB,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,OAAO,EAAE,GAAG,OAAO,CAAC;YAClD,MAAM,MAAM,GAAG,IAAI,YAAY,CAAC,MAAM,YAAY,CAAC,MAAM,EAAE,MAAM,QAAQ,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC;YACvF,MAAM,CAAC,IAAI,GAAG,GAAG,MAAM,CAAC,IAAI,IAAI,QAAQ,WAAW,CAAC;YACpD,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YAC1B,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,KAAK,OAAO,CAAC,CAAC,CAAC;YACb,MAAM,KAAK,GAAG,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC;YACvD,MAAM,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACvE,OAAO,QAAQ,CAAC,MAAM,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,GAAG,KAAK,EAAE,GAAG,KAAK,EAAE,CAAC,CAAC;QACpF,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/loader/context.d.ts

@@ -0,0 +1,44 @@
+import type { Object3D } from "three/webgpu";
+import { type DisposeOptions } from "../dispose.js";
+/**
+ * What one ladder's loads share: the source loaded to measure or build the ladder with, handed to the first level load
+ * (the source level draws it, a build uses it, a stored level disposes it; onLevel has not changed it), the levels built
+ * with the ladder, each handed to its first load, and every level object loaded. Those are freed if describing the
+ * ladder fails, else when the last Lod holding the levels is disposed (see `hold`), which spends them.
+ */
+export declare class LodLoadContext {
+    private readonly load;
+    private readonly onLevel;
+    /** Called once what the ladder loaded is freed. */
+    private readonly onFree;
+    /** Level bytes built while describing the ladder, by index: a stored level is read again when it loads. */
+    private readonly built;
+    private spare;
+    /** Every level object loaded, and what freeing it frees: a simplified level draws with its source's materials. */
+    private readonly loaded;
+    /** How many Lods hold the levels, and whether the last has let go, which freed them. */
+    private holders;
+    private spent;
+    constructor(load: () => Promise<Object3D>, onLevel: ((object: Object3D, index: number) => void | Promise<void>) | undefined, 
+    /** Called once what the ladder loaded is freed. */
+    onFree: () => void);
+    /** The spare source, loaded once. */
+    source(): Promise<Object3D>;
+    /** The spare source, for the first level load to take. */
+    take(): Object3D | undefined;
+    /** Hold the bytes of level `index`, built while describing the ladder, for its first load to take. */
+    setBuilt(index: number, bytes: Uint8Array): void;
+    /** The bytes of level `index` built while describing the ladder, once: undefined if none were, or once taken. */
+    takeBuilt(index: number): Uint8Array | undefined;
+    /** Apply onLevel to a level's arriving object, freeing it as `options` say if that fails. */
+    arrive(object: Object3D, index: number, options: DisposeOptions): Promise<Object3D>;
+    /** Describing the ladder failed: free what it loaded. */
+    fail(): void;
+    /**
+     * A Lod made from the levels holds them; the release it answers lets go, and the last frees what was loaded. Levels
+     * no Lod ever held are never freed. Freed levels are spent: a Lod made from them later throws.
+     */
+    readonly hold: () => (() => void);
+    /** Free the spare source and every level object loaded with `dispose`. */
+    private free;
+}

package/dist/loader/context.js

@@ -0,0 +1,96 @@
+import { disposeRejected, disposeRecursive } from "../dispose.js";
+/**
+ * What one ladder's loads share: the source loaded to measure or build the ladder with, handed to the first level load
+ * (the source level draws it, a build uses it, a stored level disposes it; onLevel has not changed it), the levels built
+ * with the ladder, each handed to its first load, and every level object loaded. Those are freed if describing the
+ * ladder fails, else when the last Lod holding the levels is disposed (see `hold`), which spends them.
+ */
+export class LodLoadContext {
+    load;
+    onLevel;
+    onFree;
+    /** Level bytes built while describing the ladder, by index: a stored level is read again when it loads. */
+    built = new Map();
+    spare;
+    /** Every level object loaded, and what freeing it frees: a simplified level draws with its source's materials. */
+    loaded = new Map();
+    /** How many Lods hold the levels, and whether the last has let go, which freed them. */
+    holders = 0;
+    spent = false;
+    constructor(load, onLevel, 
+    /** Called once what the ladder loaded is freed. */
+    onFree) {
+        this.load = load;
+        this.onLevel = onLevel;
+        this.onFree = onFree;
+    }
+    /** The spare source, loaded once. */
+    async source() {
+        this.spare ??= await this.load();
+        return this.spare;
+    }
+    /** The spare source, for the first level load to take. */
+    take() {
+        const taken = this.spare;
+        this.spare = undefined;
+        return taken;
+    }
+    /** Hold the bytes of level `index`, built while describing the ladder, for its first load to take. */
+    setBuilt(index, bytes) {
+        this.built.set(index, bytes);
+    }
+    /** The bytes of level `index` built while describing the ladder, once: undefined if none were, or once taken. */
+    takeBuilt(index) {
+        const bytes = this.built.get(index);
+        this.built.delete(index);
+        return bytes;
+    }
+    /** Apply onLevel to a level's arriving object, freeing it as `options` say if that fails. */
+    async arrive(object, index, options) {
+        try {
+            this.loaded.set(object, options);
+            await this.onLevel?.(object, index);
+            return object;
+        }
+        catch (error) {
+            this.loaded.delete(object);
+            disposeRejected(object, options);
+            throw error;
+        }
+    }
+    /** Describing the ladder failed: free what it loaded. */
+    fail() {
+        this.free(disposeRejected);
+    }
+    /**
+     * A Lod made from the levels holds them; the release it answers lets go, and the last frees what was loaded. Levels
+     * no Lod ever held are never freed. Freed levels are spent: a Lod made from them later throws.
+     */
+    hold = () => {
+        if (this.spent)
+            throw new Error("CachedLodLoader: these levels were freed with the last Lod that held them; call loadAsync again");
+        this.holders++;
+        let held = true;
+        return () => {
+            if (!held)
+                return;
+            held = false;
+            if (--this.holders > 0)
+                return;
+            this.spent = true;
+            this.free(disposeRecursive);
+        };
+    };
+    /** Free the spare source and every level object loaded with `dispose`. */
+    free(dispose) {
+        const taken = this.take();
+        if (taken)
+            dispose(taken, { materials: true });
+        for (const [object, options] of this.loaded)
+            dispose(object, options);
+        this.loaded.clear();
+        this.built.clear();
+        this.onFree();
+    }
+}
+//# sourceMappingURL=context.js.map

package/dist/loader/context.js.map

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

package/dist/loader/entry.d.ts

@@ -0,0 +1,4 @@
+import { CacheEntry, type CacheEntryOptions } from "vitecache";
+import { type Ladder } from "./request.js";
+/** The entry of derived level `of` of `ladder`, or of its source's shape, keyed by the request alone. */
+export declare function entryOf(ladder: Ladder, of: number | "shape", { basePath, root }: Pick<CacheEntryOptions, "basePath" | "root">): CacheEntry;

package/dist/loader/entry.js

@@ -0,0 +1,43 @@
+import { CacheEntry } from "vitecache";
+import { derived } from "./request.js";
+// What a level is stored under.
+/**
+ * What builds and lays out a stored level, and so what identifies it beside its request: bump it with any change to
+ * the bytes a level or shape entry holds.
+ */
+const version = "lod-level@25";
+/** The entry of derived level `of` of `ladder`, or of its source's shape, keyed by the request alone. */
+export function entryOf(ladder, of, { basePath, root }) {
+    const level = of === "shape" ? { type: of } : parameters(derived(ladder.levels, of));
+    return new CacheEntry({ basePath, root, version, dependencies: { level: { value: { url: ladder.key, level } } } });
+}
+/**
+ * What derives a level's content, by its role rather than its ladder position, so adding or removing another level
+ * keeps this one's entry. Switch thresholds and impostor draw options apply at decode, so changing one reuses it.
+ */
+function parameters(level) {
+    switch (level.type) {
+        case "simplify":
+            return { type: level.type, ratio: level.ratio ?? null };
+        case "baked":
+            return {
+                type: level.type,
+                ratio: level.ratio ?? null,
+                textureSize: level.textureSize ?? null,
+                low: level.low ?? null,
+                interior: level.interior ?? null,
+            };
+        case "impostor":
+            return {
+                type: level.type,
+                // The impostor bakes its top mip for this height too.
+                maxPixels: level.maxPixels ?? null,
+                layout: level.layout ?? null,
+                frames: level.frames ?? null,
+                resolution: level.resolution ?? null,
+                emissive: level.emissive ?? null,
+                supersample: level.supersample ?? null,
+            };
+    }
+}
+//# sourceMappingURL=entry.js.map

package/dist/loader/entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.js","sourceRoot":"","sources":["../../src/loader/entry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA0C,MAAM,WAAW,CAAC;AAE/E,OAAO,EAAE,OAAO,EAAe,MAAM,cAAc,CAAC;AAEpD,gCAAgC;AAEhC;;;GAGG;AACH,MAAM,OAAO,GAAG,cAAc,CAAC;AAE/B,yGAAyG;AACzG,MAAM,UAAU,OAAO,CAAC,MAAc,EAAE,EAAoB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAgD;IAC5H,MAAM,KAAK,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC;IACrF,OAAO,IAAI,UAAU,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;AACrH,CAAC;AAED;;;GAGG;AACH,SAAS,UAAU,CAAC,KAAc;IAChC,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,UAAU;YACb,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,IAAI,EAAE,CAAC;QAC1D,KAAK,OAAO;YACV,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,IAAI;gBAC1B,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,IAAI;gBACtC,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,IAAI;gBACtB,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI;aACjC,CAAC;QACJ,KAAK,UAAU;YACb,OAAO;gBACL,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,sDAAsD;gBACtD,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,IAAI;gBAClC,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI;gBAC5B,MAAM,EAAE,KAAK,CAAC,MAAM,IAAI,IAAI;gBAC5B,UAAU,EAAE,KAAK,CAAC,UAAU,IAAI,IAAI;gBACpC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI;gBAChC,WAAW,EAAE,KAAK,CAAC,WAAW,IAAI,IAAI;aACvC,CAAC;IACN,CAAC;AACH,CAAC"}

package/dist/loader/index.d.ts

@@ -0,0 +1,76 @@
+import { Loader, LoadingManager, type Object3D, type WebGPURenderer } from "three/webgpu";
+import type { CacheEntryOptions, Input } from "vitecache";
+import { type LodLevel } from "../levels/index.js";
+import { type LodRequest } from "./request.js";
+export interface CachedLodLoaderOptions extends Pick<CacheEntryOptions, "basePath" | "root"> {
+    /**
+     * Apply runtime effects when a level arrives, before draws compile. Does not change built content or bounds.
+     * `index` is the returned ladder's: 0 is the source, and `levels[i]` arrives as `i + 1`. Set `castShadow` and
+     * `shadowSide` here: a level compiles its draws, shadow maps' included, before it arrives, so a shadow setting
+     * changed later compiles mid-frame.
+     */
+    onLevel?: (object: Object3D, index: number) => void | Promise<void>;
+}
+/**
+ * Loads levels of detail from asset URLs, storing each derived level, and the source's shape, in vitecache, keyed by
+ * the request alone. Load it as a vitecache cached loader, with literal requests, so that the vitecache plugin finds
+ * every load and builds its levels in Node, saving them with the files they were built from; browsers read them, and
+ * one that misses builds the level itself.
+ *
+ * Loads asset URLs through manager handlers, else with a GLTFLoader of its own, which decodes meshopt only: register
+ * a GLTFLoader configured with Draco or KTX2 decoders for models compressed with them, and a GLTSLoader for .glts
+ * sources. Impostor and interior bakes draw with a renderer of the loader's own, made at its first bake and freed with
+ * what the last of the ladders it describes loaded (see `loadAsync`), or by `dispose`.
+ */
+export declare class CachedLodLoader extends Loader<LodLevel[], LodRequest> {
+    protected readonly options: CachedLodLoaderOptions;
+    private gltf;
+    /**
+     * The renderer this loader bakes with, made at its first bake. Its own, not the app's: a canvas the size of a bake
+     * frame would draw that frame over the whole target (see `bakeImpostor`).
+     */
+    private renderer;
+    /** How many ladders it described whose loads are not yet freed. */
+    private ladders;
+    /** Whether `loadAsync` builds every level with the ladder rather than when a camera first needs it. */
+    protected readonly buildsAll: boolean;
+    constructor(manager?: LoadingManager, options?: CachedLodLoaderOptions);
+    load(request: LodRequest, onLoad: (levels: LodLevel[]) => void, _onProgress?: (event: ProgressEvent) => void, onError?: (error: unknown) => void): void;
+    /**
+     * Describes the ladder from its source, which the first level loaded then takes. Empty levels load with it, as does
+     * the source when it is the only drawable; other levels load when a camera needs them, including a coarse stand-in
+     * while its first detail arrives, and each derived level is built when first loaded. A level whose default threshold
+     * is measured from it is built with the ladder, and in Node every level is.
+     *
+     * What the levels load is freed when the last Lod holding them is disposed (see `LodLevel.hold`), which spends them:
+     * a Lod made from them later throws, so call loadAsync again. Levels no Lod ever holds are never freed: they are
+     * yours until a Lod holds them. Once every ladder it described is freed, so is its bake renderer.
+     */
+    loadAsync(request: LodRequest): Promise<LodLevel[]>;
+    /** The stored bytes of derived level `of`, or of the source's shape, else what `build` makes, saved. */
+    private cached;
+    /**
+     * The path below the app's base that `url`, as the manager resolved it, loads, such as `/tree/model.glts`: what its
+     * levels are stored under, alike wherever the app is served. The manager of a .glts script resolves URLs against the
+     * script.
+     */
+    protected publicPath(url: string): string;
+    /** The files and packages what this loader built so far was built from: none in browsers, which do not save. */
+    protected inputs(): Input[];
+    /** A deferred level's bytes, built from `spare`, the ladder's source, or from a source of its own. Disposes `spare` either way. */
+    private levelBytes;
+    /** Build level `index` from `source`, encoded. */
+    private build;
+    /** The renderer this loader bakes with, made at its first bake. */
+    private bakeRenderer;
+    protected newBakeRenderer(): Promise<WebGPURenderer>;
+    /**
+     * Free the renderer this loader made for its bakes, resolving once freed; a bake under way fails. Levels it loaded
+     * stay as they are, and a later bake makes a new renderer. In Node each `loadAsync` frees what it made to load and
+     * bake with, the scenes of its GLTSLoader included, before it resolves, so there this frees nothing.
+     */
+    dispose(): Promise<void>;
+    /** Free the bake renderer, once made. */
+    private freeRenderer;
+    protected loadAsset(url: string): Promise<Object3D>;
+}