@driftengine/assets 4.4.2 → 4.6.0

package/README.md

@@ -2,7 +2,7 @@
 
 Model readers for seven formats, and the streaming loader that uploads them.
 
-**Cost: 15.7 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/drawKey.d.ts

@@ -23,6 +23,15 @@ export interface DrawSurfaceOverride {
      * gallery and read as a black blotch. 0 says dielectric.
      */
     readonly metallicScale?: number;
+    /**
+     * Glass, in place of what the file says: the share of light that passes, how milky it is, and
+     * the colour it takes (`GlassOptions` in the renderer). For a model whose panes arrive as an
+     * opaque dark material, because its format or its exporter had no word for glass. Transmission
+     * above zero draws the part blended.
+     */
+    readonly transmission?: number;
+    readonly frost?: number;
+    readonly tint?: readonly [number, number, number];
 }
 /**
  * The fields a merged group carries, resolved from a material and its override.
@@ -47,6 +56,13 @@ export interface DrawGrouping {
     /** Whether both faces are drawn and lit. A merge of a two-sided part and a one-sided one would cull
      *  one of them or unhide the back of the other, so it is part of the key. */
     readonly doubleSided: boolean;
+    /**
+     * Glass. Zero transmission is not glass, and then frost is 0 and the tint white whatever the
+     * file or the override said, so a stray value on an opaque surface never splits a draw.
+     */
+    readonly transmission: number;
+    readonly frost: number;
+    readonly tint: readonly [number, number, number];
 }
 /**
  * Resolve what a part will actually be drawn with.
@@ -56,7 +72,7 @@ export interface DrawGrouping {
  * 0, which is the identity that lets a file saying nothing about a property draw the same as one
  * that did not have the property to say.
  *
- * The override wins over the material for the three fields it may carry, because a consumer dressing
+ * The override wins over the material for the fields it may carry, because a consumer dressing
  * a surface by name knows more than a default an exporter wrote. A cutout is not among them: it is
  * a fact about the *image* a material wears, so nothing outside the file has anything to say
  * about it.

package/dist/drawKey.js

@@ -1,3 +1,4 @@
+const CLEAR = [1, 1, 1];
 /**
  * Resolve what a part will actually be drawn with.
  *
@@ -6,12 +7,14 @@
  * 0, which is the identity that lets a file saying nothing about a property draw the same as one
  * that did not have the property to say.
  *
- * The override wins over the material for the three fields it may carry, because a consumer dressing
+ * The override wins over the material for the fields it may carry, because a consumer dressing
  * a surface by name knows more than a default an exporter wrote. A cutout is not among them: it is
  * a fact about the *image* a material wears, so nothing outside the file has anything to say
  * about it.
  */
 export function resolveDrawGrouping(material, override) {
+    const transmission = Math.max(0, override?.transmission ?? material?.transmission ?? 0);
+    const glass = transmission > 0;
     return {
         albedo: material?.albedo ?? -1,
         orm: material?.ormMap ?? -1,
@@ -23,8 +26,11 @@ export function resolveDrawGrouping(material, override) {
         metallicScale: override?.metallicScale ?? material?.metallicScale ?? 1,
         occlusionStrength: material?.occlusionStrength ?? 0,
         cutout: material?.cutout ?? 0,
-        blend: material?.blend === true,
+        blend: material?.blend === true || glass,
         doubleSided: material?.doubleSided === true,
+        transmission,
+        frost: glass ? (override?.frost ?? material?.frost ?? 0) : 0,
+        tint: glass ? (override?.tint ?? material?.tint ?? CLEAR) : CLEAR,
     };
 }
 /**
@@ -40,5 +46,5 @@ export function resolveDrawGrouping(material, override) {
  */
 export function drawKeyOf(material, override) {
     const g = resolveDrawGrouping(material, override);
-    return `${g.albedo}:${g.orm}:${g.normal}:${g.emissive}:${g.opacity}:${g.reflectivity}:${g.roughnessScale}:${g.metallicScale}:${g.occlusionStrength}:${g.cutout}:${g.blend ? 1 : 0}:${g.doubleSided ? 1 : 0}`;
+    return `${g.albedo}:${g.orm}:${g.normal}:${g.emissive}:${g.opacity}:${g.reflectivity}:${g.roughnessScale}:${g.metallicScale}:${g.occlusionStrength}:${g.cutout}:${g.blend ? 1 : 0}:${g.doubleSided ? 1 : 0}:${g.transmission}:${g.frost}:${g.tint[0]},${g.tint[1]},${g.tint[2]}`;
 }

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.
          *
@@ -742,6 +876,7 @@ export class DrftLoader {
             cutout: 0,
             blend: false,
             doubleSided: false,
+            glass: null,
             reveal: this.outlinePart?.reveal ?? 0,
             instances: null,
         };
@@ -759,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;
@@ -778,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.
@@ -796,6 +962,7 @@ export class DrftLoader {
                 cutout,
                 blend,
                 doubleSided,
+                glass: glassOf(g),
             });
         }
         const key = drawKeyOf(material, override);
