@driftengine/drft 4.8.2 → 4.8.4

package/dist/drftBc.d.ts

@@ -0,0 +1,23 @@
+import type { BcFormat } from './drftFormat.ts';
+/** A block-compressed image, as a `CODEC_BC` payload holds it. */
+export interface BcImage {
+    readonly format: BcFormat;
+    /**
+     * What the author's header said of its texels. How a material slot samples them is still the
+     * renderer's decision, as for every other codec: a colour map is read as sRGB and a normal map as
+     * linear whatever its file claimed, so this is the author's statement rather than an instruction.
+     */
+    readonly srgb: boolean;
+    readonly width: number;
+    readonly height: number;
+    /** Level 0 first. Views over the payload when read, never copies. */
+    readonly levels: readonly Uint8Array[];
+}
+/** How many levels a full chain from `width` by `height` down to 1x1 has. */
+export declare function bcChainLength(width: number, height: number): number;
+/** The bytes level `level` of a `width` by `height` surface takes in `format`. */
+export declare function bcLevelBytes(format: BcFormat, width: number, height: number, level: number): number;
+/** The payload for `image`. Refuses a level whose size is not the one its position requires. */
+export declare function writeBcPayload(image: BcImage): Uint8Array;
+/** A payload read back, its levels as views over `bytes`. */
+export declare function readBcPayload(width: number, height: number, bytes: Uint8Array): BcImage;

package/dist/drftBc.js

@@ -0,0 +1,116 @@
+/**
+ * A `CODEC_BC` texture payload: which block format, what colour space its author declared, and
+ * every stored mip level, largest first.
+ *
+ * **The layout** (FORMAT.md §4.5, 1.24), little-endian after the `TEXS` prefix that already carries
+ * the codec, width and height:
+ *
+ *     u32 format   the format's own digit: 1, 2, 3, 4, 5 or 7 for BC1 to BC7
+ *     u32 flags    bit 0: the author declared the texels sRGB
+ *     u32 levels   how many mip levels follow, 1 to the full chain
+ *     u32 0        reserved
+ *     ...          each level's blocks, back to back, largest first
+ *
+ * **A level's size is derived, never stored.** Level `i` is `max(1, width >> i)` by
+ * `max(1, height >> i)` texels, rounded up to whole 4x4 blocks — so a level smaller than a block
+ * still costs one, which is how every DDS writer and every GPU lays them out. Storing the sizes
+ * would be a second statement of the same fact, free to disagree with the first.
+ *
+ * **What it gives up**: a chain is whole levels from the top. A file that wanted to drop its top
+ * level to save bytes has to say a smaller width and height, which is also what it then is.
+ *
+ * Unknown flag bits are ignored, which is rule 4 of the compatibility contract; a format number
+ * this reader does not know is refused by name. A signed or HDR format would be a new number rather
+ * than a flag, because a decoder that ignored it would produce wrong values rather than none.
+ */
+import { BC_BLOCK_BYTES, DrftError } from './drftFormat.js';
+const HEADER_BYTES = 16;
+const FLAG_SRGB = 1;
+const FORMAT_NUMBER = {
+    bc1: 1,
+    bc2: 2,
+    bc3: 3,
+    bc4: 4,
+    bc5: 5,
+    bc7: 7,
+};
+const FORMAT_OF = {
+    1: 'bc1',
+    2: 'bc2',
+    3: 'bc3',
+    4: 'bc4',
+    5: 'bc5',
+    7: 'bc7',
+};
+/** How many levels a full chain from `width` by `height` down to 1x1 has. */
+export function bcChainLength(width, height) {
+    return Math.floor(Math.log2(Math.max(1, width, height))) + 1;
+}
+/** The bytes level `level` of a `width` by `height` surface takes in `format`. */
+export function bcLevelBytes(format, width, height, level) {
+    const w = Math.max(1, width >> level);
+    const h = Math.max(1, height >> level);
+    return Math.ceil(w / 4) * Math.ceil(h / 4) * BC_BLOCK_BYTES[format];
+}
+/** The payload for `image`. Refuses a level whose size is not the one its position requires. */
+export function writeBcPayload(image) {
+    const { format, width, height, levels } = image;
+    checkChain(levels.length, width, height);
+    let total = HEADER_BYTES;
+    for (let i = 0; i < levels.length; i++) {
+        const want = bcLevelBytes(format, width, height, i);
+        const level = levels[i];
+        if (level.length !== want) {
+            throw new DrftError(`bc: level ${i} of a ${width}x${height} ${format.toUpperCase()} image is ${want} bytes, and ` +
+                `${level.length} were given`);
+        }
+        total += want;
+    }
+    const out = new Uint8Array(total);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, FORMAT_NUMBER[format], true);
+    view.setUint32(4, image.srgb ? FLAG_SRGB : 0, true);
+    view.setUint32(8, levels.length, true);
+    let at = HEADER_BYTES;
+    for (const level of levels) {
+        out.set(level, at);
+        at += level.length;
+    }
+    return out;
+}
+/** A payload read back, its levels as views over `bytes`. */
+export function readBcPayload(width, height, bytes) {
+    if (bytes.length < HEADER_BYTES) {
+        throw new DrftError(`bc: a payload of ${bytes.length} bytes is shorter than its header`);
+    }
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const number = view.getUint32(0, true);
+    const format = FORMAT_OF[number];
+    if (format === undefined) {
+        throw new DrftError(`bc: block format ${number} is not one this reader knows; it reads 1, 2, 3, 4, 5 and 7 ` +
+            '(BC1 to BC5 and BC7)');
+    }
+    const count = view.getUint32(8, true);
+    checkChain(count, width, height);
+    let needed = HEADER_BYTES;
+    for (let i = 0; i < count; i++)
+        needed += bcLevelBytes(format, width, height, i);
+    if (bytes.length < needed) {
+        throw new DrftError(`bc: ${count} levels of a ${width}x${height} ${format.toUpperCase()} image needs ` +
+            `${needed} bytes and the payload is ${bytes.length}`);
+    }
+    const levels = [];
+    let at = HEADER_BYTES;
+    for (let i = 0; i < count; i++) {
+        const size = bcLevelBytes(format, width, height, i);
+        levels.push(bytes.subarray(at, at + size));
+        at += size;
+    }
+    return { format, srgb: (view.getUint32(4, true) & FLAG_SRGB) !== 0, width, height, levels };
+}
+function checkChain(count, width, height) {
+    const most = bcChainLength(width, height);
+    if (width < 1 || height < 1 || count < 1 || count > most) {
+        throw new DrftError(`bc: ${count} levels for a ${width}x${height} image, which has at least 1 and at most ${most}`);
+    }
+}

