@driftengine/assets 4.8.2 → 4.8.4

package/dist/ddsHeader.js

@@ -0,0 +1,119 @@
+/**
+ * A DDS header, read as far as which blocks follow it: the block format and the colour space its
+ * author declared, in either header spelling, the size, the stored mip count, and where the surface
+ * starts. Shared by `dds.ts`, which decodes the blocks, and `ddsBlocks.ts`, which keeps them.
+ *
+ * **Two spellings of one thing.** A classic header names the format in the four characters at byte
+ * 84 and the surface follows at 128; a `DX10` header puts `DX10` there instead and states the real
+ * format in a 20-byte extension, so the surface starts at 148. Nothing else differs — the blocks are
+ * the same blocks — which is why both resolve to one name and one offset.
+ *
+ * What it refuses, by name: BC6H, signed BC4 and BC5, the premultiplied DXT2 and DXT4, and from a
+ * `DX10` header a cube map, an array or anything but a plain 2D texture. A format identified and
+ * declined is worth more than one half-decoded, which is `recognise.ts`'s principle applied one
+ * level down.
+ */
+import { DrftError } from '@driftengine/drft';
+export const HEADER_BYTES = 128;
+/** `DDS_HEADER_DXT10`: the extension a `DX10` FourCC puts between the header and the surface. */
+const DX10_EXTENSION_BYTES = 20;
+/** `DDPF_FOURCC`: the pixel format names a compression rather than describing channels. */
+export const DDPF_FOURCC = 0x4;
+/** Whether these bytes are a DDS at all. The magic, and nothing inferred from a file name. */
+export function isDds(bytes) {
+    return (bytes.length >= 4 &&
+        bytes[0] === 0x44 &&
+        bytes[1] === 0x44 &&
+        bytes[2] === 0x53 &&
+        bytes[3] === 0x20);
+}
+/**
+ * The DXGI block formats, and which of them declare sRGB.
+ *
+ * **sRGB is a statement about how the values are *read* rather than about how they are stored.**
+ * BC3 announced as `DXGI_FORMAT_BC3_UNORM_SRGB` is bit for bit the BC3 announced as `DXT5`: the
+ * same blocks and the same mip chain. Measured from outside on one bundle's paint texture —
+ * 5,592,580 bytes against 5,592,560 for the classic spelling of the same 2048² chain, which is
+ * 148 + 5,592,432 against 128 + 5,592,432. The typeless spellings read as linear.
+ *
+ * **What is deliberately absent.** `BC4_SNORM` (81) and `BC5_SNORM` (84), whose values are signed,
+ * and BC6H (94–96), whose values are half floats — mapping any of them would decode to wrong numbers
+ * rather than to an error, which is the one failure this reader is written to avoid.
+ */
+const DXGI_BLOCK = {
+    70: ['bc1', false],
+    71: ['bc1', false],
+    72: ['bc1', true],
+    73: ['bc2', false],
+    74: ['bc2', false],
+    75: ['bc2', true],
+    76: ['bc3', false],
+    77: ['bc3', false],
+    78: ['bc3', true],
+    79: ['bc4', false],
+    80: ['bc4', false],
+    82: ['bc5', false],
+    83: ['bc5', false],
+    97: ['bc7', false],
+    98: ['bc7', false],
+    99: ['bc7', true],
+};
+/** The classic spellings. BC7 has none: only a `DX10` header can name it. */
+const FOURCC_BLOCK = {
+    DXT1: 'bc1',
+    DXT3: 'bc2',
+    DXT5: 'bc3',
+    ATI1: 'bc4',
+    BC4U: 'bc4',
+    ATI2: 'bc5',
+    BC5U: 'bc5',
+};
+/**
+ * The surface a block-compressed DDS declares. The caller has checked the magic, the length of the
+ * classic header and that the pixel format names a compression.
+ *
+ * **What a `DX10` header can say that a reader must refuse.** `resourceDimension` other than 3
+ * (`TEXTURE2D`), `miscFlag` bit 2 (a cube map) or an `arraySize` above 1. Taking one would hand the
+ * caller six faces or twenty slices claiming to be a single surface — a picture rather than an
+ * error.
+ */
+export function readDdsSurface(bytes, view) {
+    const height = view.getUint32(12, true);
+    const width = view.getUint32(16, true);
+    const mipCount = Math.max(1, view.getUint32(28, true));
+    const fourcc = String.fromCharCode(bytes[84], bytes[85], bytes[86], bytes[87]);
+    if (fourcc !== 'DX10') {
+        const format = FOURCC_BLOCK[fourcc];
+        if (format === undefined) {
+            throw new DrftError(`dds: "${fourcc}" is not a format this reader decodes. It reads BC1 (DXT1), BC2 (DXT3), ` +
+                'BC3 (DXT5), BC4 (ATI1) and BC5 (ATI2), and BC7 behind a DX10 header. Convert the ' +
+                'texture to PNG, or re-export it as one of those.');
+        }
+        return { format, srgb: false, width, height, mipCount, dataAt: HEADER_BYTES, named: fourcc };
+    }
+    const dataAt = HEADER_BYTES + DX10_EXTENSION_BYTES;
+    if (bytes.length < dataAt) {
+        throw new DrftError('dds: a DX10 header is declared and the twenty-byte extension is not there');
+    }
+    const dxgi = view.getUint32(HEADER_BYTES, true);
+    const dimension = view.getUint32(HEADER_BYTES + 4, true);
+    const miscFlag = view.getUint32(HEADER_BYTES + 8, true);
+    const arraySize = view.getUint32(HEADER_BYTES + 12, true);
+    if (dimension !== 3) {
+        throw new DrftError(`dds: this DX10 surface declares resourceDimension ${dimension}, and only 3 (a plain 2D ` +
+            'texture) is read here. A 1D or volume texture is a different thing wearing the same header.');
+    }
+    if ((miscFlag & 0x4) !== 0) {
+        throw new DrftError('dds: this is a cube map, and only a plain 2D texture is read here.');
+    }
+    if (arraySize > 1) {
+        throw new DrftError(`dds: this is a texture array of ${arraySize}, and only a plain 2D texture is read here.`);
+    }
+    const entry = DXGI_BLOCK[dxgi];
+    if (entry === undefined) {
+        throw new DrftError(`dds: DXGI format ${dxgi} is not one this reader decodes. It reads BC1 to BC5 and BC7, ` +
+            'unsigned. Convert the texture to PNG, or re-export it as one of those.');
+    }
+    const [format, srgb] = entry;
+    return { format, srgb, width, height, mipCount, dataAt, named: `DXGI ${dxgi}` };
+}