@@ -814,6 +981,7 @@ export class DrftLoader {
                 cutout,
                 blend,
                 doubleSided,
+                glass: glassOf(g),
                 members: [],
             };
             this.groups.set(key, group);
@@ -854,6 +1022,7 @@ export class DrftLoader {
                 cutout,
                 blend,
                 doubleSided,
+                glass: group.glass,
                 reveal: 0,
                 instances: null,
             };
@@ -879,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);
@@ -947,6 +1089,7 @@ export class DrftLoader {
                 cutout: group.cutout,
                 blend: group.blend,
                 doubleSided: group.doubleSided,
+                glass: group.glass,
                 reveal: 1,
                 instances: null,
             });
@@ -1068,6 +1211,12 @@ export class DrftLoader {
         };
     }
 }
+/** A group's glass as the renderer takes it, or null for a group that lets no light through. */
+function glassOf(g) {
+    if (g.transmission <= 0)
+        return null;
+    return { transmission: g.transmission, frost: g.frost, tint: [g.tint[0], g.tint[1], g.tint[2]] };
+}
 /**
  * The MIME type a codec's bytes carry, or `null` for one the browser has no decoder for.
  *

package/dist/gltf.d.ts

@@ -80,16 +80,35 @@ interface GltfSpecularGlossiness {
         texCoord?: number;
     };
 }
+/**
+ * The three extensions that together say a material is glass: how much light passes
+ * (`KHR_materials_transmission`), how much of it is scattered on the way and the colour it takes
+ * (`KHR_materials_diffuse_transmission`), and the colour a thickness of it absorbs towards
+ * (`KHR_materials_volume`). Only the fields this reader maps are named.
+ */
+interface GltfTransmission {
+    transmissionFactor?: number;
+}
+interface GltfDiffuseTransmission {
+    diffuseTransmissionFactor?: number;
+    diffuseTransmissionColorFactor?: number[];
+}
+interface GltfVolume {
+    attenuationColor?: number[];
+}
 interface GltfMaterial {
     pbrMetallicRoughness?: GltfPbrMetallicRoughness;
     /**
-     * The material extensions this reader knows. One, and everything else is ignored.
+     * The material extensions this reader knows, and everything else is ignored.
      *
-     * Read as an optional field rather than as `Record<string, unknown>` so that adding a second
-     * costs a name here and a branch in `pbrOf`, and so that a typo in either is a compile error.
+     * Read as optional fields rather than as `Record<string, unknown>` so that adding one costs a
+     * name here and a branch where it is read, and so that a typo in either is a compile error.
      */
     extensions?: {
         KHR_materials_pbrSpecularGlossiness?: GltfSpecularGlossiness;
+        KHR_materials_transmission?: GltfTransmission;
+        KHR_materials_diffuse_transmission?: GltfDiffuseTransmission;
+        KHR_materials_volume?: GltfVolume;
     };
     normalTexture?: {
         index: number;