package/dist/drftFormat.d.ts

@@ -20,7 +20,7 @@ export declare const DRFT_VERSION_MAJOR = 1;
  * Additive revisions within a generation: new optional chunks, new attribute bits, new
  * enum values with a defined fallback. Never a changed meaning.
  */
-export declare const DRFT_VERSION_MINOR = 23;
+export declare const DRFT_VERSION_MINOR = 24;
 /** Bytes before the chunk table. */
 export declare const HEADER_BYTES = 32;
 /** Bytes per chunk table entry. */
@@ -365,6 +365,20 @@ export declare const ATTR_LAYERS: number;
  * before this one, and draws the mesh planted, sunlit and opaque — the absent lane's own meaning.
  */
 export declare const ATTR_CHANNEL: number;
+/**
+ * Added in 1.24: a vertex's fifth to eighth influences, which joints and how much. See
+ * `MeshData.joints2`.
+ *
+ * Two bits for two arrays, both-or-neither like the first pair, and neither without the first pair.
+ * Appended after the channel, as every attribute since 1.20 has been, and that has a consequence
+ * worth stating rather than implying: indices follow the last array, so **a 1.23 reader does not
+ * skip these** — it reads their floats where it expects indices, finds indices far past the vertex
+ * count, and refuses the mesh by name. A loud refusal rather than a mesh drawn with four of its
+ * eight influences, which is the same answer `layers` and the channel give an older reader.
+ */
+export declare const ATTR_JOINTS2: number;
+/** How much each of `ATTR_JOINTS2`' four influences moves the vertex. */
+export declare const ATTR_WEIGHTS2: number;
 /** Everything this version defines, so a reader can spot bits from a later writer. */
 export declare const ATTR_KNOWN: number;
 /**
@@ -380,6 +394,28 @@ export declare const CODEC_PNG = 1;
 export declare const CODEC_JPEG = 2;
 export declare const CODEC_WEBP = 3;
 export declare const CODEC_RAW = 4;
+/**
+ * Added in 1.24: block-compressed images, kept as the blocks they were authored in.
+ *
+ * **Uploaded as they are where the device can sample them**, so a texture authored as BC7 costs a
+ * byte a texel on the GPU rather than four, and the mip chain the author built rather than one the
+ * engine generates. Where the device cannot — most phones, which sample ASTC and ETC2 instead — the
+ * loader decodes them to RGBA, which is the cost every texture paid before this. The payload — block
+ * format, colour space and the stored mip chain — is `drftBc.ts`'s.
+ */
+export declare const CODEC_BC = 5;
+/**
+ * The block formats a `CODEC_BC` payload may hold: what one 4x4 block of texels encodes.
+ *
+ * BC1 is colour with punch-through alpha in eight bytes; BC2 and BC3 colour with explicit and
+ * interpolated alpha in sixteen; BC4 one channel and BC5 two (a normal map) in eight and sixteen;
+ * BC7 colour and alpha in sixteen, with eight modes chosen per block. BC6H, signed BC4/BC5 and the
+ * other families are not among them: an HDR or signed texture is a different contract, refused by
+ * name rather than mis-decoded.
+ */
+export type BcFormat = 'bc1' | 'bc2' | 'bc3' | 'bc4' | 'bc5' | 'bc7';
+/** Bytes per 4x4 block of each format. */
+export declare const BC_BLOCK_BYTES: Readonly<Record<BcFormat, number>>;
 /** What a codec is called, for a message naming what was not understood. */
 export declare function codecName(codec: number): string;
 /**

package/dist/drftFormat.js

@@ -20,7 +20,7 @@ export const DRFT_VERSION_MAJOR = 1;
  * Additive revisions within a generation: new optional chunks, new attribute bits, new
  * enum values with a defined fallback. Never a changed meaning.
  */
-export const DRFT_VERSION_MINOR = 23;
+export const DRFT_VERSION_MINOR = 24;
 /** Bytes before the chunk table. */
 export const HEADER_BYTES = 32;
 /** Bytes per chunk table entry. */
@@ -406,6 +406,20 @@ export const ATTR_LAYERS = 1 << 9;
  * before this one, and draws the mesh planted, sunlit and opaque — the absent lane's own meaning.
  */
 export const ATTR_CHANNEL = 1 << 10;
+/**
+ * Added in 1.24: a vertex's fifth to eighth influences, which joints and how much. See
+ * `MeshData.joints2`.
+ *
+ * Two bits for two arrays, both-or-neither like the first pair, and neither without the first pair.
+ * Appended after the channel, as every attribute since 1.20 has been, and that has a consequence
+ * worth stating rather than implying: indices follow the last array, so **a 1.23 reader does not
+ * skip these** — it reads their floats where it expects indices, finds indices far past the vertex
+ * count, and refuses the mesh by name. A loud refusal rather than a mesh drawn with four of its
+ * eight influences, which is the same answer `layers` and the channel give an older reader.
+ */
+export const ATTR_JOINTS2 = 1 << 11;
+/** How much each of `ATTR_JOINTS2`' four influences moves the vertex. */
+export const ATTR_WEIGHTS2 = 1 << 12;
 /** Everything this version defines, so a reader can spot bits from a later writer. */
 export const ATTR_KNOWN = ATTR_SPECULAR |
     ATTR_UVS |
