@driftengine/assets 4.8.2 → 4.8.4

package/src/ddsBlocks.ts

@@ -0,0 +1,63 @@
+/**
+ * A block-compressed DDS kept as it was authored: its blocks, untouched, and every mip level its
+ * author stored, ready for a `CODEC_BC` payload.
+ *
+ * **Why keep them rather than decode them.** A BC7 texture is a byte a texel on the GPU where RGBA
+ * is four, and its chain is the one its author built — often filtered with care a box filter does
+ * not take, and for a normal map renormalised at every level. Decoding to RGBA and letting the
+ * engine generate mips throws both away, and costs a phone's memory and a desktop's bandwidth for
+ * the privilege. Where a device cannot sample a format, the loader decodes the same blocks there.
+ *
+ * **What it refuses, so the baker can fall back to decoding level 0:** a chain longer than the
+ * image has levels for, a chain whose bytes stop before its last level, a volume texture (each of
+ * whose levels holds several slices, so its layout is not a chain of images), and an uncompressed
+ * surface, which has no blocks to keep. Bytes after the last level are left where they are; a
+ * classic cube map's other five faces are such bytes, so its first face is what is kept.
+ */
+import { bcChainLength, bcLevelBytes, DrftError } from '@driftengine/drft';
+import type { BcImage } from '@driftengine/drft';
+
+import { DDPF_FOURCC, HEADER_BYTES, isDds, readDdsSurface } from './ddsHeader.ts';
+
+/** `DDSCAPS2_VOLUME`: each level is a stack of slices rather than one image. */
+const DDSCAPS2_VOLUME = 0x200000;
+
+/** The surface's blocks and stored levels, as views over `bytes`. */
+export function ddsBlocks(bytes: Uint8Array): BcImage {
+  if (!isDds(bytes)) throw new DrftError('dds: these bytes do not begin "DDS "');
+  if (bytes.length < HEADER_BYTES) {
+    throw new DrftError('dds: the file is shorter than its own header');
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if ((view.getUint32(80, true) & DDPF_FOURCC) === 0) {
+    throw new DrftError('dds: this surface is uncompressed, so it has no blocks to keep');
+  }
+  if ((view.getUint32(112, true) & DDSCAPS2_VOLUME) !== 0) {
+    throw new DrftError(
+      'dds: this is a volume texture, whose levels are stacks of slices rather than a chain',
+    );
+  }
+  const surface = readDdsSurface(bytes, view);
+  const { format, width, height, mipCount } = surface;
+  const most = bcChainLength(width, height);
+  if (mipCount > most) {
+    throw new DrftError(
+      `dds: ${surface.named} declares ${mipCount} levels for a ${width}x${height} image, which ` +
+        `has at most ${most}`,
+    );
+  }
+  const levels: Uint8Array[] = [];
+  let at = surface.dataAt;
+  for (let i = 0; i < mipCount; i++) {
+    const size = bcLevelBytes(format, width, height, i);
+    if (at + size > bytes.length) {
+      throw new DrftError(
+        `dds: level ${i} of ${mipCount} needs ${size} bytes and ${Math.max(0, bytes.length - at)} ` +
+          'are left',
+      );
+    }
+    levels.push(bytes.subarray(at, at + size));
+    at += size;
+  }
+  return { format, srgb: surface.srgb, width, height, levels };
+}

package/src/ddsHeader.ts

@@ -0,0 +1,160 @@
+/**
+ * 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';
+import type { BcFormat } 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: Uint8Array): boolean {
+  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: Readonly<Record<number, readonly [BcFormat, boolean]>> = {
+  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: Readonly<Record<string, BcFormat>> = {
+  DXT1: 'bc1',
+  DXT3: 'bc2',
+  DXT5: 'bc3',
+  ATI1: 'bc4',
+  BC4U: 'bc4',
+  ATI2: 'bc5',
+  BC5U: 'bc5',
+};
+
+/** What a block-compressed DDS holds, read from its header alone. */
+export interface DdsSurface {
+  readonly format: BcFormat;
+  readonly srgb: boolean;
+  readonly width: number;
+  readonly height: number;
+  /**
+   * The levels the header says follow. Zero is read as one, which is what Microsoft's own loader
+   * does: many writers leave the count zero, and its flag unset, on a surface with no chain.
+   */
+  readonly mipCount: number;
+  /** Where level 0's first block starts. */
+  readonly dataAt: number;
+  /** How the header named the format, for a message: a FourCC, or `DXGI <n>`. */
+  readonly named: string;
+}
+
+/**
+ * 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: Uint8Array, view: DataView): DdsSurface {
+  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] as number,
+    bytes[85] as number,
+    bytes[86] as number,
+    bytes[87] as number,
+  );
+  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/src/drftLoader.ts

@@ -10,6 +10,12 @@ import { placeFields } from './fieldPlacement.ts';
 import type { DrftFieldPlacement } from './fieldPlacement.ts';
 import type { DrftTexture } from '@driftengine/drft';
 import { TextureSet, textureColorSpaces } from './drftTextures.ts';
+import { bcPlan, createBcDecoder } from './bcLoad.ts';
+import type { BcDecoder } from './bcLoad.ts';
+import { decodeBc } from './bcDecode.ts';
+import { isCompressedSource, uploadsCompressed } from '@driftengine/core';
+import { CODEC_BC, codecName, readBcPayload } from '@driftengine/drft';
+import type { BcImage } from '@driftengine/drft';
 import { drawKeyOf, resolveDrawGrouping } from './drawKey.ts';
 import type { DrawGrouping, DrawSurfaceOverride } from './drawKey.ts';
 import {
@@ -323,7 +329,10 @@ export class DrftLoader {
   private readonly bound: boolean[] = [];
   private boundCount = 0;
   private readonly singles: MeshHandle[] = [];
-  private readonly images: (ImageBitmap | null)[] = [];
+  private readonly images: (LoadedImage | null)[] = [];
+  /** Started at the first BC texture that has to be decoded, and only then. See `bcLoad.ts`. */
+  private bcDecoder: BcDecoder | null = null;
+  private warnedBc = false;
   private readonly chunks: DrftTexture[] = [];
   private materials: readonly DrftMaterial[] = [];
   /**
@@ -812,6 +821,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
@@ -969,7 +982,7 @@ export class DrftLoader {
       if (ordinal !== undefined) {
         const take = this.options.onImage;
         if (take === undefined) this.rebuildTextures(ordinal);
-        else take(this.chunks[ordinal]?.name ?? '', this.images[ordinal] ?? null);
+        else take(this.chunks[ordinal]?.name ?? '', bitmapOf(this.images[ordinal] ?? null));
         /*
          * Counted here, once, and only for the image itself.
          *
@@ -1047,6 +1060,8 @@ export class DrftLoader {
     if (this.disposed) return;
     this.disposed = true;
     this.regionStore.dispose();
+    this.bcDecoder?.dispose();
+    this.bcDecoder = null;
     /*
      * Everything this class ever made, each disposed once.
      *
@@ -1444,7 +1459,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;
     }
@@ -1458,18 +1474,90 @@ export class DrftLoader {
     this.textureSet = TextureSet.from(this.chunks, (_, at) => {
       const held = previous?.at(at) ?? null;
       if (held !== null) return held;
-      const bitmap = this.images[at] ?? null;
-      if (bitmap === null) return 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.
+   */
+  private acceptBc(texture: DrftTexture, ordinal: number): void {
+    const done = (image: LoadedImage | null): void => {
+      if (this.disposed) return;
+      this.images[ordinal] = image;
+      this.sharp[ordinal] = true;
+      this.imageQueue.push(ordinal);
+    };
+    const failed = (error: unknown): void => {
+      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: BcImage;
+    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.
+   */
+  private uploadable(image: LoadedImage, srgb: boolean): ImageBitmap | ImageData | BcImage {
+    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] as Uint8Array),
+      width,
+      height,
+    );
+  }
+
   /** One place that writes the progress, so every field stays consistent with the phase. */
   private set(patch: Partial<DrftLoadProgress>): void {
     const next = { ...this.state, ...patch };
@@ -1554,6 +1642,23 @@ const AS_AUTHORED = {
   colorSpaceConversion: 'none',
 } as const satisfies ImageBitmapOptions;
 
+/** What the loader holds for an image: decoded, or blocks to upload as they are. */
+type LoadedImage = ImageBitmap | ImageData | BcImage;
+
+/** RGBA as an `ImageData`, which every upload path takes as it takes a bitmap. */
+function imageDataOf(rgba: Uint8Array, width: number, height: number): ImageData {
+  return new ImageData(
+    new Uint8ClampedArray(rgba.buffer as ArrayBuffer, 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: LoadedImage | null): ImageBitmap | null {
+  return image === null || isCompressedSource(image) || 'data' in image ? null : image;
+}
+
 async function decodeImage(texture: DrftTexture, longestSide?: number): Promise<ImageBitmap> {
   /*
    * **A raw texture has no decoder, because it is already decoded.**
@@ -1589,8 +1694,9 @@ async function decodeImage(texture: DrftTexture, longestSide?: number): Promise<
   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',
+      `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 });

package/src/fbx.ts

@@ -32,7 +32,8 @@ import type { UpAxis } from './orient.ts';
 import { FALLBACK_MATERIAL, readMaterials } from './fbxMaterial.ts';
 import type { DrftMaterial } from '@driftengine/drft';
 import type { AssetReference } from './assetPath.ts';
-import { bareName, indexObjects, readClips, readSkin, writeInfluences } from './fbxRig.ts';
+import { bareName, indexObjects, readClips, readSkin } from './fbxRig.ts';
+import { writeInfluences } from './influences.ts';
 import type { AnimationClip, DrftSkin } from '@driftengine/drft';
 
 /** One value repeated per vertex, for a material constant this format has nowhere else to put. */
@@ -688,6 +689,16 @@ export function fbxToMeshes(
       const outUvs: number[] | null = uvLayer === null ? null : [];
       const outJoints: number[] | null = skin === null ? null : [];
       const outWeights: number[] | null = skin === null ? null : [];
+      /* The fifth to eighth influences, kept only if some vertex needed them. See influences.ts. */
+      const outJoints2: number[] | null = skin === null ? null : [];
+      const outWeights2: number[] | null = 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: number[] = [];
       /*
        * A mesh with no normals is not deduplicated, and that is the geometry speaking rather than
@@ -805,23 +816,25 @@ export function fbxToMeshes(
         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] as number;
-            outWeights[emitted * 4 + k] = scratchWeights[k] as number;
-          }
+        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;
         }
       }
 
@@ -834,8 +847,8 @@ export function fbxToMeshes(
       }
       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.`,
+          `${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) {
@@ -861,6 +874,9 @@ export function fbxToMeshes(
         ...(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/src/fbxRig.ts

@@ -30,9 +30,6 @@ import type { FbxNode } from './fbx.ts';
 /** 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: readonly number[] = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
 
 function findChild(node: FbxNode, name: string): FbxNode | undefined {
@@ -332,44 +329,6 @@ export function readSkin(
   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: readonly { joint: number; weight: number }[] | undefined,
-  joints: Float32Array,
-  weights: Float32Array,
-  at: number,
-): { dropped: boolean; rescaled: boolean } {
-  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] as { joint: number; weight: number };
-    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: number, y: number, z: number): [number, number, number, number] {
   const half = Math.PI / 360;

package/src/gltf.ts

@@ -26,6 +26,7 @@ import { MAX_MORPH_TARGETS } from '@driftengine/core';
 import { accessorFloats } from './gltfAccessor.ts';
 import type { GltfSkin } from './gltfSkin.ts';
 import { readGltfSkins } from './gltfSkin.ts';
+import { writeInfluences } from './influences.ts';
 
 /* The subset of the schema this reads. Everything else is ignored or refused by name. */
 interface GltfAccessor {
@@ -1283,22 +1284,82 @@ function buildPrimitive(
 
   let joints: Float32Array | undefined;
   let weights: Float32Array | undefined;
-  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] as number;
-      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: Float32Array | undefined;
+  let weights2: Float32Array | undefined;
+  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: { joints: Float32Array; weights: Float32Array }[] = [];
+    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] as number;
+        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] as { joints: Float32Array }).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: { joint: number; weight: number }[] = [];
+        for (const set of sets) {
+          for (let k = 0; k < 4; k++) {
+            influences.push({
+              joint: set.joints[v * 4 + k] as number,
+              weight: set.weights[v * 4 + k] as number,
+            });
+          }
+        }
+        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`,
         );
       }
-      joints[i] = moved;
+      if (rescaled) {
+        warnings.push(`${label}: vertex weight sets did not sum to one and were rescaled`);
+      }
     }
-    normaliseWeights(weights, label, warnings);
   }
 
   return {
@@ -1314,6 +1375,7 @@ function buildPrimitive(
       ...(uvs === undefined ? {} : { uvs }),
       ...(tangents === undefined ? {} : { tangents }),
       ...(joints === undefined || weights === undefined ? {} : { joints, weights }),
+      ...(joints2 === undefined || weights2 === undefined ? {} : { joints2, weights2 }),
       ...(morphTargets === undefined || morphTargetCount === undefined
         ? {}
         : { morphTargets, morphTargetCount }),