@drawcall/lod 0.1.2 → 0.3.0

package/dist/levels/load.d.ts

@@ -0,0 +1,31 @@
+import type { d } from "typegpu";
+import { type Draw, type DrawLevels } from "./draw.js";
+/**
+ * The bits of the levels to load for objects whose heights on a camera's screen lie in `ranges` (shortest and tallest,
+ * in px), read from `heights`, all levels loaded: every level a height in a range draws once all are loaded, the finer
+ * neighbour inside a fade included, and with any that draws something the coarsest level that draws something, which
+ * every draw waits for (see levelsToDraw). None where nothing draws.
+ */
+export declare function levelsToLoad(ranges: Iterable<readonly [shortest: number, tallest: number]>, heights: LevelHeights): number;
+/**
+ * The levels levelsToDraw draws with `levels` and the levels of `loaded` loaded, no arrival under way, at every height,
+ * by intervals of heights: worked out once, as it walks every chunk's heights each frame and each of its CPU calls
+ * through TypeGPU copies its arguments. What it draws changes only at a level's maxPixels and where its fade starts,
+ * whatever is loaded (which only says what stands in for a level): it is asked at the ends of a few f32 steps around
+ * each such height, and between them where it changes. levelsToDraw stays the only answer; this is where it changes.
+ */
+export declare class LevelHeights {
+    readonly levels: d.Infer<typeof DrawLevels>;
+    readonly loaded: number;
+    /** The last f32 height of every interval but the last, ascending. */
+    private readonly ends;
+    /** The bits of the levels each interval draws: its level, and inside a fade the finer one too. */
+    private readonly drawn;
+    constructor(levels: d.Infer<typeof DrawLevels>, loaded?: number);
+    /** The bits of the levels objects from `shortest` to `tallest` px tall draw. */
+    drawnIn(shortest: number, tallest: number): number;
+    /** The interval holding `height`. */
+    private interval;
+}
+/** The bits of the levels `draw` draws: its level, and its finer one while it fades; none for level -1. */
+export declare function drawnBits({ level, finer, fade }: d.Infer<typeof Draw>): number;

package/dist/levels/load.js