package/dist/drftLoader.d.ts

@@ -265,6 +265,9 @@ export declare class DrftLoader {
     private boundCount;
     private readonly singles;
     private readonly images;
+    /** Started at the first BC texture that has to be decoded, and only then. See `bcLoad.ts`. */
+    private bcDecoder;
+    private warnedBc;
     private readonly chunks;
     private materials;
     /**
@@ -510,6 +513,21 @@ export declare class DrftLoader {
      * silently reassigning an image to a different surface.
      */
     private rebuildTextures;
+    /**
+     * A BC texture: its blocks kept, to go up as they are where this device samples them, or decoded
+     * off the main thread where it does not — which on a phone is every one. See `bcLoad.ts`.
+     *
+     * **A consumer taking images through `onImage` gets a decoded image either way**, as an ordinary
+     * picture: what it builds from them is its own, and a texture array of bitmaps cannot hold blocks.
+     * Like every image, a BC texture fails on its own and its surfaces draw untextured.
+     */
+    private acceptBc;
+    /**
+     * What goes to `createSurfaceTexture`: the image as it is, unless it is blocks this device cannot
+     * take in the colour space the slot reads — a material read after its texture arrived can change
+     * that — in which case they are decoded here, on the spot.
+     */
+    private uploadable;
     /** One place that writes the progress, so every field stays consistent with the phase. */
     private set;
 }

package/dist/drftLoader.js