@@ -417,7 +431,9 @@ export const ATTR_KNOWN = ATTR_SPECULAR |
     ATTR_JOINTS |
     ATTR_WEIGHTS |
     ATTR_LAYERS |
-    ATTR_CHANNEL;
+    ATTR_CHANNEL |
+    ATTR_JOINTS2 |
+    ATTR_WEIGHTS2;
 /**
  * How a `TEXS` payload is encoded.
  *
@@ -431,6 +447,25 @@ export const CODEC_PNG = 1;
 export const CODEC_JPEG = 2;
 export const CODEC_WEBP = 3;
 export const CODEC_RAW = 4;
+/**
+ * Added in 1.24: block-compressed images, kept as the blocks they were authored in.
+ *
+ * **Uploaded as they are where the device can sample them**, so a texture authored as BC7 costs a
+ * byte a texel on the GPU rather than four, and the mip chain the author built rather than one the
+ * engine generates. Where the device cannot — most phones, which sample ASTC and ETC2 instead — the
+ * loader decodes them to RGBA, which is the cost every texture paid before this. The payload — block
+ * format, colour space and the stored mip chain — is `drftBc.ts`'s.
+ */
+export const CODEC_BC = 5;
+/** Bytes per 4x4 block of each format. */
+export const BC_BLOCK_BYTES = Object.freeze({
+    bc1: 8,
+    bc2: 16,
+    bc3: 16,
+    bc4: 8,
+    bc5: 16,
+    bc7: 16,
+});
 /** What a codec is called, for a message naming what was not understood. */
 export function codecName(codec) {
     return codec === CODEC_PNG
@@ -441,7 +476,9 @@ export function codecName(codec) {
                 ? 'WEBP'
                 : codec === CODEC_RAW
                     ? 'RAW'
-                    : `codec ${codec}`;
+                    : codec === CODEC_BC
+                        ? 'BC'
+                        : `codec ${codec}`;
 }
 /** Floats in a `MATL` entry, then the signed texture indices that follow them. */
 export const MATERIAL_FLOATS = 20;

package/dist/drftQuantised.js

@@ -23,7 +23,7 @@
  * compares vertices bit for bit, or one that cannot afford the decode's copy; `writeDrft`'s
  * `quantise: false` writes `MESH` as before.
  */
-import { ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_JOINTS, ATTR_RELIEF, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_TANGENT, ATTR_UVS, ATTR_WEIGHTS, ATTR_LAYERS, ATTR_CHANNEL, DrftError, align, } from './drftFormat.js';
+import { ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_JOINTS, ATTR_JOINTS2, ATTR_WEIGHTS2, ATTR_RELIEF, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_TANGENT, ATTR_UVS, ATTR_WEIGHTS, ATTR_LAYERS, ATTR_CHANNEL, DrftError, align, } from './drftFormat.js';
 const RAW = 0;
 const CONSTANT = 1;
 const RANGE16 = 2;
@@ -49,6 +49,8 @@ const ORDER = [
     /* Whole numbers naming an image, so exact: a layer quantised onto its neighbour is another picture. */
     { name: 'layers', width: 1, bit: ATTR_LAYERS, kind: 'exact' },
     { name: 'channel', width: 4, bit: ATTR_CHANNEL, kind: 'value' },
+    { name: 'joints2', width: 4, bit: ATTR_JOINTS2, kind: 'exact' },
+    { name: 'weights2', width: 4, bit: ATTR_WEIGHTS2, kind: 'value' },
 ];
 /** A growing little-endian byte list, for the writer: offline, so it may allocate. */
 class Bytes {

package/dist/drftRead.js

@@ -16,7 +16,7 @@
  */
 import { readClip, readMorph, readNodes, readSkin } from './drftSkin.js';
 import { validateMeshData } from './meshData.js';
-import { 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_LODM, CHUNK_LODF, CHUNK_DTEX, CHUNK_ENTS, CHUNK_NAVM, CHUNK_SPLT, SPLAT_BLOCK_PREFIX, CHUNK_MESH, CHUNK_REQUIRED, DRFT_MAGIC, DRFT_VERSION_MAJOR, DrftError, HEADER_BYTES, CHUNK_MATL, CHUNK_TEXS, KNOWN_CHUNKS, align, fourCCName, CHUNK_ANIM, CHUNK_NODE, CHUNK_INST, CHUNK_REGN, CHUNK_LVOL, CHUNK_LITE, CHUNK_MSHQ, CHUNK_KITS, CHUNK_MSHC, CHUNK_SKIN, CHUNK_MORP, CHUNK_NNET, CHUNK_NGRF, CHUNK_SDFV, CHUNK_SUBS, CHUNK_COLL, } from './drftFormat.js';
+import { ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_JOINTS, ATTR_RELIEF, ATTR_TANGENT, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_UVS, ATTR_WEIGHTS, ATTR_LAYERS, ATTR_CHANNEL, ATTR_JOINTS2, ATTR_WEIGHTS2, CHUNK_ENTRY_BYTES, CHUNK_HEAD, CHUNK_LODM, CHUNK_LODF, CHUNK_DTEX, CHUNK_ENTS, CHUNK_NAVM, CHUNK_SPLT, SPLAT_BLOCK_PREFIX, CHUNK_MESH, CHUNK_REQUIRED, DRFT_MAGIC, DRFT_VERSION_MAJOR, DrftError, HEADER_BYTES, CHUNK_MATL, CHUNK_TEXS, KNOWN_CHUNKS, align, fourCCName, CHUNK_ANIM, CHUNK_NODE, CHUNK_INST, CHUNK_REGN, CHUNK_LVOL, CHUNK_LITE, CHUNK_MSHQ, CHUNK_KITS, CHUNK_MSHC, CHUNK_SKIN, CHUNK_MORP, CHUNK_NNET, CHUNK_NGRF, CHUNK_SDFV, CHUNK_SUBS, CHUNK_COLL, } from './drftFormat.js';
 import { readSubs } from './drftSubs.js';
 import { readSdfv } from './sdfv.js';
 import { readDtex } from './dtex.js';
@@ -104,6 +104,9 @@ export function readMesh(buffer, chunk) {
     const layers = (attributes & ATTR_LAYERS) !== 0 ? floats(vertices, 'layers') : undefined;
     /* Sway, sky and opacity, 1.23, four floats a vertex and last. See ATTR_CHANNEL. */
     const channel = (attributes & ATTR_CHANNEL) !== 0 ? floats(vertices * 4, 'channel') : undefined;
+    /* The fifth to eighth influences, 1.24, last. See ATTR_JOINTS2. */
+    const joints2 = (attributes & ATTR_JOINTS2) !== 0 ? floats(vertices * 4, 'joints2') : undefined;
+    const weights2 = (attributes & ATTR_WEIGHTS2) !== 0 ? floats(vertices * 4, 'weights2') : undefined;
     const indexBytes = indexCount * 4;
     if (at + indexBytes > limit) {
         throw new DrftError(`indices need ${indexBytes} bytes but only ${limit - at} remain at ${at}`);
@@ -126,6 +129,8 @@ export function readMesh(buffer, chunk) {
         ...(weights === undefined ? {} : { weights }),
         ...(layers === undefined ? {} : { layers }),
         ...(channel === undefined ? {} : { channel }),
+        ...(joints2 === undefined ? {} : { joints2 }),
+        ...(weights2 === undefined ? {} : { weights2 }),
     };
     /*
      * Checked again on the way in, even though the writer checked on the way out. The file

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, 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 { ALIGNMENT, ATTR_EMISSIVE_COLOR, ATTR_GRAIN, ATTR_JOINTS, ATTR_RELIEF, ATTR_TANGENT, ATTR_ROUGHNESS, ATTR_SPECULAR, ATTR_UVS, ATTR_WEIGHTS, ATTR_LAYERS, ATTR_CHANNEL, ATTR_JOINTS2, ATTR_WEIGHTS2, 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';
@@ -280,6 +280,10 @@ function buildMesh(mesh, code = CHUNK_MESH, flags = CHUNK_REQUIRED) {
         attributes |= ATTR_LAYERS;
     if (mesh.channel !== undefined)
         attributes |= ATTR_CHANNEL;
+    if (mesh.joints2 !== undefined)
+        attributes |= ATTR_JOINTS2;
+    if (mesh.weights2 !== undefined)
+        attributes |= ATTR_WEIGHTS2;
     /* Order is frozen: mandatory arrays, then optional ones by ascending bit. */
     const arrays = [
         mesh.positions,
@@ -313,6 +317,11 @@ function buildMesh(mesh, code = CHUNK_MESH, flags = CHUNK_REQUIRED) {
     /* And newer still, 1.23. See ATTR_CHANNEL. */
     if (mesh.channel !== undefined)
         arrays.push(mesh.channel);
+    /* And 1.24's second four influences, last. See ATTR_JOINTS2. */
+    if (mesh.joints2 !== undefined)
+        arrays.push(mesh.joints2);
+    if (mesh.weights2 !== undefined)
+        arrays.push(mesh.weights2);
     arrays.push(mesh.indices);
     const PREFIX = 16;
     let total = PREFIX;

package/dist/index.d.ts

@@ -46,7 +46,10 @@ export type { DrftManifest, DrftStreamHandlers, DrftStreamPacing } from './drftS
 export { writeDrft } from './drftWrite.ts';
 export type { DrftSource, DrftTextureSource } from './drftWrite.ts';
 export { DrftError, DRFT_VERSION_MAJOR, DRFT_VERSION_MINOR } from './drftFormat.ts';
-export { CODEC_PNG, CODEC_JPEG, CODEC_WEBP, CODEC_RAW, codecName } from './drftFormat.ts';
+export { CODEC_PNG, CODEC_JPEG, CODEC_WEBP, CODEC_RAW, CODEC_BC, BC_BLOCK_BYTES, codecName, } from './drftFormat.ts';
+export type { BcFormat } from './drftFormat.ts';
+export { bcChainLength, bcLevelBytes, readBcPayload, writeBcPayload } from './drftBc.ts';
+export type { BcImage } from './drftBc.ts';
 export type { DrftHead, DrftMaterial, DrftSplatBlock, DrftSplats } from './drftFormat.ts';
 export { coarseFirstOrder } from './coarseFirst.ts';
 export { MAX_CLUSTERS, buildMeshlets, readMeshlets } from './drftMeshlets.ts';

package/dist/index.js

@@ -54,7 +54,8 @@ export { DEFAULT_STREAM_SLICE_MS, DrftStream, streamDrft } from './drftStream.js
 export { writeDrft } from './drftWrite.js';
 export { DrftError, DRFT_VERSION_MAJOR, DRFT_VERSION_MINOR } from './drftFormat.js';
 /* A consumer decoding an embedded texture has to know which codec it is holding. */
-export { CODEC_PNG, CODEC_JPEG, CODEC_WEBP, CODEC_RAW, codecName } from './drftFormat.js';
+export { CODEC_PNG, CODEC_JPEG, CODEC_WEBP, CODEC_RAW, CODEC_BC, BC_BLOCK_BYTES, codecName, } from './drftFormat.js';
+export { bcChainLength, bcLevelBytes, readBcPayload, writeBcPayload } from './drftBc.js';
 /* The order a capture is written in, so a baker outside this package can lay one out the same
    way — it is the whole reason a capture streams into a recognisable place. */
 export { coarseFirstOrder } from './coarseFirst.js';

package/dist/meshData.d.ts

@@ -163,9 +163,12 @@ export interface MeshData {
      * nothing and uploads nothing. Absent means unskinned, and an unskinned mesh takes exactly the
      * draw path it took before skinning existed.
      *
-     * **Four influences and not eight.** Four is what glTF's `JOINTS_0` carries, what every DCC tool
-     * exports without being asked, and what fits one attribute. Eight doubles the attribute cost of
-     * every skinned vertex to serve a case that rarely survives an export.
+     * **Four here, and four more in `joints2` for a mesh that has them.** Four is what glTF's
+     * `JOINTS_0` carries and what most exports write, and it fits one attribute; a character authored
+     * for eight — a face, a shoulder — loses the shape of its deformation when the four lightest are
+     * dropped, so 4.8.4 added a second set rather than widening this one. A mesh without it pays
+     * nothing for it, and importers sort heaviest first, so this set always holds the four that
+     * matter most.
      *
      * **`Float32Array` and not `Uint8Array`, which costs twelve bytes a vertex.** Every attribute in
      * this format is float32 and the absent-attribute mechanism depends on it: `mesh.ts` attaches
@@ -188,6 +191,19 @@ export interface MeshData {
      * is refused below rather than drawn.
      */
     weights?: Float32Array;
+    /**
+     * Four floats per vertex: the fifth to eighth joints that move this vertex, for a rig authored with
+     * eight influences. The same encoding as `joints`, and the same both-or-neither with `weights2`.
+     *
+     * **Present only with `joints`**, because the importers sort a vertex's influences heaviest first:
+     * the first set is always the four that matter most, and a second set alone would be four of the
+     * lightest with the heaviest missing. What it costs is thirty-two bytes a vertex on a mesh that
+     * carries it, and nothing on one that does not — a renderer draws such a mesh through a vertex
+     * variant that reads two more attributes, and every other mesh through the variant it always had.
+     */
+    joints2?: Float32Array;
+    /** Four floats per vertex: how much each of `joints2`' influences moves the vertex. */
+    weights2?: Float32Array;
     /**
      * Morph target position deltas: `morphTargetCount` targets, three floats a vertex each.
      *

package/dist/meshData.js

@@ -73,6 +73,17 @@ export function validateMeshData(data) {
     check('tangents', data.tangents, 4);
     check('joints', data.joints, 4);
     check('weights', data.weights, 4);
+    check('joints2', data.joints2, 4);
+    check('weights2', data.weights2, 4);
+    if ((data.joints2 === undefined) !== (data.weights2 === undefined)) {
+        throw new Error(data.joints2 === undefined
+            ? 'Mesh: weights2 without joints2 — the second four influences need both'
+            : 'Mesh: joints2 without weights2 — the second four influences need both');
+    }
+    if (data.joints2 !== undefined && data.joints === undefined) {
+        throw new Error('Mesh: a second set of influences without the first — importers put the four heaviest in ' +
+            '`joints`, so `joints2` alone would be the lightest four with the heaviest missing');
+    }
     /*
      * Both or neither. The shader multiplies four matrices by four weights, so a missing half means
      * either every weight or every index is the absent-attribute constant — and both collapse the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/drft",
-  "version": "4.8.2",
+  "version": "4.8.4",
   "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.8.2",
-    "@driftengine/entities": "4.8.2",
-    "@driftengine/texture": "4.8.2"
+    "@driftengine/core": "4.8.4",
+    "@driftengine/entities": "4.8.4",
+    "@driftengine/texture": "4.8.4"
   },
   "author": "Drift Technologies",
   "repository": {

package/src/drftBc.ts

@@ -0,0 +1,151 @@
+/**
+ * A `CODEC_BC` texture payload: which block format, what colour space its author declared, and
+ * every stored mip level, largest first.
+ *
+ * **The layout** (FORMAT.md §4.5, 1.24), little-endian after the `TEXS` prefix that already carries
+ * the codec, width and height:
+ *
+ *     u32 format   the format's own digit: 1, 2, 3, 4, 5 or 7 for BC1 to BC7
+ *     u32 flags    bit 0: the author declared the texels sRGB
+ *     u32 levels   how many mip levels follow, 1 to the full chain
+ *     u32 0        reserved
+ *     ...          each level's blocks, back to back, largest first
+ *
+ * **A level's size is derived, never stored.** Level `i` is `max(1, width >> i)` by
+ * `max(1, height >> i)` texels, rounded up to whole 4x4 blocks — so a level smaller than a block
+ * still costs one, which is how every DDS writer and every GPU lays them out. Storing the sizes
+ * would be a second statement of the same fact, free to disagree with the first.
+ *
+ * **What it gives up**: a chain is whole levels from the top. A file that wanted to drop its top
+ * level to save bytes has to say a smaller width and height, which is also what it then is.
+ *
+ * Unknown flag bits are ignored, which is rule 4 of the compatibility contract; a format number
+ * this reader does not know is refused by name. A signed or HDR format would be a new number rather
+ * than a flag, because a decoder that ignored it would produce wrong values rather than none.
+ */
+import { BC_BLOCK_BYTES, DrftError } from './drftFormat.ts';
+import type { BcFormat } from './drftFormat.ts';
+
+/** A block-compressed image, as a `CODEC_BC` payload holds it. */
+export interface BcImage {
+  readonly format: BcFormat;
+  /**
+   * What the author's header said of its texels. How a material slot samples them is still the
+   * renderer's decision, as for every other codec: a colour map is read as sRGB and a normal map as
+   * linear whatever its file claimed, so this is the author's statement rather than an instruction.
+   */
+  readonly srgb: boolean;
+  readonly width: number;
+  readonly height: number;
+  /** Level 0 first. Views over the payload when read, never copies. */
+  readonly levels: readonly Uint8Array[];
+}
+
+const HEADER_BYTES = 16;
+const FLAG_SRGB = 1;
+
+const FORMAT_NUMBER: Readonly<Record<BcFormat, number>> = {
+  bc1: 1,
+  bc2: 2,
+  bc3: 3,
+  bc4: 4,
+  bc5: 5,
+  bc7: 7,
+};
+const FORMAT_OF: Readonly<Record<number, BcFormat>> = {
+  1: 'bc1',
+  2: 'bc2',
+  3: 'bc3',
+  4: 'bc4',
+  5: 'bc5',
+  7: 'bc7',
+};
+
+/** How many levels a full chain from `width` by `height` down to 1x1 has. */
+export function bcChainLength(width: number, height: number): number {
+  return Math.floor(Math.log2(Math.max(1, width, height))) + 1;
+}
+
+/** The bytes level `level` of a `width` by `height` surface takes in `format`. */
+export function bcLevelBytes(
+  format: BcFormat,
+  width: number,
+  height: number,
+  level: number,
+): number {
+  const w = Math.max(1, width >> level);
+  const h = Math.max(1, height >> level);
+  return Math.ceil(w / 4) * Math.ceil(h / 4) * BC_BLOCK_BYTES[format];
+}
+
+/** The payload for `image`. Refuses a level whose size is not the one its position requires. */
+export function writeBcPayload(image: BcImage): Uint8Array {
+  const { format, width, height, levels } = image;
+  checkChain(levels.length, width, height);
+  let total = HEADER_BYTES;
+  for (let i = 0; i < levels.length; i++) {
+    const want = bcLevelBytes(format, width, height, i);
+    const level = levels[i] as Uint8Array;
+    if (level.length !== want) {
+      throw new DrftError(
+        `bc: level ${i} of a ${width}x${height} ${format.toUpperCase()} image is ${want} bytes, and ` +
+          `${level.length} were given`,
+      );
+    }
+    total += want;
+  }
+  const out = new Uint8Array(total);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, FORMAT_NUMBER[format], true);
+  view.setUint32(4, image.srgb ? FLAG_SRGB : 0, true);
+  view.setUint32(8, levels.length, true);
+  let at = HEADER_BYTES;
+  for (const level of levels) {
+    out.set(level, at);
+    at += level.length;
+  }
+  return out;
+}
+
+/** A payload read back, its levels as views over `bytes`. */
+export function readBcPayload(width: number, height: number, bytes: Uint8Array): BcImage {
+  if (bytes.length < HEADER_BYTES) {
+    throw new DrftError(`bc: a payload of ${bytes.length} bytes is shorter than its header`);
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const number = view.getUint32(0, true);
+  const format = FORMAT_OF[number];
+  if (format === undefined) {
+    throw new DrftError(
+      `bc: block format ${number} is not one this reader knows; it reads 1, 2, 3, 4, 5 and 7 ` +
+        '(BC1 to BC5 and BC7)',
+    );
+  }
+  const count = view.getUint32(8, true);
+  checkChain(count, width, height);
+  let needed = HEADER_BYTES;
+  for (let i = 0; i < count; i++) needed += bcLevelBytes(format, width, height, i);
+  if (bytes.length < needed) {
+    throw new DrftError(
+      `bc: ${count} levels of a ${width}x${height} ${format.toUpperCase()} image needs ` +
+        `${needed} bytes and the payload is ${bytes.length}`,
+    );
+  }
+  const levels: Uint8Array[] = [];
+  let at = HEADER_BYTES;
+  for (let i = 0; i < count; i++) {
+    const size = bcLevelBytes(format, width, height, i);
+    levels.push(bytes.subarray(at, at + size));
+    at += size;
+  }
+  return { format, srgb: (view.getUint32(4, true) & FLAG_SRGB) !== 0, width, height, levels };
+}
+
+function checkChain(count: number, width: number, height: number): void {
+  const most = bcChainLength(width, height);
+  if (width < 1 || height < 1 || count < 1 || count > most) {
+    throw new DrftError(
+      `bc: ${count} levels for a ${width}x${height} image, which has at least 1 and at most ${most}`,
+    );
+  }
+}

package/src/drftFormat.ts

@@ -23,7 +23,7 @@ export const DRFT_VERSION_MAJOR = 1;
  * Additive revisions within a generation: new optional chunks, new attribute bits, new
  * enum values with a defined fallback. Never a changed meaning.
  */
-export const DRFT_VERSION_MINOR = 23;
+export const DRFT_VERSION_MINOR = 24;
 
 /** Bytes before the chunk table. */
 export const HEADER_BYTES = 32;
@@ -448,6 +448,21 @@ export const ATTR_LAYERS = 1 << 9;
  */
 export const ATTR_CHANNEL = 1 << 10;
 
+/**
+ * Added in 1.24: a vertex's fifth to eighth influences, which joints and how much. See
+ * `MeshData.joints2`.
+ *
+ * Two bits for two arrays, both-or-neither like the first pair, and neither without the first pair.
+ * Appended after the channel, as every attribute since 1.20 has been, and that has a consequence
+ * worth stating rather than implying: indices follow the last array, so **a 1.23 reader does not
+ * skip these** — it reads their floats where it expects indices, finds indices far past the vertex
+ * count, and refuses the mesh by name. A loud refusal rather than a mesh drawn with four of its
+ * eight influences, which is the same answer `layers` and the channel give an older reader.
+ */
+export const ATTR_JOINTS2 = 1 << 11;
+/** How much each of `ATTR_JOINTS2`' four influences moves the vertex. */
+export const ATTR_WEIGHTS2 = 1 << 12;
+
 /** Everything this version defines, so a reader can spot bits from a later writer. */
 export const ATTR_KNOWN =
   ATTR_SPECULAR |
@@ -460,7 +475,9 @@ export const ATTR_KNOWN =
   ATTR_JOINTS |
   ATTR_WEIGHTS |
   ATTR_LAYERS |
-  ATTR_CHANNEL;
+  ATTR_CHANNEL |
+  ATTR_JOINTS2 |
+  ATTR_WEIGHTS2;
 
 /**
  * How a `TEXS` payload is encoded.
@@ -476,6 +493,38 @@ export const CODEC_JPEG = 2;
 export const CODEC_WEBP = 3;
 export const CODEC_RAW = 4;
 
+/**
+ * Added in 1.24: block-compressed images, kept as the blocks they were authored in.
+ *
+ * **Uploaded as they are where the device can sample them**, so a texture authored as BC7 costs a
+ * byte a texel on the GPU rather than four, and the mip chain the author built rather than one the
+ * engine generates. Where the device cannot — most phones, which sample ASTC and ETC2 instead — the
+ * loader decodes them to RGBA, which is the cost every texture paid before this. The payload — block
+ * format, colour space and the stored mip chain — is `drftBc.ts`'s.
+ */
+export const CODEC_BC = 5;
+
+/**
+ * The block formats a `CODEC_BC` payload may hold: what one 4x4 block of texels encodes.
+ *
+ * BC1 is colour with punch-through alpha in eight bytes; BC2 and BC3 colour with explicit and
+ * interpolated alpha in sixteen; BC4 one channel and BC5 two (a normal map) in eight and sixteen;
+ * BC7 colour and alpha in sixteen, with eight modes chosen per block. BC6H, signed BC4/BC5 and the
+ * other families are not among them: an HDR or signed texture is a different contract, refused by
+ * name rather than mis-decoded.
+ */
+export type BcFormat = 'bc1' | 'bc2' | 'bc3' | 'bc4' | 'bc5' | 'bc7';
+
+/** Bytes per 4x4 block of each format. */
+export const BC_BLOCK_BYTES: Readonly<Record<BcFormat, number>> = Object.freeze({
+  bc1: 8,
+  bc2: 16,
+  bc3: 16,
+  bc4: 8,
+  bc5: 16,
+  bc7: 16,
+});
+
 /** What a codec is called, for a message naming what was not understood. */
 export function codecName(codec: number): string {
   return codec === CODEC_PNG
@@ -486,7 +535,9 @@ export function codecName(codec: number): string {
         ? 'WEBP'
         : codec === CODEC_RAW
           ? 'RAW'
-          : `codec ${codec}`;
+          : codec === CODEC_BC
+            ? 'BC'
+            : `codec ${codec}`;
 }
 
 /**

package/src/drftQuantised.ts

@@ -27,6 +27,8 @@ import {
   ATTR_EMISSIVE_COLOR,
   ATTR_GRAIN,
   ATTR_JOINTS,
+  ATTR_JOINTS2,
+  ATTR_WEIGHTS2,
   ATTR_RELIEF,
   ATTR_ROUGHNESS,
   ATTR_SPECULAR,
@@ -64,7 +66,9 @@ type Name =
   | 'joints'
   | 'weights'
   | 'layers'
-  | 'channel';
+  | 'channel'
+  | 'joints2'
+  | 'weights2';
 
 /** The frozen order `MESH` uses, with each optional array's bit: `FORMAT.md` §4.3. */
 const ORDER: readonly {
@@ -89,6 +93,8 @@ const ORDER: readonly {
   /* Whole numbers naming an image, so exact: a layer quantised onto its neighbour is another picture. */
   { name: 'layers', width: 1, bit: ATTR_LAYERS, kind: 'exact' },
   { name: 'channel', width: 4, bit: ATTR_CHANNEL, kind: 'value' },
+  { name: 'joints2', width: 4, bit: ATTR_JOINTS2, kind: 'exact' },
+  { name: 'weights2', width: 4, bit: ATTR_WEIGHTS2, kind: 'value' },
 ];
 
 /** A growing little-endian byte list, for the writer: offline, so it may allocate. */

package/src/drftRead.ts

@@ -33,6 +33,8 @@ import {
   ATTR_WEIGHTS,
   ATTR_LAYERS,
   ATTR_CHANNEL,
+  ATTR_JOINTS2,
+  ATTR_WEIGHTS2,
   CHUNK_ENTRY_BYTES,
   CHUNK_HEAD,
   CHUNK_LODM,
@@ -324,6 +326,10 @@ export function readMesh(buffer: ArrayBuffer, chunk: DrftChunk): MeshData {
   const layers = (attributes & ATTR_LAYERS) !== 0 ? floats(vertices, 'layers') : undefined;
   /* Sway, sky and opacity, 1.23, four floats a vertex and last. See ATTR_CHANNEL. */
   const channel = (attributes & ATTR_CHANNEL) !== 0 ? floats(vertices * 4, 'channel') : undefined;
+  /* The fifth to eighth influences, 1.24, last. See ATTR_JOINTS2. */
+  const joints2 = (attributes & ATTR_JOINTS2) !== 0 ? floats(vertices * 4, 'joints2') : undefined;
+  const weights2 =
+    (attributes & ATTR_WEIGHTS2) !== 0 ? floats(vertices * 4, 'weights2') : undefined;
 
   const indexBytes = indexCount * 4;
   if (at + indexBytes > limit) {
@@ -348,6 +354,8 @@ export function readMesh(buffer: ArrayBuffer, chunk: DrftChunk): MeshData {
     ...(weights === undefined ? {} : { weights }),
     ...(layers === undefined ? {} : { layers }),
     ...(channel === undefined ? {} : { channel }),
+    ...(joints2 === undefined ? {} : { joints2 }),
+    ...(weights2 === undefined ? {} : { weights2 }),
   };
 
   /*

package/src/drftWrite.ts

@@ -27,6 +27,8 @@ import {
   ATTR_WEIGHTS,
   ATTR_LAYERS,
   ATTR_CHANNEL,
+  ATTR_JOINTS2,
+  ATTR_WEIGHTS2,
   CHUNK_ENTRY_BYTES,
   CHUNK_HEAD,
   CHUNK_ANIM,
@@ -523,6 +525,8 @@ function buildMesh(mesh: MeshData, code = CHUNK_MESH, flags = CHUNK_REQUIRED): P
   if (mesh.weights !== undefined) attributes |= ATTR_WEIGHTS;
   if (mesh.layers !== undefined) attributes |= ATTR_LAYERS;
   if (mesh.channel !== undefined) attributes |= ATTR_CHANNEL;
+  if (mesh.joints2 !== undefined) attributes |= ATTR_JOINTS2;
+  if (mesh.weights2 !== undefined) attributes |= ATTR_WEIGHTS2;
 
   /* Order is frozen: mandatory arrays, then optional ones by ascending bit. */
   const arrays: (Float32Array | Uint32Array)[] = [
@@ -546,6 +550,9 @@ function buildMesh(mesh: MeshData, code = CHUNK_MESH, flags = CHUNK_REQUIRED): P
   if (mesh.layers !== undefined) arrays.push(mesh.layers);
   /* And newer still, 1.23. See ATTR_CHANNEL. */
   if (mesh.channel !== undefined) arrays.push(mesh.channel);
+  /* And 1.24's second four influences, last. See ATTR_JOINTS2. */
+  if (mesh.joints2 !== undefined) arrays.push(mesh.joints2);
+  if (mesh.weights2 !== undefined) arrays.push(mesh.weights2);
   arrays.push(mesh.indices);
 
   const PREFIX = 16;

package/src/index.ts

@@ -140,7 +140,18 @@ export { writeDrft } from './drftWrite.ts';
 export type { DrftSource, DrftTextureSource } from './drftWrite.ts';
 export { DrftError, DRFT_VERSION_MAJOR, DRFT_VERSION_MINOR } from './drftFormat.ts';
 /* A consumer decoding an embedded texture has to know which codec it is holding. */
-export { CODEC_PNG, CODEC_JPEG, CODEC_WEBP, CODEC_RAW, codecName } from './drftFormat.ts';
+export {
+  CODEC_PNG,
+  CODEC_JPEG,
+  CODEC_WEBP,
+  CODEC_RAW,
+  CODEC_BC,
+  BC_BLOCK_BYTES,
+  codecName,
+} from './drftFormat.ts';
+export type { BcFormat } from './drftFormat.ts';
+export { bcChainLength, bcLevelBytes, readBcPayload, writeBcPayload } from './drftBc.ts';
+export type { BcImage } from './drftBc.ts';
 export type { DrftHead, DrftMaterial, DrftSplatBlock, DrftSplats } from './drftFormat.ts';
 /* The order a capture is written in, so a baker outside this package can lay one out the same
    way — it is the whole reason a capture streams into a recognisable place. */

package/src/meshData.ts

@@ -164,9 +164,12 @@ export interface MeshData {
    * nothing and uploads nothing. Absent means unskinned, and an unskinned mesh takes exactly the
    * draw path it took before skinning existed.
    *
-   * **Four influences and not eight.** Four is what glTF's `JOINTS_0` carries, what every DCC tool
-   * exports without being asked, and what fits one attribute. Eight doubles the attribute cost of
-   * every skinned vertex to serve a case that rarely survives an export.
+   * **Four here, and four more in `joints2` for a mesh that has them.** Four is what glTF's
+   * `JOINTS_0` carries and what most exports write, and it fits one attribute; a character authored
+   * for eight — a face, a shoulder — loses the shape of its deformation when the four lightest are
+   * dropped, so 4.8.4 added a second set rather than widening this one. A mesh without it pays
+   * nothing for it, and importers sort heaviest first, so this set always holds the four that
+   * matter most.
    *
    * **`Float32Array` and not `Uint8Array`, which costs twelve bytes a vertex.** Every attribute in
    * this format is float32 and the absent-attribute mechanism depends on it: `mesh.ts` attaches
@@ -189,6 +192,19 @@ export interface MeshData {
    * is refused below rather than drawn.
    */
   weights?: Float32Array;
+  /**
+   * Four floats per vertex: the fifth to eighth joints that move this vertex, for a rig authored with
+   * eight influences. The same encoding as `joints`, and the same both-or-neither with `weights2`.
+   *
+   * **Present only with `joints`**, because the importers sort a vertex's influences heaviest first:
+   * the first set is always the four that matter most, and a second set alone would be four of the
+   * lightest with the heaviest missing. What it costs is thirty-two bytes a vertex on a mesh that
+   * carries it, and nothing on one that does not — a renderer draws such a mesh through a vertex
+   * variant that reads two more attributes, and every other mesh through the variant it always had.
+   */
+  joints2?: Float32Array;
+  /** Four floats per vertex: how much each of `joints2`' influences moves the vertex. */
+  weights2?: Float32Array;
   /**
    * Morph target position deltas: `morphTargetCount` targets, three floats a vertex each.
    *
@@ -281,6 +297,21 @@ export function validateMeshData(data: MeshData): void {
   check('tangents', data.tangents, 4);
   check('joints', data.joints, 4);
   check('weights', data.weights, 4);
+  check('joints2', data.joints2, 4);
+  check('weights2', data.weights2, 4);
+  if ((data.joints2 === undefined) !== (data.weights2 === undefined)) {
+    throw new Error(
+      data.joints2 === undefined
+        ? 'Mesh: weights2 without joints2 — the second four influences need both'
+        : 'Mesh: joints2 without weights2 — the second four influences need both',
+    );
+  }
+  if (data.joints2 !== undefined && data.joints === undefined) {
+    throw new Error(
+      'Mesh: a second set of influences without the first — importers put the four heaviest in ' +
+        '`joints`, so `joints2` alone would be the lightest four with the heaviest missing',
+    );
+  }
 
   /*
    * Both or neither. The shader multiplies four matrices by four weights, so a missing half means