@@ -0,0 +1,142 @@
+import { at } from "../at.js";
+import { ANY_HEIGHT, FADE, levelsToDraw } from "./draw.js";
+// Which levels a camera needs loaded, and which it can draw.
+/**
+ * The bits of the levels to load for objects whose heights on a camera's screen lie in `ranges` (shortest and tallest,
+ * in px), read from `heights`, all levels loaded: every level a height in a range draws once all are loaded, the finer
+ * neighbour inside a fade included, and with any that draws something the coarsest level that draws something, which
+ * every draw waits for (see levelsToDraw). None where nothing draws.
+ */
+export function levelsToLoad(ranges, heights) {
+    const { count, empty, coarsest } = heights.levels;
+    const all = (1 << count) - 1;
+    let wanted = 0;
+    for (const [shortest, tallest] of ranges) {
+        wanted |= heights.drawnIn(shortest, tallest);
+        // Every level that draws something is wanted already.
+        if ((wanted & ~empty) === (all & ~empty))
+            break;
+    }
+    return wanted & ~empty ? wanted | (1 << coarsest) : wanted;
+}
+/**
+ * How far, in f32 steps, a height where what levelsToDraw draws changes may lie from where `windowsOf` puts it: on the
+ * CPU, TypeGPU rounds heights and maxPixels to f32 and computes a fade's start from them, which moves it by a step.
+ */
+const SLACK = 4;
+/**
+ * The levels levelsToDraw draws with `levels` and the levels of `loaded` loaded, no arrival under way, at every height,
+ * by intervals of heights: worked out once, as it walks every chunk's heights each frame and each of its CPU calls
+ * through TypeGPU copies its arguments. What it draws changes only at a level's maxPixels and where its fade starts,
+ * whatever is loaded (which only says what stands in for a level): it is asked at the ends of a few f32 steps around
+ * each such height, and between them where it changes. levelsToDraw stays the only answer; this is where it changes.
+ */
+export class LevelHeights {
+    levels;
+    loaded;
+    /** The last f32 height of every interval but the last, ascending. */
+    ends = [];
+    /** The bits of the levels each interval draws: its level, and inside a fade the finer one too. */
+    drawn = [];
+    constructor(levels, loaded = (1 << levels.count) - 1) {
+        this.levels = levels;
+        this.loaded = loaded;
+        const ask = (height) => drawnBits(levelsToDraw(height, levels, loaded, loaded, 1));
+        let below = ask(0);
+        this.drawn.push(below);
+        for (const [low, high] of windowsOf(levels)) {
+            if (ask(low) !== below)
+                throw new Error("Lod: levelsToDraw changes away from every maxPixels and fade start");
+            const above = ask(high);
+            // Every change inside the window: the last f32 height that draws what is below it, found by halving.
+            for (let from = low; below !== above;) {
+                let last = from;
+                let past = high;
+                while (step(last, 1) < past) {
+                    const middle = halfway(last, past);
+                    if (ask(middle) === below)
+                        last = middle;
+                    else
+                        past = middle;
+                }
+                below = ask(past);
+                this.ends.push(last);
+                this.drawn.push(below);
+                from = past;
+            }
+        }
+        // levelsToDraw takes no infinite f32: the largest finite one stands for every height above.
+        if (ask(ANY_HEIGHT) !== below)
+            throw new Error("Lod: levelsToDraw changes above every maxPixels");
+    }
+    /** The bits of the levels objects from `shortest` to `tallest` px tall draw. */
+    drawnIn(shortest, tallest) {
+        const last = this.interval(tallest);
+        let bits = 0;
+        for (let i = this.interval(shortest); i <= last; i++)
+            bits |= at(this.drawn, i);
+        return bits;
+    }
+    /** The interval holding `height`. */
+    interval(height) {
+        // levelsToDraw reads a height as an f32.
+        const value = Math.fround(height);
+        const { ends } = this;
+        let index = 0;
+        let end = ends.length;
+        while (index < end) {
+            const middle = (index + end) >>> 1;
+            if (value > at(ends, middle))
+                index = middle + 1;
+            else
+                end = middle;
+        }
+        return index;
+    }
+}
+/** The bits of the levels `draw` draws: its level, and its finer one while it fades; none for level -1. */
+export function drawnBits({ level, finer, fade }) {
+    if (level < 0)
+        return 0;
+    return (1 << level) | (fade > 0 ? 1 << finer : 0);
+}
+/**
+ * The f32 heights around which what levelsToDraw draws with `levels` may change, `SLACK` steps either side, ascending
+ * and merged where they overlap: every level's maxPixels but the source's, and where its fade starts.
+ */
+function windowsOf(levels) {
+    const edges = [];
+    levels.maxPixels.forEach((maxPixels, level) => {
+        if (level === 0 || level >= levels.count)
+            return;
+        edges.push(Math.fround(maxPixels), Math.fround(Math.fround(maxPixels) * (1 - FADE)));
+    });
+    edges.sort((a, b) => a - b);
+    const windows = [];
+    for (const edge of edges) {
+        const low = step(edge, -SLACK);
+        const last = windows.at(-1);
+        if (last && low <= last[1])
+            last[1] = step(edge, SLACK);
+        else
+            windows.push([low, step(edge, SLACK)]);
+    }
+    return windows;
+}
+const float = new Float32Array(1);
+const bits = new Uint32Array(float.buffer);
+/** The f32 `steps` steps from `value`, a height at or above 0, not below 0. */
+function step(value, steps) {
+    float[0] = value;
+    bits[0] = Math.max(at(bits, 0) + steps, 0);
+    return at(float, 0);
+}
+/** An f32 between the f32s `low` and `high`, two or more steps apart, at or above 0. */
+function halfway(low, high) {
+    float[0] = low;
+    const from = at(bits, 0);
+    float[0] = high;
+    bits[0] = from + Math.floor((at(bits, 0) - from) / 2);
+    return at(float, 0);
+}
+//# sourceMappingURL=load.js.map

package/dist/levels/load.js.map

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

package/dist/levels/manager.d.ts

