@driftengine/assets 4.5.0 → 4.6.1

package/README.md

@@ -2,7 +2,7 @@
 
 Model readers for seven formats, and the streaming loader that uploads them.
 
-**Cost: 15.9 KB gzipped on top of core.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
+**Cost: 22.5 KB gzipped on top of core.** Measured by `scripts/size-gate.test.mjs`, which fails if it drifts more than
 3% — the number is a fact about the build rather than a claim in a document.
 
 Part of [DriftEngine](../../README.md). See [`docs/ARCHITECTURE.md`](../../docs/ARCHITECTURE.md)

package/dist/drftLoader.d.ts

@@ -7,7 +7,9 @@ import type { DrftFieldPlacement } from './fieldPlacement.ts';
 import { TextureSet } from './drftTextures.ts';
 import type { DrawSurfaceOverride } from './drawKey.ts';
 import type { AnimationClip, DrftLight, DrftMorph, DrftNode, DrftSkin } from '@driftengine/drft';
+import type { DrftLightVolume, EntsScene, NavPolyMesh } from '@driftengine/drft';
 import type { DrftLoadProgress, DrftPart } from './loadProgress.ts';
+import type { LoadedRegion } from './regionStore.ts';
 /**
  * How a loaded model is placed: fitted to a size, or left exactly where its file puts it.
  *
@@ -152,6 +154,23 @@ export interface DrftLoaderOptions {
      * of the file — which is why it is an option a caller weighs rather than a default.
      */
     readonly texturePreview?: number;
+    /**
+     * Take each image as it decodes, by the name its `TEXS` chunk gives it, and upload none: for a
+     * consumer that builds its own textures — a world packing every picture into a layer of an
+     * array — where a surface texture of each as well would spend the memory twice. On the same
+     * frame clock as an upload, one a frame; `null` for an image that did not decode. Materials in
+     * the file that name an image then draw untextured, which is the consumer's to answer.
+     */
+    readonly onImage?: (name: string, image: ImageBitmap | null) => void;
+    /**
+     * Offered each mesh no region holds as it arrives, by its ordinal in the file; return true to
+     * take it, and it is neither uploaded as a part nor merged. For a consumer that draws some of a
+     * file's meshes its own way — a crowd of kinds it instances and moves every frame — which a part
+     * cannot be, since the merge bakes a part into a static group by the image it wears. Counted as
+     * arrived, so a loading bar still finishes. What it gives up: the loader's upload budget and
+     * fade, which a taken mesh leaves to the consumer.
+     */
+    readonly onMesh?: (mesh: MeshData, ordinal: number) => boolean;
 }
 /**
  * A `.drft` loaded progressively: the model builds up on screen instead of appearing.
@@ -185,6 +204,11 @@ export declare class DrftLoader {
     private readonly revealed;
     /** Arrived, not yet uploaded. Drained by `update` at the budget. */
     private readonly queue;
+    /**
+     * Paged region meshes asked for and not yet up, drained after `queue` on the same clock: each is
+     * an expansion from the copies the file carried, then an upload.
+     */
+    private pageQueue;
     /** `INST`'s placements by mesh ordinal, in hand before the meshes they place arrive. */
     private readonly loadedInstances;
     /**
@@ -253,6 +277,10 @@ export declare class DrftLoader {
      */
     private loadedNodes;
     private loadedLights;
+    private loadedColliders;
+    private loadedNavigation;
+    private loadedEntities;
+    private loadedLightVolume;
     private loadedFields;
     /** The fields placed, built once the fit and the fields are both known. See `fields`. */
     private placedFields;
