@driftengine/drft 4.4.2 → 4.6.0

package/dist/drftWrite.js

@@ -10,7 +10,7 @@
  */
 import { buildClip, buildMorph, buildNodes, buildSkin } from './drftSkin.js';
 import { validateMeshData } from './meshData.js';
-import { ALIGNMENT, ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_JOINTS, ATTR_RELIEF, ATTR_TANGENT, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_UVS, ATTR_WEIGHTS, CHUNK_ENTRY_BYTES, CHUNK_HEAD, CHUNK_ANIM, CHUNK_DTEX, CHUNK_ENTS, CHUNK_NAVM, CHUNK_LODM, CHUNK_LODF, CHUNK_MORP, CHUNK_NODE, CHUNK_INST, CHUNK_LITE, CHUNK_MSHQ, CHUNK_SKIN, CHUNK_SPLT, SPLAT_BLOCK_PREFIX, CHUNK_MATL, CHUNK_MESH, CHUNK_REQUIRED, CHUNK_COLL, CHUNK_NNET, CHUNK_NGRF, CHUNK_SDFV, CHUNK_SUBS, CHUNK_TEXS, MATERIAL_ENTRY_BYTES, DRFT_MAGIC, DRFT_VERSION_MAJOR, DRFT_VERSION_MINOR, DrftError, FLAG_LITTLE_ENDIAN, HEADER_BYTES, align, } from './drftFormat.js';
+import { ALIGNMENT, ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_JOINTS, ATTR_RELIEF, ATTR_TANGENT, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_UVS, ATTR_WEIGHTS, ATTR_LAYERS, ATTR_CHANNEL, CHUNK_ENTRY_BYTES, CHUNK_HEAD, CHUNK_ANIM, CHUNK_DTEX, CHUNK_ENTS, CHUNK_NAVM, CHUNK_LODM, CHUNK_LODF, CHUNK_MORP, CHUNK_NODE, CHUNK_INST, CHUNK_REGN, CHUNK_LVOL, CHUNK_LITE, CHUNK_MSHQ, CHUNK_KITS, CHUNK_MSHC, CHUNK_SKIN, CHUNK_SPLT, SPLAT_BLOCK_PREFIX, CHUNK_MATL, CHUNK_MESH, CHUNK_REQUIRED, CHUNK_COLL, CHUNK_NNET, CHUNK_NGRF, CHUNK_SDFV, CHUNK_SUBS, CHUNK_TEXS, MATERIAL_ENTRY_BYTES, DRFT_MAGIC, DRFT_VERSION_MAJOR, DRFT_VERSION_MINOR, DrftError, FLAG_LITTLE_ENDIAN, HEADER_BYTES, align, } from './drftFormat.js';
 import { coarseFirstOrder } from './coarseFirst.js';
 import { buildSubs } from './drftSubs.js';
 import { buildSdfv } from './sdfv.js';
@@ -21,8 +21,17 @@ import { buildNavm } from './navm.js';
 import { buildNgrf } from './ngrf.js';
 import { buildColliders } from './drftColliders.js';
 import { buildInstances } from './drftInstances.js';
+import { buildRegion, planRegions } from './drftRegions.js';
+import { buildLightVolume } from './drftLightVolume.js';
+/** Whether a region names a mesh, as a level or a prop. */
+function regionNames(region, mesh) {
+    return (region.levels.some((level) => level.meshes.includes(mesh)) ||
+        region.instances.some((group) => group.mesh === mesh));
+}
 import { buildLights } from './drftLights.js';
 import { encodeQuantisedMesh } from './drftQuantised.js';