@@ -0,0 +1,159 @@
+import type { Camera, Object3D, Object3DEventMap, Renderer } from "three/webgpu";
+import type { d } from "typegpu";
+import type { LodGpu } from "../gpu.js";
+import { type DrawLevels } from "./draw.js";
+import type { LodLevel } from "./index.js";
+import { LoadingItem } from "./item.js";
+import { CameraRequests } from "./requests.js";
+/** How long an arriving level fades in for, over what drew in its place. */
+export declare const ARRIVAL_MS = 200;
+export interface LodEventMap extends Object3DEventMap {
+    /** A compiled level has joined the loaded levels. */
+    levelschange: {};
+    /** Fetch, decode, or GPU preparation failed; the loaded levels still draw. */
+    levelserror: {
+        error: Error;
+    };
+}
+/** What a Lod or InstancedLod makes of a level's loaded object: `object` compiles, then joins the loaded levels or is discarded. */
+export interface PreparedLevel {
+    object: Object3D;
+    /** The level joins the loaded levels: it draws from now on. */
+    join(): void;
+    /** The compile failed, or the Lod was disposed meanwhile: free what preparing made. */
+    discard(): void;
+}
+/**
+ * Loads a Lod's or InstancedLod's levels as its cameras request them, never blocking a render. The coarsest level that
+ * draws something loads first, as nothing draws before it has (see levelsToDraw); the other levels a camera wants
+ * start loading once it has loaded. Each level's load runs once; once the render that asked for it has ended, the Lod
+ * prepares it (`prepare`), it compiles for the render context of every camera rendering the Lod and joins the loaded
+ * levels. Levels join only between arrivals, each of which fades in for ARRIVAL_MS from the levels loaded `before` it.
+ * Each render context seen for the first time compiles in the background every loaded level that draws something,
+ * given ones included, that no camera rendering the Lod wants: three skips a draw whose pipeline a compileAsync is
+ * still building, in any context that shares it, so a level a camera may draw now builds as it first draws instead.
+ * Nothing is evicted: a level stays loaded until the Lod is disposed.
+ *
+ * A Lod draws with its LodGpu's renderer, whose renders it learns its cameras from. It holds an item on its LoadingManager while anything a camera wants is missing, compiling or arriving,
+ * and an InstancedLod's while the GPU has not shown its chunks taken in (see `chunksChanged`).
+ */
+export declare class LodLevelLoadManager {
+    private readonly lod;
+    private readonly gpu;
+    /** The LoadingManager item's name, which errors name too: the kind of Lod and its uuid. */
+    private readonly name;
+    /** The levels as the Lod was given them: it holds them (see `LodLevel.hold`) until it is disposed. */
+    private readonly levels;
+    private readonly prepare;
+    /** What draws a loaded level, compiled for each render context it is wanted in. */
+    private readonly drawnBy;
+    /** The bits of the levels that draw: given ones from the start, deferred ones once loaded and compiled. */
+    loaded: number;
+    /** The bits loaded before the latest arrival (see `progress`). */
+    before: number;
+    /** The first failure; it stops further loading. */
+    error: Error | undefined;
+    /** Whether a render has updated the Lod: its shaders are being or have been built. */
+    started: boolean;
+    /** What draws the Lod: its LodGpu's renderer. */
+    readonly renderer: Renderer;
+    /** The cameras rendering the Lod, and what they asked for. */
+    readonly requests: CameraRequests;
+    /** Its item on a LoadingManager. */
+    readonly item: LoadingItem;
+    /**
+     * The bits of the levels that draw nothing, the coarsest level that draws something, and the order levels load in: it
+     * first, then coarse to fine.
+     */
+    private readonly empty;
+    private readonly coarsest;
+    private readonly order;
+    /** When the latest arrival began. */
+    private arrival;
+    /** Compiled levels waiting for the arrival under way to end. */
+    private readonly ready;
+    /** Levels being prepared and compiled to join the loaded ones. */
+    private readonly arriving;
+    /** The background compiles of loaded levels, per render context. */
+    private readonly compiles;
+    /** Per level, its load once started. */
+    private readonly loads;
+    /** What renders told of the cameras that drew the Lod. */
+    private readonly seen;
+    private disposed;
+    /** What `LodLevel.hold` answered, each called once the Lod is disposed. */
+    private readonly releases;
+    /** An InstancedLod's chunks, while they wait to be shown taken in (see `chunksChanged`); null for a Lod. */
+    private readonly wait;
+    constructor(lod: Object3D<LodEventMap>, gpu: LodGpu, 
+    /** The LoadingManager item's name, which errors name too: the kind of Lod and its uuid. */
+    name: string, 
+    /** The levels as the Lod was given them: it holds them (see `LodLevel.hold`) until it is disposed. */
+    levels: readonly LodLevel[], 
+    /** The levels as levelsToDraw reads them, for the ones that draw nothing and the coarsest that draws something. */
+    { empty, coarsest }: d.Infer<typeof DrawLevels>, prepare: (level: number, loaded: Object3D) => PreparedLevel, 
+    /** What draws a loaded level, compiled for each render context it is wanted in. */
+    drawnBy: (level: number) => readonly Object3D[], 
+    /** An InstancedLod's read of whether the GPU shows every chunk taken in (see `ChunkWait`); null for a Lod. */
+    readChunks: (() => Promise<boolean>) | null);
+    /** How far the latest arrival has faded in, in [0, 1]: 1 once it has. */
+    get progress(): number;
+    get pending(): boolean;
+    /**
+     * `camera`, a shadow map's when `shadow`, wants the levels of the bits `wanted` (see levelsToLoad): load what is
+     * missing, and answer the bits of the levels loaded now. Outside a Scene a missing level is an error, as no render of it would load it.
+     */
+    request(camera: Camera, wanted: number, shadow: boolean): number;
+    /**
+     * An InstancedLod's chunks were added or removed: hold the item until, a few renders later, the GPU shows each taken
+     * in, so that a host waiting for its LoadingManager sees them drawn. A chunk the pool lacks room for is the
+     * InstancedLod's error.
+     */
+    chunksChanged(): void;
+    /**
+     * The height `camera`, a shadow map's when `shadow`, draws at (see CameraRenders.heightOf), which levels are chosen
+     * at.
+     */
+    heightOf(camera: Camera, shadow: boolean): number;
+    /** What compiles for `cameras` are for: the shadow maps they drew, and the targets disposed. */
+    private compileFor;
+    /**
+     * Load what the cameras still rendering the Lod want, in `order`, compile for `camera`'s render context every loaded
+     * level that draws something, none of them wants and is not yet compiled for it, and prepare the levels that have
+     * loaded. `shadow` is whether a shadow map renders it, in the renderer's `frame`.
+     */
+    private load;
+    /** Run level `level`'s `load`, holding the object it makes. */
+    private start;
+    private levelAt;
+    /** Compile the loaded levels of `bits` for `context`: a background compile (see ContextCompiles). */
+    private compileLevels;
+    /**
+     * Prepare `level` once the render that asked for it has ended, if a camera still wants it then, and compile it for
+     * the render context of every camera still rendering the Lod, `context` among them, to join the loaded levels: a
+     * slow level never holds another's, and no camera draws it uncompiled.
+     */
+    private arrive;
+    /** Let compiled levels join the loaded ones, between arrivals: what draws never changes halfway through a fade. */
+    private join;
+    /**
+     * Hold the item while levels a camera wants are missing, compiling or arriving, or chunks wait to be shown taken in,
+     * and end it once they are done, so a host waiting for its LoadingManager renders its cameras complete. Called at
+     * the end of each request.
+     */
+    private sync;
+    /**
+     * The one failure rule, for a level that fails and for anything that throws while three renders, where a throw would
+     * leave its internal target bound: note the error, log it, report it on the LoadingManager the item is held on and
+     * end the item, and dispatch `levelserror`. Only the first is reported; it stops further loading.
+     */
+    report(error: unknown): void;
+    /** Run `action`, part of an update or a draw callback, reporting what it throws instead. */
+    guard(action: () => void): void;
+    /**
+     * Stop loading, then `release` what the Lod made of its levels and let go of what it holds of them (see
+     * `LodLevel.hold`), once nothing preparing, compiling or loading still uses them. What the levels gave or loaded is
+     * not freed: it is whoever made it's.
+     */
+    dispose(release: () => void): void;
+}