@@ -2,6 +2,10 @@
 import { MeshBuilder, concatMeshes, placeMesh } from '@driftengine/core';
 import { placeFields } from './fieldPlacement.js';
 import { TextureSet, textureColorSpaces } from './drftTextures.js';
+import { bcPlan, createBcDecoder } from './bcLoad.js';
+import { decodeBc } from './bcDecode.js';
+import { isCompressedSource, uploadsCompressed } from '@driftengine/core';
+import { CODEC_BC, codecName, readBcPayload } from '@driftengine/drft';
 import { drawKeyOf, resolveDrawGrouping } from './drawKey.js';
 import { streamDrft, CODEC_JPEG, CODEC_PNG, CODEC_RAW, CODEC_WEBP, DrftError, expandAssembly, } from '@driftengine/drft';
 import { RegionStore, fitCopies } from './regionStore.js';
@@ -99,6 +103,9 @@ export class DrftLoader {
     boundCount = 0;
     singles = [];
     images = [];
+    /** Started at the first BC texture that has to be decoded, and only then. See `bcLoad.ts`. */
+    bcDecoder = null;
+    warnedBc = false;
     chunks = [];
     materials = [];
     /**
@@ -567,6 +574,10 @@ export class DrftLoader {
                      * visibly wrong, which a consumer's loading bar reported to a person as finished.
                      */
                     this.set({ phase: 'textures' });
+                    if (texture.codec === CODEC_BC) {
+                        this.acceptBc(texture, ordinal);
+                        return;
+                    }
                     /*
                      * Decoded through the browser's own image path, so the engine ships no decoder, and
                      * **each one fails on its own**: a texture is the part of an asset most likely to be
@@ -716,7 +727,7 @@ export class DrftLoader {
                 if (take === undefined)
                     this.rebuildTextures(ordinal);
                 else
-                    take(this.chunks[ordinal]?.name ?? '', this.images[ordinal] ?? null);
+                    take(this.chunks[ordinal]?.name ?? '', bitmapOf(this.images[ordinal] ?? null));
                 /*
                  * Counted here, once, and only for the image itself.
                  *
@@ -789,6 +800,8 @@ export class DrftLoader {
             return;
         this.disposed = true;
         this.regionStore.dispose();
+        this.bcDecoder?.dispose();
+        this.bcDecoder = null;
         /*
          * Everything this class ever made, each disposed once.
          *
@@ -1175,7 +1188,8 @@ export class DrftLoader {
          */
         const existing = previous?.at(ordinal) ?? null;
         const arrived = this.images[ordinal] ?? null;
-        if (existing !== null && arrived !== null) {
+        /* Blocks never arrive as a replacement: a BC texture has no preview to replace. */
+        if (existing !== null && arrived !== null && !isCompressedSource(arrived)) {
             this.renderer.updateSurfaceTexture(existing, arrived);
             return;
         }
@@ -1188,18 +1202,85 @@ export class DrftLoader {
             const held = previous?.at(at) ?? null;
             if (held !== null)
                 return held;
-            const bitmap = this.images[at] ?? null;
-            if (bitmap === null)
+            const image = this.images[at] ?? null;
+            if (image === null)
                 return null;
             const anisotropy = this.options.anisotropy;
             const wrap = this.options.textureWrap;
-            return this.renderer.createSurfaceTexture(bitmap, {
+            const colorSpace = spaces[at] ?? 'linear';
+            return this.renderer.createSurfaceTexture(this.uploadable(image, colorSpace === 'srgb'), {
                 ...(anisotropy === undefined ? {} : { anisotropy }),
                 ...(wrap === undefined ? {} : { wrap }),
-                colorSpace: spaces[at] ?? 'linear',
+                colorSpace,
             });
         });
     }
+    /**
+     * A BC texture: its blocks kept, to go up as they are where this device samples them, or decoded
+     * off the main thread where it does not — which on a phone is every one. See `bcLoad.ts`.
+     *
+     * **A consumer taking images through `onImage` gets a decoded image either way**, as an ordinary
+     * picture: what it builds from them is its own, and a texture array of bitmaps cannot hold blocks.
+     * Like every image, a BC texture fails on its own and its surfaces draw untextured.
+     */
+    acceptBc(texture, ordinal) {
+        const done = (image) => {
+            if (this.disposed)
+                return;
+            this.images[ordinal] = image;
+            this.sharp[ordinal] = true;
+            this.imageQueue.push(ordinal);
+        };
+        const failed = (error) => {
+            console.warn(`DrftLoader: image ${ordinal} did not decode; its surfaces stay untextured` +
+                ` (codec BC, ${texture.bytes.length} bytes, ${texture.width}x${texture.height})`, error);
+            done(null);
+        };
+        let image;
+        try {
+            image = readBcPayload(texture.width, texture.height, texture.bytes);
+        }
+        catch (error) {
+            failed(error);
+            return;
+        }
+        const asImage = this.options.onImage !== undefined;
+        const srgb = textureColorSpaces(this.materials, ordinal + 1)[ordinal] === 'srgb';
+        if (!asImage && bcPlan(image, srgb, this.renderer.compressedFormats) === 'blocks') {
+            done(image);
+            return;
+        }
+        if (this.bcDecoder === null)
+            this.bcDecoder = createBcDecoder();
+        const decoder = this.bcDecoder;
+        decoder
+            .decode(image, asImage)
+            .then(async (rgba) => {
+            /* Said once, where a worker could not be had or failed: a slower load nobody could
+               otherwise attribute. */
+            if (decoder.reason !== '' && !this.warnedBc) {
+                this.warnedBc = true;
+                console.warn(`DrftLoader: ${decoder.reason}`);
+            }
+            const pixels = imageDataOf(rgba, image.width, image.height);
+            done(asImage ? await createImageBitmap(pixels, AS_AUTHORED) : pixels);
+        })
+            .catch(failed);
+    }
+    /**
+     * What goes to `createSurfaceTexture`: the image as it is, unless it is blocks this device cannot
+     * take in the colour space the slot reads — a material read after its texture arrived can change
+     * that — in which case they are decoded here, on the spot.
+     */
+    uploadable(image, srgb) {
+        if (!isCompressedSource(image))
+            return image;
+        const { format, width, height } = image;
+        if (uploadsCompressed(format, srgb, width, height, this.renderer.compressedFormats)) {
+            return image;
+        }
+        return imageDataOf(decodeBc(format, width, height, image.levels[0]), width, height);
+    }
     /** One place that writes the progress, so every field stays consistent with the phase. */
     set(patch) {
         const next = { ...this.state, ...patch };
@@ -1283,6 +1364,14 @@ const AS_AUTHORED = {
     premultiplyAlpha: 'premultiply',
     colorSpaceConversion: 'none',
 };
+/** RGBA as an `ImageData`, which every upload path takes as it takes a bitmap. */
+function imageDataOf(rgba, width, height) {
+    return new ImageData(new Uint8ClampedArray(rgba.buffer, rgba.byteOffset, rgba.length), width, height);
+}
+/** The bitmap `onImage` is handed. Only bitmaps reach that path, BC decoded to one on the way. */
+function bitmapOf(image) {
+    return image === null || isCompressedSource(image) || 'data' in image ? null : image;
+}
 async function decodeImage(texture, longestSide) {
     /*
      * **A raw texture has no decoder, because it is already decoded.**
@@ -1308,8 +1397,9 @@ async function decodeImage(texture, longestSide) {
     }
     const type = imageTypeFor(texture.codec);
     if (type === null) {
-        throw new DrftError(`texture codec ${texture.codec} is not one this loader can decode; bake it again with a ` +
-            'current baker');
+        throw new DrftError(`texture codec ${codecName(texture.codec)} is not one this loader reads: a newer baker ` +
+            'wrote it, or the file is damaged. Update @driftengine/assets, or bake with the baker ' +
+            'that matches it');
     }
     const blob = new Blob([texture.bytes.slice()], { type });
     if (longestSide === undefined)

package/dist/fbx.js

@@ -27,7 +27,8 @@
 import { DrftError } from '@driftengine/drft';
 import { parseUpAxis } from './orient.js';
 import { FALLBACK_MATERIAL, readMaterials } from './fbxMaterial.js';
-import { bareName, indexObjects, readClips, readSkin, writeInfluences } from './fbxRig.js';
+import { bareName, indexObjects, readClips, readSkin } from './fbxRig.js';
+import { writeInfluences } from './influences.js';
 /** One value repeated per vertex, for a material constant this format has nowhere else to put. */
 function repeatTriple(count, value) {
     const out = new Float32Array(count * 3);
@@ -575,6 +576,16 @@ export function fbxToMeshes(buffer, inflate) {
             const outUvs = uvLayer === null ? null : [];
             const outJoints = skin === null ? null : [];
             const outWeights = skin === null ? null : [];
+            /* The fifth to eighth influences, kept only if some vertex needed them. See influences.ts. */
+            const outJoints2 = skin === null ? null : [];
+            const outWeights2 = skin === null ? null : [];
+            let secondInfluences = false;
+            const scratch = {
+                joints: new Float32Array(4),
+                weights: new Float32Array(4),
+                joints2: new Float32Array(4),
+                weights2: new Float32Array(4),
+            };
             const indices = [];
             /*
              * A mesh with no normals is not deduplicated, and that is the geometry speaking rather than
@@ -677,18 +688,23 @@ export function fbxToMeshes(buffer, inflate) {
                 outColors.push(r, g, b);
                 if (outUvs !== null)
                     outUvs.push(u, v);
-                if (outJoints !== null && outWeights !== null && skin !== null) {
-                    outJoints.push(0, 0, 0, 0);
-                    outWeights.push(0, 0, 0, 0);
-                    const scratchJoints = new Float32Array(4);
-                    const scratchWeights = new Float32Array(4);
-                    const report = writeInfluences(skin.influences.get(vertexIndex), scratchJoints, scratchWeights, 0);
-                    for (let k = 0; k < 4; k++) {
-                        outJoints[emitted * 4 + k] = scratchJoints[k];
-                        outWeights[emitted * 4 + k] = scratchWeights[k];
-                    }
+                if (outJoints !== null &&
+                    outWeights !== null &&
+                    outJoints2 !== null &&
+                    outWeights2 !== null &&
+                    skin !== null) {
+                    scratch.joints.fill(0);
+                    scratch.weights.fill(0);
+                    scratch.joints2.fill(0);
+                    scratch.weights2.fill(0);
+                    const report = writeInfluences(skin.influences.get(vertexIndex), scratch, 0);
+                    outJoints.push(...scratch.joints);
+                    outWeights.push(...scratch.weights);
+                    outJoints2.push(...scratch.joints2);
+                    outWeights2.push(...scratch.weights2);
                     droppedInfluences ||= report.dropped;
                     rescaledInfluences ||= report.rescaled;
+                    secondInfluences ||= report.second;
                 }
             }
             const count = positions.length / 3;
@@ -699,8 +715,8 @@ export function fbxToMeshes(buffer, inflate) {
                 computeFaceNormals(outPositions, normalsOut);
             }
             if (droppedInfluences) {
-                warnings.push(`${name}: a vertex is held by more than four joints; the four largest are kept and ` +
-                    `renormalised, because four is what the skinning palette reads.`);
+                warnings.push(`${name}: a vertex is held by more than eight joints; the eight largest are kept and ` +
+                    `renormalised, because eight is what the skinning palette reads.`);
             }
             if (rescaledInfluences) {
                 warnings.push(`${name}: skin weights did not sum to one and were normalised.`);
@@ -724,6 +740,9 @@ export function fbxToMeshes(buffer, inflate) {
                 ...(outJoints === null || outWeights === null
                     ? {}
                     : { joints: Float32Array.from(outJoints), weights: Float32Array.from(outWeights) }),
+                ...(outJoints2 === null || outWeights2 === null || !secondInfluences
+                    ? {}
+                    : { joints2: Float32Array.from(outJoints2), weights2: Float32Array.from(outWeights2) }),
             });
             perMesh.push(material);
         }

package/dist/fbxRig.d.ts

@@ -95,24 +95,6 @@ export declare function readSkin(objects: FbxObjects, geometryId: number,
  * readers of this format settle on, and for the same reason.
  */
 meshWorld: readonly number[], warnings: string[]): FbxSkin | null;
-/**
- * One control point's four influences, largest first, normalised, written into a caller's arrays.
- *
- * **Four is the shader's number and the file's is unbounded.** A rig authored with six influences
- * on a shoulder is ordinary, so the four largest are kept and renormalised rather than the first
- * four taken: dropping by *order* would discard whichever the exporter happened to write last,
- * which on a shoulder is as likely to be the dominant one as not.
- *
- * Returns true where something was dropped or rescaled, so the caller can say so once for the mesh
- * rather than once per vertex.
- */
-export declare function writeInfluences(influences: readonly {
-    joint: number;
-    weight: number;
-}[] | undefined, joints: Float32Array, weights: Float32Array, at: number): {
-    dropped: boolean;
-    rescaled: boolean;
-};
 /**
  * Every take in the file, as clips over the joints a skin named.
  *

package/dist/fbxRig.js

@@ -25,8 +25,6 @@
  */
 /** One second, in the integer unit `KeyTime` counts. FBX's own constant. */
 const KTIME_PER_SECOND = 46186158000;
-/** The most influences a vertex may carry, which is what the palette shader reads. */
-const MAX_INFLUENCES = 4;
 const IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 function findChild(node, name) {
     return node.children.find((child) => child.name === name);
@@ -296,41 +294,6 @@ meshWorld, warnings) {
     }
     return { joints, inverseBind, influences, modelOfJoint: order };
 }
-/**
- * One control point's four influences, largest first, normalised, written into a caller's arrays.
- *
- * **Four is the shader's number and the file's is unbounded.** A rig authored with six influences
- * on a shoulder is ordinary, so the four largest are kept and renormalised rather than the first
- * four taken: dropping by *order* would discard whichever the exporter happened to write last,
- * which on a shoulder is as likely to be the dominant one as not.
- *
- * Returns true where something was dropped or rescaled, so the caller can say so once for the mesh
- * rather than once per vertex.
- */
-export function writeInfluences(influences, joints, weights, at) {
-    if (influences === undefined || influences.length === 0)
-        return { dropped: false, rescaled: false };
-    const sorted = [...influences].sort((a, b) => b.weight - a.weight);
-    const kept = sorted.slice(0, MAX_INFLUENCES);
-    let sum = 0;
-    for (const influence of kept)
-        sum += influence.weight;
-    if (sum <= 0)
-        return { dropped: false, rescaled: false };
-    for (let i = 0; i < kept.length; i++) {
-        const influence = kept[i];
-        joints[at * MAX_INFLUENCES + i] = influence.joint;
-        weights[at * MAX_INFLUENCES + i] = influence.weight / sum;
-    }
-    let total = 0;
-    for (const influence of sorted)
-        total += influence.weight;
-    return {
-        dropped: sorted.length > MAX_INFLUENCES,
-        /* A tenth of a per cent, which is wider than float noise and narrower than an authoring slip. */
-        rescaled: Math.abs(total - 1) > 1e-3,
-    };
-}
 /** Euler degrees in the file's default XYZ order, as a quaternion. */
 function eulerToQuaternion(x, y, z) {
     const half = Math.PI / 360;

package/dist/gltf.js

@@ -21,6 +21,7 @@ import { generateTangents } from '@driftengine/core';
 import { MAX_MORPH_TARGETS } from '@driftengine/core';
 import { accessorFloats } from './gltfAccessor.js';
 import { readGltfSkins } from './gltfSkin.js';
+import { writeInfluences } from './influences.js';
 /** The engine's own roughness, for a material whose stated one cannot be believed. */
 const DEFAULT_ROUGHNESS = 0.4277;
 /** `TRIANGLES`. The only primitive mode a `MeshData` can express. */
@@ -959,20 +960,80 @@ deriveTangents = true) {
     }
     let joints;
     let weights;
-    const jointIndex = primitive.attributes['JOINTS_0'];
-    const weightIndex = primitive.attributes['WEIGHTS_0'];
-    if (skin !== undefined && jointIndex !== undefined && weightIndex !== undefined) {
-        joints = accessorFloats(doc, buffers, jointIndex, `${label} JOINTS_0`);
-        weights = accessorFloats(doc, buffers, weightIndex, `${label} WEIGHTS_0`);
-        for (let i = 0; i < joints.length; i++) {
-            const old = joints[i];
-            const moved = skin.remap[old];
-            if (moved === undefined) {
-                throw new DrftError(`gltf: ${label} weights a vertex to joint ${old}, and its skin has ${skin.remap.length}`);
+    let joints2;
+    let weights2;
+    if (skin !== undefined) {
+        /*
+         * Every `JOINTS_n`/`WEIGHTS_n` pair the primitive carries, remapped onto the sorted joints. One
+         * pair is what nearly every export writes and keeps the path it always had; more go through
+         * `writeInfluences`, which keeps the eight heaviest, heaviest first, across the two sets a mesh
+         * carries. See influences.ts.
+         */
+        const sets = [];
+        for (let n = 0;; n++) {
+            const jointIndex = primitive.attributes[`JOINTS_${n}`];
+            const weightIndex = primitive.attributes[`WEIGHTS_${n}`];
+            if (jointIndex === undefined || weightIndex === undefined)
+                break;
+            const set = {
+                joints: accessorFloats(doc, buffers, jointIndex, `${label} JOINTS_${n}`),
+                weights: accessorFloats(doc, buffers, weightIndex, `${label} WEIGHTS_${n}`),
+            };
+            for (let i = 0; i < set.joints.length; i++) {
+                const old = set.joints[i];
+                const moved = skin.remap[old];
+                if (moved === undefined) {
+                    throw new DrftError(`gltf: ${label} weights a vertex to joint ${old}, and its skin has ${skin.remap.length}`);
+                }
+                set.joints[i] = moved;
+            }
+            sets.push(set);
+        }
+        const only = sets.length === 1 ? sets[0] : undefined;
+        if (only !== undefined) {
+            joints = only.joints;
+            weights = only.weights;
+            normaliseWeights(weights, label, warnings);
+        }
+        else if (sets.length > 1) {
+            const vertices = sets[0].joints.length / 4;
+            const out = {
+                joints: new Float32Array(vertices * 4),
+                weights: new Float32Array(vertices * 4),
+                joints2: new Float32Array(vertices * 4),
+                weights2: new Float32Array(vertices * 4),
+            };
+            let dropped = false;
+            let rescaled = false;
+            let second = false;
+            for (let v = 0; v < vertices; v++) {
+                const influences = [];
+                for (const set of sets) {
+                    for (let k = 0; k < 4; k++) {
+                        influences.push({
+                            joint: set.joints[v * 4 + k],
+                            weight: set.weights[v * 4 + k],
+                        });
+                    }
+                }
+                const report = writeInfluences(influences, out, v);
+                dropped ||= report.dropped;
+                rescaled ||= report.rescaled;
+                second ||= report.second;
+            }
+            joints = out.joints;
+            weights = out.weights;
+            if (second) {
+                joints2 = out.joints2;
+                weights2 = out.weights2;
+            }
+            if (dropped) {
+                warnings.push(`${label}: a vertex is held by more than eight joints; the eight largest are kept`);
+            }
+            if (rescaled) {
+                warnings.push(`${label}: vertex weight sets did not sum to one and were rescaled`);
             }
-            joints[i] = moved;
         }
-        normaliseWeights(weights, label, warnings);
     }
     return {
         mesh: {
@@ -987,6 +1048,7 @@ deriveTangents = true) {
             ...(uvs === undefined ? {} : { uvs }),
             ...(tangents === undefined ? {} : { tangents }),
             ...(joints === undefined || weights === undefined ? {} : { joints, weights }),
+            ...(joints2 === undefined || weights2 === undefined ? {} : { joints2, weights2 }),
             ...(morphTargets === undefined || morphTargetCount === undefined
                 ? {}
                 : { morphTargets, morphTargetCount }),

package/dist/index.d.ts

@@ -94,6 +94,10 @@ export type { Localised } from './localise.ts';
 export { colliderBeside, levelsBeside } from './readModel.ts';
 export { ddsToRgba, isDds } from './dds.ts';
 export type { DdsImage } from './dds.ts';
+export { ddsBlocks } from './ddsBlocks.ts';
+export { decodeBc } from './bcDecode.ts';
+export { decodeBcImage } from './bcImage.ts';
+export { flipBc5Green } from './bcFlip.ts';
 export { buildClusters } from './bake/cluster.ts';
 export type { ClusterOptions, ClusterSet } from './bake/cluster.ts';
 export { buildClusterDag } from './bake/clusterLod.ts';

package/dist/index.js

@@ -170,10 +170,15 @@ export { localiseNodes } from './localise.js';
  */
 export { colliderBeside, levelsBeside } from './readModel.js';
 /*
- * DDS block decoding, for the block-compressed textures a vehicle model carries. Baker work: RGBA
- * is larger than the source and nothing ships a block decoder into a frame.
+ * DDS for the baker: `ddsBlocks` keeps a block-compressed surface's blocks and stored chain for a
+ * `CODEC_BC` texture, and `ddsToRgba` decodes level 0 for what cannot be kept. `decodeBc` is the
+ * block decoder both share with the loader, which runs it on a device that cannot sample BC.
  */
 export { ddsToRgba, isDds } from './dds.js';
+export { ddsBlocks } from './ddsBlocks.js';
+export { decodeBc } from './bcDecode.js';
+export { decodeBcImage } from './bcImage.js';
+export { flipBc5Green } from './bcFlip.js';
 /*
  * **The offline half of the GPU-driven pipeline, which nothing outside this package could reach.**
  *

package/dist/influences.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A vertex's joint influences, sorted, cut to eight and normalised into the two sets a mesh carries.
+ *
+ * **Eight and not four, since 4.8.4.** A rig authored for eight — a face, a shoulder, a hand — loses
+ * the shape of its deformation when the four lightest are dropped, and both importers dropped them.
+ * Heaviest first is the contract the format relies on: the first set always holds the four that
+ * matter most, so a renderer or an older pipeline reading only that set keeps the best four, and
+ * the second set holds what is left. Shared by the glTF and FBX readers so both cut and order the
+ * same way.
+ *
+ * **What it gives up** is anything past eight, renormalised over what is kept, as four was before.
+ * Runs at import, off the frame, so it allocates where that is clearer.
+ */
+/** One joint and how much of a vertex it moves. */
+export interface Influence {
+    readonly joint: number;
+    readonly weight: number;
+}
+/** The four arrays a mesh's influences land in, four floats per vertex each. */
+export interface InfluenceSets {
+    readonly joints: Float32Array;
+    readonly weights: Float32Array;
+    readonly joints2: Float32Array;
+    readonly weights2: Float32Array;
+}
+/** What a vertex's influences needed: dropping past eight, rescaling, and a second set at all. */
+export interface InfluenceReport {
+    readonly dropped: boolean;
+    readonly rescaled: boolean;
+    readonly second: boolean;
+}
+/** The most influences a vertex keeps: two sets of four. */
+export declare const MAX_INFLUENCES = 8;
+/**
+ * Write vertex `at`'s influences into `out`, heaviest first: the four heaviest into `joints` and
+ * `weights`, the next four into `joints2` and `weights2`, normalised to sum to one over all kept.
+ * A vertex with no positive weight is left all zero and reported as nothing, because inventing an
+ * influence would move geometry nobody rigged.
+ */
+export declare function writeInfluences(influences: readonly Influence[] | undefined, out: InfluenceSets, at: number): InfluenceReport;