+import { assemblyBounds } from './assemble.js';
+import { buildAssembly, buildKit, checkAssembly, checkCopies, checkKit, isAssembly, } from './drftAssembly.js';
 /**
  * The most blocks a capture is split into, and the fewest splats worth having in one.
  *
@@ -104,7 +113,7 @@ function encodeString(value) {
     bytes.set(text, 4);
     return bytes;
 }
-function buildHead(head, meshes, instances = []) {
+function buildHead(head, meshes, instances = [], kit = new Set()) {
     /*
      * Bounds are computed rather than taken on trust. A caller that gets them wrong would
      * produce an asset that culls itself out of frame, which looks like a rendering bug and
@@ -119,8 +128,25 @@ function buildHead(head, meshes, instances = []) {
     const placed = new Map();
     for (const group of instances)
         placed.set(group.mesh, group.transforms);
+    const pieceAt = (o) => meshes[o];
     for (let m = 0; m < meshes.length; m++) {
-        const mesh = meshes[m];
+        /* A kit piece is drawn only where it is copied, and its copies are counted with them. */
+        if (kit.has(m))
+            continue;
+        const slot = meshes[m];
+        if (isAssembly(slot)) {
+            const b = assemblyBounds(slot, pieceAt);
+            if (!(b[0] <= b[3]))
+                continue;
+            minX = Math.min(minX, b[0]);
+            minY = Math.min(minY, b[1]);
+            minZ = Math.min(minZ, b[2]);
+            maxX = Math.max(maxX, b[3]);
+            maxY = Math.max(maxY, b[4]);
+            maxZ = Math.max(maxZ, b[5]);
+            continue;
+        }
+        const mesh = slot;
         const transforms = placed.get(m);
         if (transforms === undefined) {
             for (let at = 0; at + 2 < mesh.positions.length; at += 3) {
@@ -250,6 +276,10 @@ function buildMesh(mesh, code = CHUNK_MESH, flags = CHUNK_REQUIRED) {
         attributes |= ATTR_JOINTS;
     if (mesh.weights !== undefined)
         attributes |= ATTR_WEIGHTS;
+    if (mesh.layers !== undefined)
+        attributes |= ATTR_LAYERS;
+    if (mesh.channel !== undefined)
+        attributes |= ATTR_CHANNEL;
     /* Order is frozen: mandatory arrays, then optional ones by ascending bit. */
     const arrays = [
         mesh.positions,
@@ -277,6 +307,12 @@ function buildMesh(mesh, code = CHUNK_MESH, flags = CHUNK_REQUIRED) {
         arrays.push(mesh.joints);
     if (mesh.weights !== undefined)
         arrays.push(mesh.weights);
+    /* Newest of all, 1.20, so last. See ATTR_LAYERS. */
+    if (mesh.layers !== undefined)
+        arrays.push(mesh.layers);
+    /* And newer still, 1.23. See ATTR_CHANNEL. */
+    if (mesh.channel !== undefined)
+        arrays.push(mesh.channel);
     arrays.push(mesh.indices);
     const PREFIX = 16;
     let total = PREFIX;
@@ -366,6 +402,12 @@ function buildMaterials(materials) {
         view.setFloat32(at + 68, material.occlusionStrength, true);
         view.setFloat32(at + 72, material.cutout, true);
         view.setUint32(at + 76, (material.blend === true ? 1 : 0) | (material.doubleSided === true ? 2 : 0), true);
+        /* Glass, 1.19: after the flags word, so every earlier offset stays where readers expect it. */
+        view.setFloat32(at + 80, material.transmission ?? 0, true);
+        view.setFloat32(at + 84, material.frost ?? 0, true);
+        view.setFloat32(at + 88, material.tint?.[0] ?? 1, true);
+        view.setFloat32(at + 92, material.tint?.[1] ?? 1, true);
+        view.setFloat32(at + 96, material.tint?.[2] ?? 1, true);
         at += MATERIAL_ENTRY_BYTES;
     }
     return { code: CHUNK_MATL, flags: 0, bytes };
@@ -416,7 +458,29 @@ export function writeDrft(source) {
      * same asset less its textures rather than a refusal. Moving it earlier in the file changes
      * nothing about that, because a chunk is found through the table rather than by position.
      */
-    const chunks = [buildHead(source.head, source.meshes, source.instances)];
+    const kit = new Set(source.kit ?? []);
+    checkKit(source.kit ?? [], source.meshes.length);
+    source.meshes.forEach((slot, ordinal) => {
+        if (!isAssembly(slot))
+            return;
+        checkAssembly(slot, `mesh ${ordinal}`);
+        checkCopies(slot, ordinal, kit, (o) => {
+            const piece = source.meshes[o];
+            return piece === undefined || isAssembly(piece) ? undefined : piece;
+        });
+    });
+    for (const o of kit) {
+        if (isAssembly(source.meshes[o])) {
+            throw new DrftError(`mesh ${o} is a kit piece and an assembly; a piece is vertices`);
+        }
+        if ((source.instances ?? []).some((g) => g.mesh === o)) {
+            throw new DrftError(`mesh ${o} is a kit piece and is placed by INST`);
+        }
+        if ((source.regions ?? []).some((r) => regionNames(r, o))) {
+            throw new DrftError(`mesh ${o} is a kit piece and a region's; a piece is drawn only as copies`);
+        }
+    }
+    const chunks = [buildHead(source.head, source.meshes, source.instances, kit)];
     /*
      * The outline first, ahead of even the paint. It is the one thing that puts a recognisable
      * whole object on screen, it is a few hundred kilobytes against tens of megabytes, and the
@@ -466,6 +530,11 @@ export function writeDrft(source) {
             bytes: buildInstances(source.instances),
         });
     }
+    /* The kit ahead of the geometry, for the placements' reason: a streaming consumer must know a
+       mesh is a piece before it lands, or it has already drawn it at the origin. */
+    if (kit.size > 0) {
+        chunks.push({ code: CHUNK_KITS, flags: CHUNK_REQUIRED, bytes: buildKit(source.kit ?? []) });
+    }
     /* Small, and ahead of the geometry, so a streaming consumer can place its lamps early. */
     if ((source.lights?.length ?? 0) > 0) {
         chunks.push({ code: CHUNK_LITE, flags: 0, bytes: buildLights(source.lights ?? []) });
@@ -494,7 +563,23 @@ export function writeDrft(source) {
     if (source.entities !== undefined) {
         chunks.push({ code: CHUNK_ENTS, flags: 0, bytes: buildEnts(source.entities) });
     }
+    if (source.texturesFirst === true) {
+        for (const texture of source.textures ?? [])
+            chunks.push(buildTexture(texture));
+    }
+    const regionsBefore = planRegions(source.regions ?? [], source.meshes.length, (m) => {
+        const mesh = source.meshes[m];
+        return mesh !== undefined && isAssembly(mesh) ? mesh.pieces : undefined;
+    });
+    for (const group of source.instances ?? []) {
+        if ((source.regions ?? []).some((r) => regionNames(r, group.mesh))) {
+            throw new DrftError(`mesh ${group.mesh} is placed by INST and is also a region's`);
+        }
+    }
     source.meshes.forEach((mesh, ordinal) => {
+        for (const region of regionsBefore[ordinal] ?? []) {
+            chunks.push({ code: CHUNK_REGN, flags: CHUNK_REQUIRED, bytes: buildRegion(region) });
+        }
         /*
          * **Its deltas immediately before it, not after.** A streaming consumer uploads a mesh the
          * moment its chunk lands, so deltas arriving afterwards are deltas for geometry already on the
@@ -502,6 +587,10 @@ export function writeDrft(source) {
          * them in hand when it builds. The mesh ordinal in the payload still does the pairing, so a
          * reader meeting them in another order is unaffected.
          */
+        if (isAssembly(mesh)) {
+            chunks.push({ code: CHUNK_MSHC, flags: CHUNK_REQUIRED, bytes: buildAssembly(mesh) });
+            return;
+        }
         if (mesh.morphTargets !== undefined && mesh.morphTargetCount !== undefined) {
             chunks.push({
                 code: CHUNK_MORP,
@@ -521,8 +610,16 @@ export function writeDrft(source) {
             chunks.push(buildMesh(mesh));
         }
     });
-    for (const texture of source.textures ?? [])
-        chunks.push(buildTexture(texture));
+    for (const region of regionsBefore[source.meshes.length] ?? []) {
+        chunks.push({ code: CHUNK_REGN, flags: CHUNK_REQUIRED, bytes: buildRegion(region) });
+    }
+    if (source.lightVolume !== undefined) {
+        chunks.push({ code: CHUNK_LVOL, flags: 0, bytes: buildLightVolume(source.lightVolume) });
+    }
+    if (source.texturesFirst !== true) {
+        for (const texture of source.textures ?? [])
+            chunks.push(buildTexture(texture));
+    }
     /* One `SUBS` for the file, and only where something was labelled — an empty chunk would cost
        sixteen bytes to say nothing, and rule 2 already covers its absence. */
     if ((source.substances?.length ?? 0) > 0) {

package/dist/index.d.ts

@@ -24,6 +24,15 @@ export { buildInstances, readInstances } from './drftInstances.ts';
 export { buildLights, readLights } from './drftLights.ts';
 export type { DrftLight, DrftLightKind } from './drftLights.ts';
 export type { DrftInstanceGroup } from './drftInstances.ts';
+export { REGION_MAX_LEVELS, RegionLedger, buildRegion, planRegions, readRegion, } from './drftRegions.ts';
+export { ATTR_CHANNEL, ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_LAYERS, ATTR_RELIEF, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_TANGENT, ATTR_UVS, } from './drftFormat.ts';
+export { ASSEMBLY_ATTRIBUTES, COPY_MATRIX_FLOATS, COPY_UV_FLOATS, SURFACE, SURFACE_FLOATS, buildAssembly, buildKit, checkAssembly, checkCopies, isAssembly, readAssembly, readKit, } from './drftAssembly.ts';
+export type { DrftAssembly } from './drftAssembly.ts';
+export { assemblyBounds, expandAssembly } from './assemble.ts';
+export type { PieceLookup } from './assemble.ts';
+export type { DrftRegion, DrftRegionCollision, DrftRegionLevel } from './drftRegions.ts';
+export { buildLightVolume, readLightVolume } from './drftLightVolume.ts';
+export type { DrftLightVolume } from './drftLightVolume.ts';
 export { buildDtex, readDtex, DTEX_ADDRESS_MODES, DTEX_MAX_TILES, DTEX_REGISTERS } from './dtex.ts';
 export type { DtexEntry, DtexMaterial } from './dtex.ts';
 export { buildNavm, readNavm } from './navm.ts';

package/dist/index.js

@@ -23,6 +23,13 @@ export { MAX_COLLIDER_HULLS, MAX_COLLIDER_POINTS, buildColliders, readColliders,
 /* Meshes drawn many times, one matrix a copy, as the baker finds merged copies again. */
 export { buildInstances, readInstances } from './drftInstances.js';
 export { buildLights, readLights } from './drftLights.js';
+export { REGION_MAX_LEVELS, RegionLedger, buildRegion, planRegions, readRegion, } from './drftRegions.js';
+/* A mesh carried as painted copies of kit pieces, expanded where it is needed. The attribute bits
+   are a MESH's, which is what an assembly declares its optional arrays with. */
+export { ATTR_CHANNEL, ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_LAYERS, ATTR_RELIEF, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_TANGENT, ATTR_UVS, } from './drftFormat.js';
+export { ASSEMBLY_ATTRIBUTES, COPY_MATRIX_FLOATS, COPY_UV_FLOATS, SURFACE, SURFACE_FLOATS, buildAssembly, buildKit, checkAssembly, checkCopies, isAssembly, readAssembly, readKit, } from './drftAssembly.js';
+export { assemblyBounds, expandAssembly } from './assemble.js';
+export { buildLightVolume, readLightVolume } from './drftLightVolume.js';
 /*
  * **`DTEX`: a material as a decode program over a latent, rather than as pictures.** The chunk
  * carries no semantics — this package is the container and does not know what a channel means —

package/dist/meshData.d.ts

@@ -106,6 +106,25 @@ export interface MeshData {
      * separates asphalt from plaster, and the pass states it: see `Renderer.setSurfaceRelief`.
      */
     relief?: Float32Array;
+    /**
+     * Which image of a texture array each vertex's face wears: one whole number a vertex, 0 the first
+     * layer. Absent means layer 0, which is the only layer a plain texture has.
+     *
+     * **What it is for is a merged mesh wearing many images in one draw.** A block of forty buildings
+     * with forty facades is forty materials — forty draws, forty material changes — when each image
+     * is its own texture; with the facades as the layers of one array and each face naming its layer,
+     * it is one. `Renderer.createSurfaceTextureArray` builds the array, and every map of a material
+     * (albedo, normal, ORM, emissive) is read at the same layer, so an albedo and its emissive twin
+     * share an index.
+     *
+     * **It travels in the texture-coordinate attribute, as its third component**, because all
+     * sixteen of WebGL2's guaranteed vertex locations are spent in the instanced variant. So it needs
+     * `uvs` beside it and is refused without them: a layer with no coordinates addresses nothing.
+     *
+     * Whole numbers, checked, because the shader rounds to the nearest layer and a 1.5 would land on
+     * whichever side rounding favoured on that device.
+     */
+    layers?: Float32Array;
     /**
      * Four floats per vertex, and the only attribute whose lanes mean four different things.
      *

package/dist/meshData.js

@@ -50,6 +50,21 @@ export function validateMeshData(data) {
     check('grain', data.grain, 1);
     check('relief', data.relief, 1);
     check('channel', data.channel, 4);
+    check('layers', data.layers, 1);
+    if (data.layers !== undefined) {
+        if (data.uvs === undefined) {
+            throw new Error('Mesh: layers without uvs — a texture-array layer travels as the third texture coordinate, ' +
+                'so a mesh that names layers has to supply the two it rides with');
+        }
+        const layers = data.layers;
+        for (let v = 0; v < layers.length; v++) {
+            const layer = layers[v];
+            if (!(layer >= 0) || Math.floor(layer) !== layer) {
+                throw new Error(`Mesh: layer ${layer} at vertex ${v} — a texture-array layer is a whole number at or ` +
+                    'above zero, and anything else lands on whichever layer the device rounds it to');
+            }
+        }
+    }
     /*
      * `tangents` was declared optional on 2026-08-22 and was not checked here until 2026-08-25, which
      * made the widest optional attribute in the format the one a short buffer could reach a driver

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/drft",
-  "version": "4.4.2",
+  "version": "4.6.0",
   "description": "The .drft container: a streaming format for baked 3D scenes",
   "license": "Apache-2.0",
   "type": "module",
@@ -27,9 +27,9 @@
   ],
   "sideEffects": false,
   "devDependencies": {
-    "@driftengine/core": "4.4.2",
-    "@driftengine/entities": "4.4.2",
-    "@driftengine/texture": "4.4.2"
+    "@driftengine/core": "4.6.0",
+    "@driftengine/entities": "4.6.0",
+    "@driftengine/texture": "4.6.0"
   },
   "author": "Drift Technologies",
   "repository": {

package/src/assemble.ts

@@ -0,0 +1,268 @@
+/**
+ * An assembly expanded into the mesh it describes: every copy's piece through its matrix, painted
+ * by its surface, its texture coordinates stretched as the copy says.
+ *
+ * **Positions by the matrix, normals by its inverse transpose**, so a slope stretched along one
+ * axis stays perpendicular to itself rather than leaning with the stretch. **A copy that mirrors
+ * — a negative determinant — winds its triangles back** and flips its tangent's handedness, so its
+ * faces still wind counter-clockwise seen from outside and a mirrored texture still lights the
+ * right way up. Tangents follow the matrix, since a tangent is a direction along the surface.
+ *
+ * **A coordinate is stretched along the piece's own tangent**: u by `|uStretch ⊙ t|` for the
+ * piece's unit tangent t, v the same along its bitangent, then offset. That is what lets one unit
+ * box serve every box in a city: its face coordinates run 0..1, and a copy 13 m by 4 m carrying
+ * stretches of size over tile repeats its facade in metres on every face. What it gives up is a
+ * stretch that varies across one face — a cone's side, where the circumference shrinks up the
+ * slope — which comes out as the stretch at each vertex's own tangent, and exact only where the
+ * piece's coordinates are linear in its surface.
+ *
+ * One allocation per output array, sized by a first pass over the copies.
+ */
+import {
+  COPY_MATRIX_FLOATS,
+  COPY_UV_FLOATS,
+  SURFACE,
+  SURFACE_FLOATS,
+  determinant,
+} from './drftAssembly.ts';
+import type { DrftAssembly } from './drftAssembly.ts';
+import {
+  ATTR_EMISSIVE_COLOR,
+  ATTR_GRAIN,
+  ATTR_LAYERS,
+  ATTR_RELIEF,
+  ATTR_ROUGHNESS,
+  ATTR_SPECULAR,
+  ATTR_TANGENT,
+  ATTR_UVS,
+  ATTR_CHANNEL,
+  DrftError,
+} from './drftFormat.ts';
+import type { MeshData } from './meshData.ts';
+
+/** Finds a kit piece by mesh ordinal. */
+export type PieceLookup = (ordinal: number) => MeshData;
+
+function pieceOf(piece: PieceLookup, assembly: DrftAssembly, c: number): MeshData {
+  const mesh = piece(assembly.pieces[c] as number);
+  const textured = (assembly.attributes & ATTR_UVS) !== 0;
+  if (textured && (mesh.uvs === undefined || mesh.tangents === undefined)) {
+    throw new DrftError(
+      `piece ${assembly.pieces[c]} has no ${mesh.uvs === undefined ? 'texture coordinates' : 'tangents'}, and a textured assembly copies it`,
+    );
+  }
+  if ((assembly.attributes & ATTR_TANGENT) !== 0 && mesh.tangents === undefined) {
+    throw new DrftError(
+      `piece ${assembly.pieces[c]} has no tangents, and the assembly carries them`,
+    );
+  }
+  if ((assembly.attributes & ATTR_CHANNEL) !== 0 && mesh.channel === undefined) {
+    throw new DrftError(`piece ${assembly.pieces[c]} has no channel, and the assembly sways`);
+  }
+  return mesh;
+}
+
+export function expandAssembly(assembly: DrftAssembly, piece: PieceLookup): MeshData {
+  const { attributes, surfaces, surfaceOf, transforms, uv } = assembly;
+  const copies = assembly.pieces.length;
+  let vertices = 0;
+  let indexCount = 0;
+  for (let c = 0; c < copies; c++) {
+    const mesh = pieceOf(piece, assembly, c);
+    vertices += mesh.positions.length / 3;
+    indexCount += mesh.indices.length;
+  }
+  const has = (bit: number): boolean => (attributes & bit) !== 0;
+  const out: MeshData = {
+    positions: new Float32Array(vertices * 3),
+    normals: new Float32Array(vertices * 3),
+    colors: new Float32Array(vertices * 3),
+    emissive: new Float32Array(vertices),
+    indices: new Uint32Array(indexCount),
+  };
+  if (has(ATTR_SPECULAR)) out.specular = new Float32Array(vertices);
+  if (has(ATTR_UVS)) out.uvs = new Float32Array(vertices * 2);
+  if (has(ATTR_EMISSIVE_COLOR)) out.emissiveColor = new Float32Array(vertices * 3);
+  if (has(ATTR_ROUGHNESS)) out.roughness = new Float32Array(vertices);
+  if (has(ATTR_GRAIN)) out.grain = new Float32Array(vertices);
+  if (has(ATTR_RELIEF)) out.relief = new Float32Array(vertices);
+  if (has(ATTR_TANGENT)) out.tangents = new Float32Array(vertices * 4);
+  if (has(ATTR_LAYERS)) out.layers = new Float32Array(vertices);
+  if (has(ATTR_CHANNEL)) out.channel = new Float32Array(vertices * 4);
+
+  let v0 = 0;
+  let i0 = 0;
+  for (let c = 0; c < copies; c++) {
+    const mesh = pieceOf(piece, assembly, c);
+    const m = c * COPY_MATRIX_FLOATS;
+    const t = transforms;
+    const [a, b, cc, d, e, f, g, h, k] = [
+      t[m] as number,
+      t[m + 1] as number,
+      t[m + 2] as number,
+      t[m + 3] as number,
+      t[m + 4] as number,
+      t[m + 5] as number,
+      t[m + 6] as number,
+      t[m + 7] as number,
+      t[m + 8] as number,
+    ];
+    const [tx, ty, tz] = [t[m + 9] as number, t[m + 10] as number, t[m + 11] as number];
+    const det = determinant(t, m);
+    /* The inverse transpose is the cofactor matrix over the determinant. With columns (a b cc),
+       (d e f), (g h k) the matrix's rows are (a d g), (b e h), (cc f k), and nRC is the cofactor of
+       row R, column C — not of C, R, which would be the plain inverse. */
+    const n00 = (e * k - f * h) / det;
+    const n01 = (cc * h - b * k) / det;
+    const n02 = (b * f - cc * e) / det;
+    const n10 = (f * g - d * k) / det;
+    const n11 = (a * k - cc * g) / det;
+    const n12 = (cc * d - a * f) / det;
+    const n20 = (d * h - e * g) / det;
+    const n21 = (b * g - a * h) / det;
+    const n22 = (a * e - b * d) / det;
+    const hand = det < 0 ? -1 : 1;
+    const s = (surfaceOf[c] as number) * SURFACE_FLOATS;
+    const u = c * COPY_UV_FLOATS;
+    const count = mesh.positions.length / 3;
+    const p = mesh.positions;
+    const n = mesh.normals;
+    const tan = mesh.tangents;
+    const tex = mesh.uvs;
+    for (let i = 0; i < count; i++) {
+      const o = v0 + i;
+      const px = p[i * 3] as number;
+      const py = p[i * 3 + 1] as number;
+      const pz = p[i * 3 + 2] as number;
+      out.positions[o * 3] = a * px + d * py + g * pz + tx;
+      out.positions[o * 3 + 1] = b * px + e * py + h * pz + ty;
+      out.positions[o * 3 + 2] = cc * px + f * py + k * pz + tz;
+      const nx = n[i * 3] as number;
+      const ny = n[i * 3 + 1] as number;
+      const nz = n[i * 3 + 2] as number;
+      let wx = n00 * nx + n01 * ny + n02 * nz;
+      let wy = n10 * nx + n11 * ny + n12 * nz;
+      let wz = n20 * nx + n21 * ny + n22 * nz;
+      const nl = Math.hypot(wx, wy, wz) || 1;
+      wx /= nl;
+      wy /= nl;
+      wz /= nl;
+      out.normals[o * 3] = wx;
+      out.normals[o * 3 + 1] = wy;
+      out.normals[o * 3 + 2] = wz;
+      out.colors[o * 3] = surfaces[s + SURFACE.color] as number;
+      out.colors[o * 3 + 1] = surfaces[s + SURFACE.color + 1] as number;
+      out.colors[o * 3 + 2] = surfaces[s + SURFACE.color + 2] as number;
+      out.emissive[o] = surfaces[s + SURFACE.emissive] as number;
+      if (out.specular) out.specular[o] = surfaces[s + SURFACE.specular] as number;
+      if (out.emissiveColor) {
+        out.emissiveColor[o * 3] = surfaces[s + SURFACE.emissiveColor] as number;
+        out.emissiveColor[o * 3 + 1] = surfaces[s + SURFACE.emissiveColor + 1] as number;
+        out.emissiveColor[o * 3 + 2] = surfaces[s + SURFACE.emissiveColor + 2] as number;
+      }
+      if (out.roughness) out.roughness[o] = surfaces[s + SURFACE.roughness] as number;
+      if (out.grain) out.grain[o] = surfaces[s + SURFACE.grain] as number;
+      if (out.relief) out.relief[o] = surfaces[s + SURFACE.relief] as number;
+      if (out.layers) out.layers[o] = surfaces[s + SURFACE.layer] as number;
+      /* Sway, sky and opacity are the piece's own: shape, not paint. */
+      if (out.channel && mesh.channel !== undefined) {
+        for (let lane = 0; lane < 4; lane++) {
+          out.channel[o * 4 + lane] = mesh.channel[i * 4 + lane] as number;
+        }
+      }
+      if (tan !== undefined && (out.tangents !== undefined || out.uvs !== undefined)) {
+        const qx = tan[i * 4] as number;
+        const qy = tan[i * 4 + 1] as number;
+        const qz = tan[i * 4 + 2] as number;
+        const qw = tan[i * 4 + 3] as number;
+        if (out.tangents) {
+          let rx = a * qx + d * qy + g * qz;
+          let ry = b * qx + e * qy + h * qz;
+          let rz = cc * qx + f * qy + k * qz;
+          const rl = Math.hypot(rx, ry, rz) || 1;
+          rx /= rl;
+          ry /= rl;
+          rz /= rl;
+          out.tangents[o * 4] = rx;
+          out.tangents[o * 4 + 1] = ry;
+          out.tangents[o * 4 + 2] = rz;
+          out.tangents[o * 4 + 3] = qw * hand;
+        }
+        if (out.uvs && tex !== undefined) {
+          /* The piece's own directions for u and v: its tangent, and the bitangent n × t · w. */
+          const ql = Math.hypot(qx, qy, qz) || 1;
+          const bx = (ny * qz - nz * qy) * qw;
+          const by = (nz * qx - nx * qz) * qw;
+          const bz = (nx * qy - ny * qx) * qw;
+          const bl = Math.hypot(bx, by, bz) || 1;
+          const su = Math.hypot(
+            ((uv[u] as number) * qx) / ql,
+            ((uv[u + 1] as number) * qy) / ql,
+            ((uv[u + 2] as number) * qz) / ql,
+          );
+          const sv = Math.hypot(
+            ((uv[u + 3] as number) * bx) / bl,
+            ((uv[u + 4] as number) * by) / bl,
+            ((uv[u + 5] as number) * bz) / bl,
+          );
+          out.uvs[o * 2] = (tex[i * 2] as number) * su + (uv[u + 6] as number);
+          out.uvs[o * 2 + 1] = (tex[i * 2 + 1] as number) * sv + (uv[u + 7] as number);
+        }
+      }
+    }
+    const idx = mesh.indices;
+    for (let j = 0; j + 2 < idx.length; j += 3) {
+      out.indices[i0 + j] = v0 + (idx[j] as number);
+      /* A mirrored copy winds back, or its faces turn inside out. */
+      out.indices[i0 + j + 1] = v0 + (idx[hand < 0 ? j + 2 : j + 1] as number);
+      out.indices[i0 + j + 2] = v0 + (idx[hand < 0 ? j + 1 : j + 2] as number);
+    }
+    v0 += count;
+    i0 += idx.length;
+  }
+  return out;
+}
+
+/** Min xyz then max xyz of every copy: its piece's box through its matrix, corner by corner. */
+export function assemblyBounds(
+  assembly: DrftAssembly,
+  piece: PieceLookup,
+  out: Float32Array = new Float32Array(6),
+): Float32Array {
+  out.set([Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity]);
+  for (let c = 0; c < assembly.pieces.length; c++) {
+    const p = piece(assembly.pieces[c] as number).positions;
+    let lx = Infinity;
+    let ly = Infinity;
+    let lz = Infinity;
+    let hx = -Infinity;
+    let hy = -Infinity;
+    let hz = -Infinity;
+    for (let i = 0; i + 2 < p.length; i += 3) {
+      lx = Math.min(lx, p[i] as number);
+      ly = Math.min(ly, p[i + 1] as number);
+      lz = Math.min(lz, p[i + 2] as number);
+      hx = Math.max(hx, p[i] as number);
+      hy = Math.max(hy, p[i + 1] as number);
+      hz = Math.max(hz, p[i + 2] as number);
+    }
+    if (lx > hx) continue;
+    const m = c * COPY_MATRIX_FLOATS;
+    const t = assembly.transforms;
+    for (let corner = 0; corner < 8; corner++) {
+      const x = corner & 1 ? hx : lx;
+      const y = corner & 2 ? hy : ly;
+      const z = corner & 4 ? hz : lz;
+      for (let axis = 0; axis < 3; axis++) {
+        const w =
+          (t[m + axis] as number) * x +
+          (t[m + 3 + axis] as number) * y +
+          (t[m + 6 + axis] as number) * z +
+          (t[m + 9 + axis] as number);
+        if (w < (out[axis] as number)) out[axis] = w;
+        if (w > (out[axis + 3] as number)) out[axis + 3] = w;
+      }
+    }
+  }
+  return out;
+}