@@ -276,6 +304,8 @@ export declare class DrftLoader {
     private merged;
     private disposed;
     private arrived;
+    /** A streamed world's regions, kept apart from the parts and never merged. See `regionStore.ts`. */
+    private readonly regionStore;
     constructor(renderer: RendererApi, options?: DrftLoaderOptions);
     get progress(): DrftLoadProgress;
     /**
@@ -306,6 +336,41 @@ export declare class DrftLoader {
      * geometry. What a candela is in this scene's light units is the caller's decision.
      */
     get lights(): readonly DrftLight[];
+    /**
+     * The convex hulls the asset collides as, in the file's own space and unfitted, or empty. Handed
+     * on for the caller to build shapes from, as `hullShape` takes them.
+     */
+    get colliders(): readonly Float32Array[];
+    /** The asset's navigation mesh, unfitted, or null for a file carrying no `NAVM`. */
+    get navigation(): NavPolyMesh | null;
+    /**
+     * The asset's serialised entities, or null for a file carrying no `ENTS` — handed on as
+     * `deserializeWorld` takes them, because what an entity is belongs to the caller's schemas.
+     */
+    get entities(): EntsScene | null;
+    /**
+     * A streamed world's regions by id, each filling as its meshes and props upload — `pending` is 0
+     * once one is whole. Their meshes are never among `parts`: a region's levels are alternatives,
+     * drawn one at a time through `HlodSet`, and its batches cull instance by instance.
+     */
+    get regions(): ReadonlyMap<number, LoadedRegion>;
+    /** One mesh to draw, from the stream or expanded from an assembly, queued for upload. */
+    private take;
+    /**
+     * Bring a region's paged level up, or free it. A level that arrived as assemblies (`paged`) is
+     * held as the copies the file carried; asked for, each mesh is expanded and uploaded on the
+     * loader's clocked queue in later `update`s, and `resident` turns true when the last is up. Freed,
+     * its meshes go and the copies stay. A level that is not paged ignores this.
+     *
+     * The caller decides from what it will draw: page in the levels `HlodSet` is choosing or about
+     * to, draw a coarser one until the fine one is resident, and page out what the eye has left.
+     */
+    pageRegion(id: number, level: number, resident: boolean): void;
+    /**
+     * A world's summed lights, unfitted, or null until `LVOL` lands and for a file carrying none.
+     * Handed straight to `createWorldLightField`, whose volume it is shaped as.
+     */
+    get lightVolume(): DrftLightVolume | null;
     /**
      * The distance fields the file carries, each where it stands: at the loader's fit, and once a
      * copy for a mesh drawn many times. Empty until the fields and the fit have both arrived, and for
@@ -422,10 +487,9 @@ export declare class DrftLoader {
     /**
      * A mesh the file draws many times: uploaded once, placed by a batch, and kept out of the merge.
      *
-     * **The fit is conjugated into each placement.** The prototype is uploaded with the fit already
-     * applied, as every part is, so a copy's matrix M becomes F·M·F⁻¹: the same turn, and a translation
-     * of t − R·t + s·u for the fit's scale s and offset t and the copy's own translation u. A fitted
-     * model's copies then land where its geometry does, and are not scaled twice.
+     * **The fit is conjugated into each placement** by `fitCopies`, which a region's props share: the
+     * prototype is uploaded with the fit already applied, so the copies land where its geometry does
+     * and are not scaled twice.
      */
     private uploadInstanced;
     private buildGroup;

package/dist/drftLoader.js

@@ -1,9 +1,10 @@
 /** Loading a `.drft` into drawable parts progressively, without stalling the frame. */
-import { MeshBuilder, concatMeshes, createMeshInstances, placeMesh } from '@driftengine/core';
+import { MeshBuilder, concatMeshes, placeMesh } from '@driftengine/core';
 import { placeFields } from './fieldPlacement.js';
 import { TextureSet, textureColorSpaces } from './drftTextures.js';
 import { drawKeyOf, resolveDrawGrouping } from './drawKey.js';
-import { streamDrft, CODEC_JPEG, CODEC_PNG, CODEC_RAW, CODEC_WEBP, DrftError, } from '@driftengine/drft';
+import { streamDrft, CODEC_JPEG, CODEC_PNG, CODEC_RAW, CODEC_WEBP, DrftError, expandAssembly, } from '@driftengine/drft';
+import { RegionStore, fitCopies } from './regionStore.js';
 import { DEFAULT_REVEAL_SEC, DEFAULT_UPLOAD_MS_PER_FRAME, DEFAULT_UPLOADS_PER_FRAME, isDocumentResponse, mayBeginMore, } from './uploadBudget.js';
 /**
  * A `.drft` loaded progressively: the model builds up on screen instead of appearing.
@@ -37,6 +38,11 @@ export class DrftLoader {
     revealed = [];
     /** Arrived, not yet uploaded. Drained by `update` at the budget. */
     queue = [];
+    /**
+     * Paged region meshes asked for and not yet up, drained after `queue` on the same clock: each is
+     * an expansion from the copies the file carried, then an upload.
+     */
+    pageQueue = [];
     /** `INST`'s placements by mesh ordinal, in hand before the meshes they place arrive. */
     loadedInstances = new Map();
     /**
@@ -105,6 +111,10 @@ export class DrftLoader {
      */
     loadedNodes = [];
     loadedLights = [];
+    loadedColliders = [];
+    loadedNavigation = null;
+    loadedEntities = null;
+    loadedLightVolume = null;
     loadedFields = [];
     /** The fields placed, built once the fit and the fields are both known. See `fields`. */
     placedFields = null;
@@ -137,9 +147,12 @@ export class DrftLoader {
     merged = false;
     disposed = false;
     arrived = 0;
+    /** A streamed world's regions, kept apart from the parts and never merged. See `regionStore.ts`. */
+    regionStore;
     constructor(renderer, options = {}) {
         this.renderer = renderer;
         this.options = options;
+        this.regionStore = new RegionStore(renderer, () => this.fit);
     }
     get progress() {
         return this.state;
@@ -178,6 +191,91 @@ export class DrftLoader {
     get lights() {
         return this.loadedLights;
     }
+    /**
+     * The convex hulls the asset collides as, in the file's own space and unfitted, or empty. Handed
+     * on for the caller to build shapes from, as `hullShape` takes them.
+     */
+    get colliders() {
+        return this.loadedColliders;
+    }
+    /** The asset's navigation mesh, unfitted, or null for a file carrying no `NAVM`. */
+    get navigation() {
+        return this.loadedNavigation;
+    }
+    /**
+     * The asset's serialised entities, or null for a file carrying no `ENTS` — handed on as
+     * `deserializeWorld` takes them, because what an entity is belongs to the caller's schemas.
+     */
+    get entities() {
+        return this.loadedEntities;
+    }
+    /**
+     * A streamed world's regions by id, each filling as its meshes and props upload — `pending` is 0
+     * once one is whole. Their meshes are never among `parts`: a region's levels are alternatives,
+     * drawn one at a time through `HlodSet`, and its batches cull instance by instance.
+     */
+    get regions() {
+        return this.regionStore.regions;
+    }
+    /** One mesh to draw, from the stream or expanded from an assembly, queued for upload. */
+    take(mesh, ordinal) {
+        if (this.disposed)
+            return;
+        /* A region's own meshes are known by now: a region is written ahead of what it introduces. */
+        if (!this.regionStore.owns(ordinal) && this.options.onMesh?.(mesh, ordinal) === true) {
+            this.arrived++;
+            this.set({ phase: 'geometry', partsDone: this.arrived });
+            return;
+        }
+        const material = this.materials[ordinal];
+        /*
+         * Deltas onto the mesh they name, before it is queued for upload. The container writes a
+         * `MORP` immediately ahead of its `MESH` so this is in hand; a file that puts them the
+         * other way round still opens, and that mesh simply does not morph — a defined
+         * degradation rather than a wrong picture.
+         */
+        const morph = this.loadedMorphs.find((entry) => entry.mesh === ordinal);
+        const withMorph = morph === undefined
+            ? mesh
+            : { ...mesh, morphTargets: morph.deltas, morphTargetCount: morph.targetCount };
+        this.queue.push({
+            mesh: withMorph,
+            ordinal,
+            material,
+            instances: this.loadedInstances.get(ordinal) ?? null,
+        });
+        this.arrived++;
+        this.set({ phase: 'geometry', partsDone: this.arrived });
+    }
+    /**
+     * Bring a region's paged level up, or free it. A level that arrived as assemblies (`paged`) is
+     * held as the copies the file carried; asked for, each mesh is expanded and uploaded on the
+     * loader's clocked queue in later `update`s, and `resident` turns true when the last is up. Freed,
+     * its meshes go and the copies stay. A level that is not paged ignores this.
+     *
+     * The caller decides from what it will draw: page in the levels `HlodSet` is choosing or about
+     * to, draw a coarser one until the fine one is resident, and page out what the eye has left.
+     */
+    pageRegion(id, level, resident) {
+        const changes = this.regionStore.page(id, level, resident);
+        if (resident) {
+            for (const { ordinal, expand } of changes) {
+                this.pageQueue.push({ ordinal, material: this.materials[ordinal], expand });
+            }
+            return;
+        }
+        if (changes.length === 0)
+            return;
+        const released = new Set(changes.map((c) => c.ordinal));
+        this.pageQueue = this.pageQueue.filter((item) => !released.has(item.ordinal));
+    }
+    /**
+     * A world's summed lights, unfitted, or null until `LVOL` lands and for a file carrying none.
+     * Handed straight to `createWorldLightField`, whose volume it is shaped as.
+     */
+    get lightVolume() {
+        return this.loadedLightVolume;
+    }
     /**
      * The distance fields the file carries, each where it stands: at the loader's fit, and once a
      * copy for a mesh drawn many times. Empty until the fields and the fit have both arrived, and for
@@ -349,6 +447,15 @@ export class DrftLoader {
                 onLights: (lights) => {
                     this.loadedLights = lights;
                 },
+                onColliders: (hulls) => {
+                    this.loadedColliders = hulls;
+                },
+                onNavigation: (navigation) => {
+                    this.loadedNavigation = navigation;
+                },
+                onEntities: (entities) => {
+                    this.loadedEntities = entities;
+                },
                 onFields: (fields) => {
                     this.loadedFields = fields;
                     this.placedFields = null;
@@ -357,6 +464,14 @@ export class DrftLoader {
                     for (const group of groups)
                         this.loadedInstances.set(group.mesh, group.transforms);
                 },
+                onLightVolume: (volume) => {
+                    this.loadedLightVolume = volume;
+                },
+                onRegion: (region) => {
+                    if (this.disposed)
+                        return;
+                    this.regionStore.admit(region);
+                },
                 onSkin: (skin) => {
                     this.loadedSkins.push(skin);
                 },
@@ -422,27 +537,23 @@ export class DrftLoader {
                     this.materials = list;
                     this.set({ phase: 'materials' });
                 },
-                onMesh: (mesh, ordinal) => {
+                onKit: (pieces) => {
+                    /* A piece is drawn only as copies: it is not a part, and the count said it was. */
+                    this.set({ partsTotal: Math.max(0, this.state.partsTotal - pieces.length) });
+                },
+                onAssembly: (assembly, ordinal, piece) => {
                     if (this.disposed)
                         return;
-                    const material = this.materials[ordinal];
-                    /*
-                     * Deltas onto the mesh they name, before it is queued for upload. The container writes a
-                     * `MORP` immediately ahead of its `MESH` so this is in hand; a file that puts them the
-                     * other way round still opens, and that mesh simply does not morph — a defined
-                     * degradation rather than a wrong picture.
-                     */
-                    const morph = this.loadedMorphs.find((entry) => entry.mesh === ordinal);
-                    const withMorph = morph === undefined
-                        ? mesh
-                        : { ...mesh, morphTargets: morph.deltas, morphTargetCount: morph.targetCount };
-                    this.queue.push({
-                        mesh: withMorph,
-                        material,
-                        instances: this.loadedInstances.get(ordinal) ?? null,
-                    });
-                    this.arrived++;
-                    this.set({ phase: 'geometry', partsDone: this.arrived });
+                    if (this.regionStore.isLevelMesh(ordinal)) {
+                        this.regionStore.hold(ordinal, assembly, piece);
+                        this.arrived++;
+                        this.set({ phase: 'geometry', partsDone: this.arrived });
+                        return;
+                    }
+                    this.take(expandAssembly(assembly, piece), ordinal);
+                },
+                onMesh: (mesh, ordinal) => {
+                    this.take(mesh, ordinal);
                 },
                 onTexture: (texture, ordinal) => {
                     if (this.disposed)
@@ -572,10 +683,28 @@ export class DrftLoader {
             const next = this.queue.shift();
             if (next === undefined)
                 break;
-            if (this.uploadOne(next.mesh, next.material, next.instances))
+            if (this.uploadOne(next.mesh, next.material, next.instances, next.ordinal))
                 changed = true;
             begun++;
         }
+        /* Paged region meshes, after the stream's own: an expansion from the copies, then an upload. */
+        while (this.pageQueue.length > 0 &&
+            mayBeginMore(begun, performance.now() - startedMs, msBudget)) {
+            const next = this.pageQueue.shift();
+            if (next === undefined)
+                break;
+            if (this.uploadOne(next.expand(), next.material, null, next.ordinal))
+                changed = true;
+            begun++;
+        }
+        /* A region's prop batches, on the same clock: each is an allocation and an upload. Drained
+           before the merge below can begin, which is what lets `ready` not wait on them separately. */
+        while (this.regionStore.busy &&
+            mayBeginMore(begun, performance.now() - startedMs, msBudget) &&
+            this.regionStore.buildNext()) {
+            changed = true;
+            begun++;
+        }
         /* One image a frame, and only into a frame that has room for it. A 2048 square decodes
            off-thread and then uploads with its mips, which is the single most expensive thing in a
            load and lands right after the geometry — on top of the parts, until this was clocked. */
@@ -583,7 +712,11 @@ export class DrftLoader {
             mayBeginMore(begun, performance.now() - startedMs, msBudget)) {
             const ordinal = this.imageQueue.shift();
             if (ordinal !== undefined) {
-                this.rebuildTextures(ordinal);
+                const take = this.options.onImage;
+                if (take === undefined)
+                    this.rebuildTextures(ordinal);
+                else
+                    take(this.chunks[ordinal]?.name ?? '', this.images[ordinal] ?? null);
                 /*
                  * Counted here, once, and only for the image itself.
                  *
@@ -655,6 +788,7 @@ export class DrftLoader {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.regionStore.dispose();
         /*
          * Everything this class ever made, each disposed once.
          *
@@ -760,7 +894,7 @@ export class DrftLoader {
         return true;
     }
     /** One part, transformed, dressed and uploaded. Returns whether it landed. */
-    uploadOne(mesh, material, instances) {
+    uploadOne(mesh, material, instances, ordinal) {
         const fit = this.fit;
         if (fit === null)
             return false;
@@ -779,6 +913,37 @@ export class DrftLoader {
          */
         const g = resolveDrawGrouping(material, override);
         const { albedo, orm, normal, emissive, opacity, reflectivity, roughnessScale, metallicScale, occlusionStrength, cutout, blend, doubleSided, } = g;
+        /*
+         * A region's mesh — a level or a prop's prototype — is one part of its own, never grouped: the
+         * merge would weld a region's levels together and one region to the next. See `regionStore.ts`.
+         */
+        if (this.regionStore.owns(ordinal)) {
+            try {
+                this.regionStore.arrived(ordinal, {
+                    mesh: this.renderer.createMesh(placed),
+                    albedo,
+                    orm,
+                    normal,
+                    emissive,
+                    opacity,
+                    reflectivity,
+                    roughnessScale,
+                    metallicScale,
+                    occlusionStrength,
+                    cutout,
+                    blend,
+                    doubleSided,
+                    glass: glassOf(g),
+                    reveal: 1,
+                    instances: null,
+                });
+                return true;
+            }
+            catch (error) {
+                console.warn(`DrftLoader: region mesh ${ordinal} would not upload and was skipped`, error);
+                return false;
+            }
+        }
         /*
          * Added to its merged group here, while there is a budget governing how much of this happens
          * in one frame.
@@ -883,42 +1048,15 @@ export class DrftLoader {
     /**
      * A mesh the file draws many times: uploaded once, placed by a batch, and kept out of the merge.
      *
-     * **The fit is conjugated into each placement.** The prototype is uploaded with the fit already
-     * applied, as every part is, so a copy's matrix M becomes F·M·F⁻¹: the same turn, and a translation
-     * of t − R·t + s·u for the fit's scale s and offset t and the copy's own translation u. A fitted
-     * model's copies then land where its geometry does, and are not scaled twice.
+     * **The fit is conjugated into each placement** by `fitCopies`, which a region's props share: the
+     * prototype is uploaded with the fit already applied, so the copies land where its geometry does
+     * and are not scaled twice.
      */
     uploadInstanced(prototype, instances, fit, surface) {
         try {
             const uploaded = this.renderer.createMesh(prototype);
-            const count = instances.length / 16;
-            const batch = this.renderer.createInstanced(uploaded, count);
-            const data = createMeshInstances(count);
-            const s = fit.scale;
-            for (let k = 0; k < count; k++) {
-                const at = k * 16;
-                for (let i = 0; i < 12; i++)
-                    data.models[at + i] = instances[at + i];
-                const ux = instances[at + 12];
-                const uy = instances[at + 13];
-                const uz = instances[at + 14];
-                /* R·t, with R the copy's own 3×3 read column-major. */
-                const rtx = instances[at] * fit.x +
-                    instances[at + 4] * fit.y +
-                    instances[at + 8] * fit.z;
-                const rty = instances[at + 1] * fit.x +
-                    instances[at + 5] * fit.y +
-                    instances[at + 9] * fit.z;
-                const rtz = instances[at + 2] * fit.x +
-                    instances[at + 6] * fit.y +
-                    instances[at + 10] * fit.z;
-                data.models[at + 12] = fit.x - rtx + s * ux;
-                data.models[at + 13] = fit.y - rty + s * uy;
-                data.models[at + 14] = fit.z - rtz + s * uz;
-                data.models[at + 15] = 1;
-            }
-            data.tints.fill(1);
-            data.count = count;
+            const data = fitCopies(instances, fit);
+            const batch = this.renderer.createInstanced(uploaded, data.count);
             this.renderer.uploadInstanced(batch, data);
             const part = { mesh: uploaded, ...surface, reveal: 0, instances: { batch, data } };
             this.revealed.push(part);

package/dist/index.d.ts

@@ -13,6 +13,7 @@ export type { DrftFit, DrftLoaderOptions } from './drftLoader.ts';
 export { drawKeyOf, resolveDrawGrouping } from './drawKey.ts';
 export type { DrawGrouping, DrawSurfaceOverride } from './drawKey.ts';
 export type { DrftLoadPhase, DrftLoadProgress, DrftPart } from './loadProgress.ts';
+export type { LoadedRegion, LoadedRegionLevel } from './regionStore.ts';
 export type { DrftFieldPlacement } from './fieldPlacement.ts';
 export { TextureSet, textureColorSpaces } from './drftTextures.ts';
 export { assetCandidates, basenameOf } from './assetPath.ts';

package/dist/regionStore.d.ts

@@ -0,0 +1,94 @@
+import type { MeshInstances, RendererApi } from '@driftengine/core';
+import type { DrftAssembly, DrftRegion, DrftRegionCollision, PieceLookup } from '@driftengine/drft';
+import type { MeshData } from '@driftengine/drft';
+import type { DrftPart } from './loadProgress.ts';
+/** How the loader placed the model: `p · scale + (x, y, z)`. */
+export interface LoaderFit {
+    readonly scale: number;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+export interface LoadedRegionLevel {
+    /** How far, in metres of the file, this level may stand from the real surface. */
+    readonly error: number;
+    /** One part a mesh, filled as they upload. */
+    readonly parts: DrftPart[];
+    /** Whether any of its meshes arrived as assemblies, kept small until paged in. */
+    paged: boolean;
+    /** Whether every mesh is up: always, for a level that is not paged. */
+    resident: boolean;
+}
+export interface LoadedRegion {
+    readonly id: number;
+    /** Min xyz then max xyz, placed. */
+    readonly bounds: Float32Array;
+    /** Finest first. `HlodSet.add` takes the errors, scaled by the fit. */
+    readonly levels: readonly LoadedRegionLevel[];
+    /** Its props, one instanced part a prototype, culled per instance. */
+    readonly batches: DrftPart[];
+    /**
+     * Which of the region's groups in the file each batch is, index for index. Batches are built as
+     * their prototypes arrive, not in the file's order, so a caller pairing something of its own with
+     * each group — a material, a blend — pairs through this, never by position.
+     */
+    readonly batchGroups: number[];
+    /** Six floats a box, placed, for `addOccluder`. */
+    readonly occluders: Float32Array;
+    /** What it collides as, placed, or null. */
+    readonly collision: DrftRegionCollision | null;
+    /** Meshes and batches still to come; 0 once every level and prop is up. */
+    pending: number;
+}
+/**
+ * Copies of a fitted prototype, each matrix conjugated by the fit: M becomes F·M·F⁻¹, the same turn
+ * and a translation of t − R·t + s·u for the fit's scale s and offset t and the copy's own
+ * translation u. The prototype already carries the fit, so the copies land where its geometry does
+ * and are not scaled twice.
+ */
+export declare function fitCopies(transforms: Float32Array, fit: LoaderFit): MeshInstances;
+export declare class RegionStore {
+    private readonly renderer;
+    private readonly fit;
+    readonly regions: Map<number, LoadedRegion>;
+    /** Level meshes by ordinal: whose, and which level. */
+    private readonly levelOwners;
+    /** Prototypes that have uploaded, by ordinal. */
+    private readonly prototypes;
+    /** Groups whose prototype has not uploaded yet, by its ordinal. */
+    private readonly waiting;
+    private readonly jobs;
+    private readonly made;
+    /** Assemblies held small, by ordinal, and each paged level's ordinals. */
+    private readonly compact;
+    private readonly levelCompact;
+    /** Paged meshes asked for and not yet up, and those that are. */
+    private readonly requested;
+    private readonly pagedParts;
+    constructor(renderer: RendererApi, fit: () => LoaderFit | null);
+    /** Whether a mesh is a region's, as a level or a prop, and so is not a part of the model. */
+    owns(ordinal: number): boolean;
+    /** Whether batches are queued. */
+    get busy(): boolean;
+    /** A region's chunk has landed, ahead of the meshes it introduces. */
+    admit(region: DrftRegion): void;
+    /** Whether a mesh is one of a region's levels. */
+    isLevelMesh(ordinal: number): boolean;
+    /** A level's assembly has arrived: held small, its level paged and not yet up. */
+    hold(ordinal: number, assembly: DrftAssembly, piece: PieceLookup): void;
+    /**
+     * Ask for a paged level's meshes, or free them. Coming up, returns each mesh still to upload with
+     * a way to expand it, for the loader's queue; going down, frees what is up and returns the
+     * ordinals released, so the loader can drop any still queued.
+     */
+    page(id: number, level: number, resident: boolean): {
+        ordinal: number;
+        expand: () => MeshData;
+    }[];
+    private release;
+    /** A region's mesh has uploaded, as the part the loader would have made of it. */
+    arrived(ordinal: number, part: DrftPart): void;
+    /** Build one queued batch inside the caller's budget; false when none was queued. */
+    buildNext(): boolean;
+    dispose(): void;
+}