three-vat 3.0.0 → 4.1.0

package/dist/index.js

@@ -1,7 +1,79 @@
-import { LoopMode, MAX_TEXTURE_SIZE, makeVATTexture, RIG_TEXELS_PER_SLOT, RIG_TEXELS, LIBRARY_PLAYBACK_DEFAULTS, FORWARD_ONLY_REASON, INFINITE_REPETITIONS } from './chunk-J5IEUGSB.js';
-export { EndMode, INFINITE_REPETITIONS, LoopMode, MAX_TEXTURE_SIZE, createVATPlaybackTexture, endsAt, makeVATTexture, resolveVATFrame, setVATInstance } from './chunk-J5IEUGSB.js';
-import { LoopRepeat, LoopOnce, LoopPingPong, Matrix4, AnimationMixer, Box3, Vector4, Vector3, Sphere, Quaternion, BufferGeometry, BufferAttribute, AdditiveAnimationBlendMode, PropertyBinding } from 'three';
+import { LoopMode, MAX_TEXTURE_SIZE, vertexLayoutFor, makeVATNormalTexture, makeVATTexture, RIG_TEXELS_PER_SLOT, LIBRARY_PLAYBACK_DEFAULTS, FORWARD_ONLY_REASON, INFINITE_REPETITIONS, HALF_FLOAT_MAX, RIG_TEXELS } from './chunk-OEKKEHRQ.js';
+export { EndMode, INFINITE_REPETITIONS, LoopMode, MAX_TEXTURE_SIZE, createVATPlaybackTexture, endsAt, makeVATNormalTexture, makeVATTexture, resolveVATFrame, setVATInstance } from './chunk-OEKKEHRQ.js';
+import { LoopRepeat, LoopOnce, LoopPingPong, DataUtils, Quaternion, Matrix4, Box3, Vector4, Vector3, Sphere, HalfFloatType, BufferGeometry, BufferAttribute, AdditiveAnimationBlendMode, AnimationMixer, PropertyBinding, FloatType, Material, InterleavedBuffer, SkinnedMesh, Mesh, Bone, Object3D, Skeleton, AnimationClip, Color, InterleavedBufferAttribute, VectorKeyframeTrack, StringKeyframeTrack, QuaternionKeyframeTrack, NumberKeyframeTrack, ColorKeyframeTrack, BooleanKeyframeTrack, Float16BufferAttribute, Interpolant } from 'three';
 
+var IGNORED = ["uuid", "name", "color", "userData", "metadata"];
+function flatFacts(material) {
+  const m = material;
+  if (!m.color?.isColor || m.vertexColors || m.isShadowMaterial) return null;
+  const own = (key) => Object.prototype.hasOwnProperty.call(m, key);
+  if (own("onBeforeCompile") || own("customProgramCacheKey")) return null;
+  for (const value of Object.values(m)) {
+    const v = value;
+    if (v?.isTexture || v?.isNode) return null;
+  }
+  const json = m.toJSON();
+  for (const key of IGNORED) delete json[key];
+  return { key: JSON.stringify(json), color: [m.color.r, m.color.g, m.color.b] };
+}
+function mergedFlatMaterial(members) {
+  const merged = members[0].clone();
+  merged.color.setRGB(1, 1, 1);
+  merged.vertexColors = true;
+  merged.name = members.map((m) => m.name).filter(Boolean).join(" + ");
+  return merged;
+}
+var FLAT_MERGE = { facts: flatFacts, merge: mergedFlatMaterial };
+function planFlatMerge(materials, hooks) {
+  const facts = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  for (const material of materials) {
+    if (facts.has(material)) continue;
+    const f = hooks.facts(material);
+    if (!f) continue;
+    facts.set(material, f);
+    groups.set(f.key, [...groups.get(f.key) ?? [], material]);
+  }
+  const targets = /* @__PURE__ */ new Map();
+  for (const members of groups.values()) {
+    if (members.length < 2) continue;
+    const merged = hooks.merge(members);
+    for (const m of members) targets.set(m, { material: merged, tint: new Color().fromArray(facts.get(m).color) });
+  }
+  return { targetOf: (material) => targets.get(material) };
+}
+
+// src/octahedral.ts
+var signNotZero = (v) => v >= 0 ? 1 : -1;
+var toByte = (v) => Math.max(0, Math.min(255, Math.round((v * 0.5 + 0.5) * 255)));
+function encodeOctahedral(x, y, z, out, offset) {
+  const l1 = Math.abs(x) + Math.abs(y) + Math.abs(z);
+  if (l1 === 0) {
+    out[offset] = toByte(0);
+    out[offset + 1] = toByte(0);
+    return;
+  }
+  const px = x / l1;
+  const py = y / l1;
+  const fold = z <= 0;
+  out[offset] = toByte(fold ? (1 - Math.abs(py)) * signNotZero(px) : px);
+  out[offset + 1] = toByte(fold ? (1 - Math.abs(px)) * signNotZero(py) : py);
+}
+function decodeOctahedral(u, v, out = { x: 0, y: 0, z: 0 }) {
+  const ex = u / 255 * 2 - 1;
+  const ey = v / 255 * 2 - 1;
+  const z = 1 - Math.abs(ex) - Math.abs(ey);
+  const t = Math.max(-z, 0);
+  const x = ex - signNotZero(ex) * t;
+  const y = ey - signNotZero(ey) * t;
+  const length = Math.hypot(x, y, z) || 1;
+  out.x = x / length;
+  out.y = y / length;
+  out.z = z / length;
+  return out;
+}
+
+// src/bake.ts
 var LOOP_MODES = /* @__PURE__ */ new Map([
   [LoopRepeat, LoopMode.Repeat],
   [LoopOnce, LoopMode.Once],
@@ -53,6 +125,32 @@ function morphCountOf({ mesh, morphPos, morphNrm }) {
   const influences = mesh.morphTargetInfluences;
   return influences ? Math.min(influences.length, Math.max(morphPos?.length ?? 0, morphNrm?.length ?? 0)) : 0;
 }
+var _mt = /* @__PURE__ */ new Vector3();
+var _mb = /* @__PURE__ */ new Vector3();
+var _mbn = /* @__PURE__ */ new Vector3();
+function morphVertex(part, v, weights, count, p, n) {
+  const { basePos, baseNrm, morphPos, morphNrm, morphRelative } = part;
+  if (!morphRelative) {
+    _mb.fromBufferAttribute(basePos, v);
+    if (n) _mbn.fromBufferAttribute(baseNrm, v);
+  }
+  for (let t = 0; t < count; t++) {
+    const w = weights[t];
+    if (w === 0) continue;
+    const targetPos = morphPos?.[t];
+    if (targetPos) {
+      _mt.fromBufferAttribute(targetPos, v);
+      if (!morphRelative) _mt.sub(_mb);
+      p.addScaledVector(_mt, w);
+    }
+    const targetNrm = n ? morphNrm?.[t] : void 0;
+    if (n && targetNrm) {
+      _mt.fromBufferAttribute(targetNrm, v);
+      if (!morphRelative) _mt.sub(_mbn);
+      n.addScaledVector(_mt, w);
+    }
+  }
+}
 function asAttribute(value, mesh, name) {
   if (!(value instanceof BufferAttribute)) {
     throw new Error(
@@ -61,7 +159,14 @@ function asAttribute(value, mesh, name) {
   }
   return value;
 }
-function collectParts(root) {
+function deriveNormals(position, index) {
+  const scratch = new BufferGeometry();
+  scratch.setAttribute("position", position);
+  scratch.setIndex(index);
+  scratch.computeVertexNormals();
+  return scratch.attributes.normal;
+}
+function collectParts(root, hooks) {
   const found = [];
   root.traverse((o) => {
     const mesh = o;
@@ -70,6 +175,10 @@ function collectParts(root) {
   if (found.length === 0) {
     throw new Error("three-vat: no Mesh found under root; nothing to bake");
   }
+  const flat = hooks ? planFlatMerge(
+    found.flatMap((mesh) => Array.isArray(mesh.material) ? [] : [mesh.material]),
+    hooks
+  ) : null;
   const materials = [];
   const parts = [];
   for (const mesh of found) {
@@ -79,11 +188,13 @@ function collectParts(root) {
       );
     }
     const geometry = mesh.geometry;
-    if (!geometry.attributes.normal) geometry.computeVertexNormals();
-    const material = mesh.material;
+    const source = mesh.material;
+    const merged = flat?.targetOf(source);
+    const material = merged?.material ?? source;
     let materialIndex = materials.indexOf(material);
     if (materialIndex === -1) materialIndex = materials.push(material) - 1;
     const skinned = mesh;
+    const basePos = asAttribute(geometry.attributes.position, mesh, "position");
     parts.push({
       mesh,
       material,
@@ -91,8 +202,8 @@ function collectParts(root) {
       vertexStart: 0,
       // assigned below, after material sorting
       vertexCount: geometry.attributes.position.count,
-      basePos: asAttribute(geometry.attributes.position, mesh, "position"),
-      baseNrm: asAttribute(geometry.attributes.normal, mesh, "normal"),
+      basePos,
+      baseNrm: geometry.attributes.normal ? asAttribute(geometry.attributes.normal, mesh, "normal") : deriveNormals(basePos, geometry.index),
       isSkinned: !!geometry.attributes.skinWeight && !!skinned.skeleton,
       skeleton: skinned.skeleton,
       pose: void 0,
@@ -101,7 +212,8 @@ function collectParts(root) {
       skinWeight: geometry.attributes.skinWeight,
       morphPos: geometry.morphAttributes.position,
       morphNrm: geometry.morphAttributes.normal,
-      morphRelative: geometry.morphTargetsRelative
+      morphRelative: geometry.morphTargetsRelative,
+      tint: merged?.tint ?? null
     });
   }
   parts.sort((a, b) => a.materialIndex - b.materialIndex);
@@ -115,42 +227,48 @@ function collectParts(root) {
 function mergeGeometry(parts, restMatrices, total) {
   const position = new Float32Array(total * 3);
   const normal = new Float32Array(total * 3);
-  const want = optionalAttributes(parts);
+  const _v = new Vector3();
+  const _n = new Vector3();
+  parts.forEach((part, pi) => {
+    const m = restMatrices[pi];
+    for (let v = 0; v < part.vertexCount; v++) {
+      _v.fromBufferAttribute(part.basePos, v).applyMatrix4(m);
+      _n.fromBufferAttribute(part.baseNrm, v).transformDirection(m);
+      _v.toArray(position, (part.vertexStart + v) * 3);
+      _n.toArray(normal, (part.vertexStart + v) * 3);
+    }
+  });
+  const merged = new BufferGeometry();
+  merged.setAttribute("position", new BufferAttribute(position, 3));
+  merged.setAttribute("normal", new BufferAttribute(normal, 3));
+  mergeSurface(merged, parts, total, restMatrices);
+  return merged;
+}
+function mergeSurface(merged, parts, total, restMatrices) {
+  const merging = parts.some((p) => p.tint);
+  const want = optionalAttributes(parts, merging);
   const uv = want.uv ? new Float32Array(total * 2) : null;
   const color = want.color ? new Float32Array(total * 3) : null;
   const tangent = want.tangent ? new Float32Array(total * 4) : null;
-  const _v = new Vector3();
-  const _n = new Vector3();
   const _t = new Vector3();
   parts.forEach((part, pi) => {
-    const m = restMatrices[pi];
     const geometry = part.mesh.geometry;
     const start = part.vertexStart;
     const srcUV = uv ? asAttribute(geometry.attributes.uv, part.mesh, "uv") : null;
-    const srcColor = color ? asAttribute(geometry.attributes.color, part.mesh, "color") : null;
+    const srcColor = color ? colorSource(part, merging) : null;
     const srcTangent = tangent ? geometry.attributes.tangent : null;
+    const m = restMatrices?.[pi];
     for (let v = 0; v < part.vertexCount; v++) {
-      _v.fromBufferAttribute(part.basePos, v).applyMatrix4(m);
-      _n.fromBufferAttribute(part.baseNrm, v).transformDirection(m);
-      const o3 = (start + v) * 3;
-      position[o3] = _v.x;
-      position[o3 + 1] = _v.y;
-      position[o3 + 2] = _v.z;
-      normal[o3] = _n.x;
-      normal[o3 + 1] = _n.y;
-      normal[o3 + 2] = _n.z;
+      const vi = start + v;
       if (uv && srcUV) {
-        uv[(start + v) * 2] = srcUV.getX(v);
-        uv[(start + v) * 2 + 1] = srcUV.getY(v);
-      }
-      if (color && srcColor) {
-        color[o3] = srcColor.getX(v);
-        color[o3 + 1] = srcColor.getY(v);
-        color[o3 + 2] = srcColor.getZ(v);
+        uv[vi * 2] = srcUV.getX(v);
+        uv[vi * 2 + 1] = srcUV.getY(v);
       }
+      if (color) writeColor(color, vi * 3, part, srcColor, v);
       if (tangent && srcTangent) {
-        _t.fromBufferAttribute(srcTangent, v).transformDirection(m);
-        const o4 = (start + v) * 4;
+        _t.fromBufferAttribute(srcTangent, v);
+        if (m) _t.transformDirection(m);
+        const o4 = vi * 4;
         tangent[o4] = _t.x;
         tangent[o4 + 1] = _t.y;
         tangent[o4 + 2] = _t.z;
@@ -158,19 +276,37 @@ function mergeGeometry(parts, restMatrices, total) {
       }
     }
   });
-  const merged = new BufferGeometry();
-  merged.setAttribute("position", new BufferAttribute(position, 3));
-  merged.setAttribute("normal", new BufferAttribute(normal, 3));
   if (uv) merged.setAttribute("uv", new BufferAttribute(uv, 2));
   if (color) merged.setAttribute("color", new BufferAttribute(color, 3));
   if (tangent) merged.setAttribute("tangent", new BufferAttribute(tangent, 4));
   indexParts(merged, parts);
-  return merged;
 }
-function optionalAttributes(parts) {
+function colorSource(part, merging) {
+  const source = part.mesh.geometry.attributes.color;
+  if (part.tint || !source) return null;
+  if (merging && source instanceof InterleavedBufferAttribute) return source;
+  return asAttribute(source, part.mesh, "color");
+}
+function writeColor(out, o3, part, source, v) {
+  if (part.tint) {
+    out[o3] = part.tint.r;
+    out[o3 + 1] = part.tint.g;
+    out[o3 + 2] = part.tint.b;
+  } else if (source) {
+    out[o3] = source.getX(v);
+    out[o3 + 1] = source.getY(v);
+    out[o3 + 2] = source.getZ(v);
+  } else {
+    out[o3] = out[o3 + 1] = out[o3 + 2] = 1;
+  }
+}
+function optionalAttributes(parts, merging) {
   return {
     uv: parts.every((p) => !!p.mesh.geometry.attributes.uv),
-    color: parts.every((p) => !!p.mesh.geometry.attributes.color),
+    // A merge writes a colour for every part it touched, so the attribute is
+    // there whenever one happened; a part it did not touch keeps its own, or
+    // white, which leaves an untinted material's shading as it was.
+    color: merging || parts.every((p) => !!p.mesh.geometry.attributes.color),
     tangent: parts.every((p) => {
       const t = p.mesh.geometry.attributes.tangent;
       return t instanceof BufferAttribute && t.itemSize === 4;
@@ -214,31 +350,96 @@ function frameCountsFor(clips, fps, maxTextureSize) {
   return { frameCounts, totalFrames };
 }
 function bakeVAT(root, animations, options = {}) {
-  const { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE, bakeNormals = true, encoding = "delta" } = options;
+  return bakeVATWith(root, animations, options, FLAT_MERGE);
+}
+function bakeVATWith(root, animations, options, hooks) {
+  const {
+    fps = 30,
+    maxTextureSize = MAX_TEXTURE_SIZE,
+    bakeNormals = true,
+    encoding = "auto",
+    mergeFlatMaterials = false
+  } = options;
   const resolved = animations.map(resolveAnimation);
-  const clips = resolved.map((a) => a.clip);
   root.updateMatrixWorld(true);
-  const parts = collectParts(root);
+  const parts = collectParts(root, mergeFlatMaterials ? hooks : null);
   if (encoding === "rig") return bakeRig(root, parts, resolved, { fps, maxTextureSize });
-  const vertexCount = parts.reduce((n, p) => n + p.vertexCount, 0);
-  if (vertexCount > maxTextureSize) {
+  if (encoding === "delta") {
+    return { ...bakeVertices(root, parts, resolved, { fps, maxTextureSize, bakeNormals }), fallback: null };
+  }
+  let refusal;
+  try {
+    return bakeRig(root, parts, resolved, { fps, maxTextureSize });
+  } catch (error) {
+    if (!(error instanceof RigRefusal)) throw error;
+    refusal = error;
+  }
+  try {
+    return { ...bakeVertices(root, parts, resolved, { fps, maxTextureSize, bakeNormals }), fallback: refusal.message };
+  } catch (error) {
+    if (!(error instanceof Error)) throw error;
     throw new Error(
-      `three-vat: vertexCount ${vertexCount} exceeds maxTextureSize ${maxTextureSize}; row wrapping is not implemented`
+      `three-vat: neither encoding can bake this subtree. The vertex encoding: ${unprefixed(error)}. The rig encoding, tried first: ${unprefixed(refusal)}`,
+      { cause: refusal }
     );
   }
+}
+function unprefixed(error) {
+  return error.message.replace(/^three-vat: /, "");
+}
+function sampleClips(root, resolved, frameCounts, poses, writeFrame) {
+  const mixer = new AnimationMixer(root);
+  const clipTable = [];
+  let rowOffset = 0;
+  try {
+    for (let ci = 0; ci < resolved.length; ci++) {
+      const { clip, defaults } = resolved[ci];
+      const frames = frameCounts[ci];
+      const action = mixer.clipAction(clip);
+      action.play();
+      let maxDeltaSq = 0;
+      for (let f = 0; f < frames; f++) {
+        mixer.setTime(f / frames * clip.duration);
+        root.updateMatrixWorld(true);
+        poseSkeletons(poses);
+        maxDeltaSq = Math.max(maxDeltaSq, writeFrame(clip, f, rowOffset + f));
+      }
+      action.stop();
+      clipTable.push({
+        name: clip.name,
+        startFrame: rowOffset,
+        frames,
+        fps: frames / clip.duration,
+        duration: clip.duration,
+        maxDelta: Math.sqrt(maxDeltaSq),
+        // Declared once, here, rather than repeated at every instance that plays
+        // this band. An instance overrides any of them, field by field.
+        ...defaults
+      });
+      rowOffset += frames;
+    }
+  } finally {
+    mixer.stopAllAction();
+    mixer.setTime(0);
+    root.updateMatrixWorld(true);
+  }
+  return clipTable;
+}
+function bakeVertices(root, parts, resolved, { fps, maxTextureSize, bakeNormals }) {
+  const clips = resolved.map((a) => a.clip);
+  const vertexCount = parts.reduce((n, p) => n + p.vertexCount, 0);
   const { frameCounts, totalFrames } = frameCountsFor(clips, fps, maxTextureSize);
+  const { rowsPerFrame, width, height, frameStride } = vertexLayoutFor(vertexCount, totalFrames, maxTextureSize);
   const rootInverse = root.matrixWorld.clone().invert();
   const restMatrices = parts.map(
     (p) => new Matrix4().multiplyMatrices(rootInverse, p.mesh.matrixWorld)
   );
   const geometry = mergeGeometry(parts, restMatrices, vertexCount);
   const mergedBase = geometry.attributes.position;
-  const posData = new Float32Array(vertexCount * totalFrames * 4);
-  const nrmData = bakeNormals ? new Float32Array(vertexCount * totalFrames * 4) : null;
+  const posData = new Uint16Array(frameStride * totalFrames * 4);
+  const nrmData = bakeNormals ? new Uint8Array(frameStride * totalFrames * 2) : null;
   const bakeNormal = nrmData !== null;
-  const mixer = new AnimationMixer(root);
   const bounds = new Box3();
-  const clipTable = [];
   const _si = new Vector4();
   const _sw = new Vector4();
   const _acc = new Matrix4();
@@ -247,129 +448,86 @@ function bakeVAT(root, animations, options = {}) {
   const _p = new Vector3();
   const _bp = new Vector3();
   const _n = new Vector3();
-  const _mt = new Vector3();
-  const _mb = new Vector3();
-  const _mbn = new Vector3();
   const poses = attachPoseBuffers(parts);
   const influencers = bakeNormals ? parts.filter((p) => p.pose).map(influencedBones) : [];
   let warnedNonUniformScale = false;
-  let rowOffset = 0;
-  clips.forEach((clip, ci) => {
-    const frames = frameCounts[ci];
-    const action = mixer.clipAction(clip);
-    action.play();
+  const writeFrame = (clip, f, row) => {
     let maxDeltaSq = 0;
-    for (let f = 0; f < frames; f++) {
-      mixer.setTime(f / frames * clip.duration);
-      root.updateMatrixWorld(true);
-      const row = rowOffset + f;
-      poseSkeletons(poses);
-      if (!warnedNonUniformScale) {
-        warnedNonUniformScale = warnOnNonUniformBoneScale(influencers);
-      }
-      for (const part of parts) {
-        _partMatrix.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
-        const influences = part.mesh.morphTargetInfluences;
-        const { morphPos, morphNrm, morphRelative, isSkinned, skinIndex, skinWeight } = part;
-        const boneMatrices = part.pose?.matrices;
-        const morphCount = morphCountOf(part);
-        for (let v = 0; v < part.vertexCount; v++) {
-          const vi = part.vertexStart + v;
-          _p.fromBufferAttribute(part.basePos, v);
-          if (bakeNormal) _n.fromBufferAttribute(part.baseNrm, v);
-          if (influences && morphCount > 0) {
-            if (!morphRelative) {
-              _mb.fromBufferAttribute(part.basePos, v);
-              if (bakeNormal) _mbn.fromBufferAttribute(part.baseNrm, v);
-            }
-            for (let t = 0; t < morphCount; t++) {
-              const w = influences[t];
-              if (w === 0) continue;
-              const targetPos = morphPos?.[t];
-              if (targetPos) {
-                _mt.fromBufferAttribute(targetPos, v);
-                if (!morphRelative) _mt.sub(_mb);
-                _p.addScaledVector(_mt, w);
-              }
-              const targetNrm = bakeNormal ? morphNrm?.[t] : void 0;
-              if (targetNrm) {
-                _mt.fromBufferAttribute(targetNrm, v);
-                if (!morphRelative) _mt.sub(_mbn);
-                _n.addScaledVector(_mt, w);
-              }
-            }
-          }
-          if (isSkinned && boneMatrices) {
-            const skinned = part.mesh;
-            _si.fromBufferAttribute(skinIndex, v);
-            _sw.fromBufferAttribute(skinWeight, v);
-            const ae = _acc.elements;
-            ae.fill(0);
-            for (let i = 0; i < 4; i++) {
-              const w = _sw.getComponent(i);
-              if (w === 0) continue;
-              const b = _si.getComponent(i) * BONE_STRIDE;
-              for (let e = 0; e < 16; e++) ae[e] += boneMatrices[b + e] * w;
-            }
-            _skin.multiplyMatrices(_acc, skinned.bindMatrix).premultiply(skinned.bindMatrixInverse);
-            _p.applyMatrix4(_skin);
-            if (bakeNormal) _n.transformDirection(_skin);
-          }
-          _p.applyMatrix4(_partMatrix);
-          if (bakeNormal) _n.transformDirection(_partMatrix);
-          bounds.expandByPoint(_p);
-          _bp.fromBufferAttribute(mergedBase, vi);
-          const o = (row * vertexCount + vi) * 4;
-          const dx = _p.x - _bp.x;
-          const dy = _p.y - _bp.y;
-          const dz = _p.z - _bp.z;
-          maxDeltaSq = Math.max(maxDeltaSq, dx * dx + dy * dy + dz * dz);
-          posData[o] = dx;
-          posData[o + 1] = dy;
-          posData[o + 2] = dz;
-          posData[o + 3] = 1;
-          if (bakeNormal) {
-            nrmData[o] = _n.x;
-            nrmData[o + 1] = _n.y;
-            nrmData[o + 2] = _n.z;
-            nrmData[o + 3] = 1;
+    if (!warnedNonUniformScale) {
+      warnedNonUniformScale = warnOnNonUniformBoneScale(influencers);
+    }
+    for (const part of parts) {
+      _partMatrix.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
+      const influences = part.mesh.morphTargetInfluences;
+      const { isSkinned, skinIndex, skinWeight } = part;
+      const boneMatrices = part.pose?.matrices;
+      const morphCount = morphCountOf(part);
+      for (let v = 0; v < part.vertexCount; v++) {
+        const vi = part.vertexStart + v;
+        _p.fromBufferAttribute(part.basePos, v);
+        if (bakeNormal) _n.fromBufferAttribute(part.baseNrm, v);
+        if (influences && morphCount > 0) morphVertex(part, v, influences, morphCount, _p, bakeNormal ? _n : null);
+        if (isSkinned && boneMatrices) {
+          const skinned = part.mesh;
+          _si.fromBufferAttribute(skinIndex, v);
+          _sw.fromBufferAttribute(skinWeight, v);
+          const ae = _acc.elements;
+          for (let e = 0; e < 16; e++) ae[e] = 0;
+          for (let i = 0; i < 4; i++) {
+            const w = _sw.getComponent(i);
+            if (w === 0) continue;
+            const b = _si.getComponent(i) * BONE_STRIDE;
+            for (let e = 0; e < 16; e++) ae[e] += boneMatrices[b + e] * w;
           }
+          _skin.multiplyMatrices(_acc, skinned.bindMatrix).premultiply(skinned.bindMatrixInverse);
+          _p.applyMatrix4(_skin);
+          if (bakeNormal) _n.transformDirection(_skin);
+        }
+        _p.applyMatrix4(_partMatrix);
+        if (bakeNormal) _n.transformDirection(_partMatrix);
+        bounds.expandByPoint(_p);
+        _bp.fromBufferAttribute(mergedBase, vi);
+        const texel = row * frameStride + vi;
+        const o = texel * 4;
+        const dx = _p.x - _bp.x;
+        const dy = _p.y - _bp.y;
+        const dz = _p.z - _bp.z;
+        maxDeltaSq = Math.max(maxDeltaSq, dx * dx + dy * dy + dz * dz);
+        const largest = Math.max(Math.abs(dx), Math.abs(dy), Math.abs(dz));
+        if (largest > HALF_FLOAT_MAX) {
+          throw new Error(
+            `three-vat: position delta component ${largest} (clip "${clip.name}", frame ${f}, vertex ${vi}) exceeds the half-float limit of ${HALF_FLOAT_MAX} the position texture stores; a unit smaller than the metre is the usual cause`
+          );
         }
+        posData[o] = toHalfFloat(dx);
+        posData[o + 1] = toHalfFloat(dy);
+        posData[o + 2] = toHalfFloat(dz);
+        posData[o + 3] = HALF_ONE;
+        if (bakeNormal) encodeOctahedral(_n.x, _n.y, _n.z, nrmData, texel * 2);
       }
     }
-    action.stop();
-    clipTable.push({
-      name: clip.name,
-      startFrame: rowOffset,
-      frames,
-      fps: frames / clip.duration,
-      duration: clip.duration,
-      maxDelta: Math.sqrt(maxDeltaSq),
-      // Declared once, here, rather than repeated at every instance that plays
-      // this band. An instance overrides any of them, field by field.
-      ...resolved[ci].defaults
-    });
-    rowOffset += frames;
-  });
-  mixer.stopAllAction();
-  mixer.setTime(0);
-  root.updateMatrixWorld(true);
+    return maxDeltaSq;
+  };
+  const clipTable = sampleClips(root, resolved, frameCounts, poses, writeFrame);
   geometry.boundingBox = bounds.clone();
   geometry.boundingSphere = bounds.getBoundingSphere(new Sphere());
   const materials = [];
   for (const part of parts) materials[part.materialIndex] = part.material;
   return {
-    positionTexture: makeVATTexture(posData, vertexCount, totalFrames),
-    normalTexture: nrmData ? makeVATTexture(nrmData, vertexCount, totalFrames) : null,
+    positionTexture: makeVATTexture(posData, width, height, HalfFloatType),
+    normalTexture: nrmData ? makeVATNormalTexture(nrmData, width, height) : null,
     clips: clipTable,
     bounds,
     vertexCount,
     totalFrames,
+    rowsPerFrame,
     encoding: "delta",
     geometry,
     materials
   };
 }
+var toHalfFloat = DataUtils.toHalfFloat;
+var HALF_ONE = /* @__PURE__ */ toHalfFloat(1);
 var BONE_STRIDE = 16;
 var IDENTITY = /* @__PURE__ */ new Matrix4();
 function attachPoseBuffers(parts) {
@@ -408,6 +566,7 @@ function influencedBones(part) {
   return { pose: part.pose, bones: [...used] };
 }
 var SCALE_UNIFORMITY_EPSILON = 1e-4;
+var MATRIX_BASIS = [0, 1, 2, 4, 5, 6, 8, 9, 10];
 function hasNonUniformScale(matrices, b) {
   const o = b * BONE_STRIDE;
   return unevenSquares(
@@ -416,6 +575,13 @@ function hasNonUniformScale(matrices, b) {
     matrices[o + 8] ** 2 + matrices[o + 9] ** 2 + matrices[o + 10] ** 2
   );
 }
+function hasShear(matrices, b) {
+  const m = (i) => matrices[b * BONE_STRIDE + i];
+  const lengthSq = (a) => m(a) ** 2 + m(a + 1) ** 2 + m(a + 2) ** 2;
+  const dot = (a, c) => m(a) * m(c) + m(a + 1) * m(c + 1) + m(a + 2) * m(c + 2);
+  const square = (a, c) => dot(a, c) ** 2 <= SCALE_UNIFORMITY_EPSILON ** 2 * lengthSq(a) * lengthSq(c);
+  return !(square(0, 4) && square(0, 8) && square(4, 8));
+}
 function unevenSquares(x, y, z) {
   const max = Math.max(x, y, z);
   return max - Math.min(x, y, z) > SCALE_UNIFORMITY_EPSILON * max;
@@ -432,7 +598,9 @@ function warnOnNonUniformBoneScale(influencers) {
   }
   return false;
 }
-var USE_VERTEX_ENCODING = "bake this subtree with the vertex encoding (the default) instead";
+var VERTEX_ENCODING_STORES_IT = "the vertex encoding (`encoding: 'delta'`) stores what a rig cannot";
+var RigRefusal = class extends Error {
+};
 function placementOf(part, rootInverse, out) {
   out.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
   if (part.pose) out.multiply(part.mesh.bindMatrixInverse);
@@ -554,39 +722,22 @@ ${clips.join("\n")}`;
     const its = parts.length === 1 ? "its" : "their";
     return `clip${one ? "" : "s"} ${clips.join(", ")} animate${one ? "s" : ""} morph target ${target} of part${parts.length === 1 ? "" : "s"} ${parts.map(partName).join(", ")}, ${its} vertices moving where no bone does`;
   });
-  return new Error(
-    `three-vat: the rig encoding cannot bake this subtree: ${offences.join("; ")}. A slot stores a rotation, a translation and one scale, not a per-vertex delta \u2014 ${USE_VERTEX_ENCODING}`
+  return new RigRefusal(
+    `three-vat: the rig encoding cannot bake this subtree: ${offences.join("; ")}. A slot stores a rotation, a translation and one scale, not a per-vertex delta, and ${VERTEX_ENCODING_STORES_IT}`
   );
 }
 function foldMorphs(part, statics) {
-  const { vertexCount, basePos, baseNrm, morphPos, morphNrm, morphRelative } = part;
+  const { vertexCount, basePos, baseNrm } = part;
   const position = new Float32Array(vertexCount * 3);
   const normal = new Float32Array(vertexCount * 3);
   const active = statics.some((w) => w !== 0);
   const _p = new Vector3();
   const _n = new Vector3();
-  const _mt = new Vector3();
-  const _mb = new Vector3();
   for (let v = 0; v < vertexCount; v++) {
     _p.fromBufferAttribute(basePos, v);
     _n.fromBufferAttribute(baseNrm, v);
     if (active) {
-      for (let t = 0; t < statics.length; t++) {
-        const w = statics[t];
-        if (w === 0) continue;
-        const targetPos = morphPos?.[t];
-        if (targetPos) {
-          _mt.fromBufferAttribute(targetPos, v);
-          if (!morphRelative) _mt.sub(_mb.fromBufferAttribute(basePos, v));
-          _p.addScaledVector(_mt, w);
-        }
-        const targetNrm = morphNrm?.[t];
-        if (targetNrm) {
-          _mt.fromBufferAttribute(targetNrm, v);
-          if (!morphRelative) _mt.sub(_mb.fromBufferAttribute(baseNrm, v));
-          _n.addScaledVector(_mt, w);
-        }
-      }
+      morphVertex(part, v, statics, statics.length, _p, _n);
       _n.normalize();
     }
     _p.toArray(position, v * 3);
@@ -631,8 +782,8 @@ function refuseAnimatedNonUniformScale(slots, clips, root, influenced) {
   }
 }
 function nonUniformScale(label, clip) {
-  return new Error(
-    `three-vat: ${label} animates with non-uniform scale in clip "${clip.name}", which the rig encoding cannot store \u2014 a slot is a rotation, a translation and one scale. ${USE_VERTEX_ENCODING}, or author it with a uniform scale.`
+  return new RigRefusal(
+    `three-vat: ${label} animates with non-uniform scale in clip "${clip.name}", which the rig encoding cannot store \u2014 a slot is a rotation, a translation and one scale, and ${VERTEX_ENCODING_STORES_IT}. Authored with a uniform scale, it bakes as a rig`
   );
 }
 function bakeRig(root, parts, resolved, { fps, maxTextureSize }) {
@@ -651,7 +802,7 @@ function bakeRig(root, parts, resolved, { fps, maxTextureSize }) {
   }));
   const width = slotCount * RIG_TEXELS_PER_SLOT;
   if (width > maxTextureSize) {
-    throw new Error(
+    throw new RigRefusal(
       `three-vat: rig texture width ${width} (${slotCount} slots \xD7 ${RIG_TEXELS_PER_SLOT} texels) exceeds maxTextureSize ${maxTextureSize}`
     );
   }
@@ -670,7 +821,7 @@ function bakeRig(root, parts, resolved, { fps, maxTextureSize }) {
   const _slot = new Matrix4();
   const _partMatrix = new Matrix4();
   const placements = new Map(parts.map((part) => [part, new Matrix4()]));
-  const _q = new Quaternion();
+  const _q2 = new Quaternion();
   const _t = new Vector3();
   const _s = new Vector3();
   const restRoot = new Float64Array(vertexCount * 3);
@@ -684,114 +835,101 @@ function bakeRig(root, parts, resolved, { fps, maxTextureSize }) {
   const data = new Float32Array(width * totalFrames * 4);
   const slotMatrices = new Float64Array(slotCount * BONE_STRIDE);
   const previous = new Float64Array(slotCount * 4);
-  const mixer = new AnimationMixer(root);
   const bounds = new Box3();
-  const clipTable = [];
   let minX = Infinity;
   let minY = Infinity;
   let minZ = Infinity;
   let maxX = -Infinity;
   let maxY = -Infinity;
   let maxZ = -Infinity;
-  let rowOffset = 0;
-  clips.forEach((clip, ci) => {
-    const frames = frameCounts[ci];
-    const action = mixer.clipAction(clip);
-    action.play();
+  const writeFrame = (clip, _f, row) => {
     let maxDeltaSq = 0;
-    for (let f = 0; f < frames; f++) {
-      mixer.setTime(f / frames * clip.duration);
-      root.updateMatrixWorld(true);
-      const row = rowOffset + f;
-      poseSkeletons(poses);
-      for (const [part, placement] of placements) placementOf(part, rootInverse, placement);
-      for (let slot = 0; slot < slotCount; slot++) {
-        const { rig, parts: readers } = slots[slot];
-        const lead = readers[0];
-        const placement = placements.get(lead);
-        for (let pi = 1; pi < readers.length; pi++) {
-          const other = readers[pi];
-          if (!matricesClose(placement, placements.get(other))) {
-            throw new Error(
-              `three-vat: parts ${partName(lead)} and ${partName(other)} read the same slots but move apart in clip "${clip.name}"; the rig encoding gives them one set of slots, which cannot place them differently \u2014 ${USE_VERTEX_ENCODING}`
-            );
-          }
-        }
-        if (rig) {
-          _slot.fromArray(rig.pose.matrices, rig.bone * BONE_STRIDE).multiply(rig.bindMatrix).premultiply(placement);
-        } else {
-          _slot.copy(placement);
-        }
-        slotMatrices.set(_slot.elements, slot * BONE_STRIDE);
-        if (influenced[slot] && hasNonUniformScale(slotMatrices, slot)) {
-          throw nonUniformScale(slotLabel(slots[slot]), clip);
-        }
-        _slot.decompose(_t, _q, _s);
-        const p4 = slot * 4;
-        if (previous[p4] * _q.x + previous[p4 + 1] * _q.y + previous[p4 + 2] * _q.z + previous[p4 + 3] * _q.w < 0) {
-          _q.set(-_q.x, -_q.y, -_q.z, -_q.w);
+    for (const [part, placement] of placements) placementOf(part, rootInverse, placement);
+    for (let slot = 0; slot < slotCount; slot++) {
+      const { rig, parts: readers } = slots[slot];
+      const lead = readers[0];
+      const placement = placements.get(lead);
+      for (let pi = 1; pi < readers.length; pi++) {
+        const other = readers[pi];
+        if (!matricesClose(placement, placements.get(other))) {
+          throw new RigRefusal(
+            `three-vat: parts ${partName(lead)} and ${partName(other)} read the same slots but move apart in clip "${clip.name}"; the rig encoding gives them one set of slots, which cannot place them differently, and ${VERTEX_ENCODING_STORES_IT}`
+          );
         }
-        previous[p4] = _q.x;
-        previous[p4 + 1] = _q.y;
-        previous[p4 + 2] = _q.z;
-        previous[p4 + 3] = _q.w;
-        const o = (row * width + slot * RIG_TEXELS_PER_SLOT) * 4;
-        const rotation = o + RIG_TEXELS.rotation * 4;
-        data[rotation] = _q.x;
-        data[rotation + 1] = _q.y;
-        data[rotation + 2] = _q.z;
-        data[rotation + 3] = _q.w;
-        const placementTexel = o + RIG_TEXELS.placement * 4;
-        data[placementTexel] = _t.x;
-        data[placementTexel + 1] = _t.y;
-        data[placementTexel + 2] = _t.z;
-        data[placementTexel + 3] = _s.x;
       }
-      for (let v = 0; v < vertexCount; v++) {
-        const o3 = v * 3;
-        const o4 = v * 4;
-        const x = localPosition[o3];
-        const y = localPosition[o3 + 1];
-        const z = localPosition[o3 + 2];
-        let px = 0;
-        let py = 0;
-        let pz = 0;
-        for (let i = 0; i < 4; i++) {
-          const w = skinWeight[o4 + i];
-          if (w === 0) continue;
-          const m = skinIndex[o4 + i] * BONE_STRIDE;
-          px += w * (slotMatrices[m] * x + slotMatrices[m + 4] * y + slotMatrices[m + 8] * z + slotMatrices[m + 12]);
-          py += w * (slotMatrices[m + 1] * x + slotMatrices[m + 5] * y + slotMatrices[m + 9] * z + slotMatrices[m + 13]);
-          pz += w * (slotMatrices[m + 2] * x + slotMatrices[m + 6] * y + slotMatrices[m + 10] * z + slotMatrices[m + 14]);
-        }
-        if (px < minX) minX = px;
-        if (px > maxX) maxX = px;
-        if (py < minY) minY = py;
-        if (py > maxY) maxY = py;
-        if (pz < minZ) minZ = pz;
-        if (pz > maxZ) maxZ = pz;
-        const dx = px - restRoot[o3];
-        const dy = py - restRoot[o3 + 1];
-        const dz = pz - restRoot[o3 + 2];
-        const deltaSq = dx * dx + dy * dy + dz * dz;
-        if (deltaSq > maxDeltaSq) maxDeltaSq = deltaSq;
+      if (rig) {
+        _slot.fromArray(rig.pose.matrices, rig.bone * BONE_STRIDE).multiply(rig.bindMatrix).premultiply(placement);
+      } else {
+        _slot.copy(placement);
+      }
+      slotMatrices.set(_slot.elements, slot * BONE_STRIDE);
+      if (influenced[slot] && (hasNonUniformScale(slotMatrices, slot) || hasShear(slotMatrices, slot))) {
+        throw nonUniformScale(slotLabel(slots[slot]), clip);
+      }
+      const p4 = slot * 4;
+      const det = _slot.determinant();
+      let scale;
+      if (det === 0) {
+        _t.setFromMatrixPosition(_slot);
+        _q2.fromArray(previous, p4);
+        if (_q2.lengthSq() === 0) _q2.identity();
+        scale = 0;
+      } else {
+        if (det < 0) for (const e of MATRIX_BASIS) _slot.elements[e] = -_slot.elements[e];
+        _slot.decompose(_t, _q2, _s);
+        scale = det < 0 ? -_s.x : _s.x;
+      }
+      if (previous[p4] * _q2.x + previous[p4 + 1] * _q2.y + previous[p4 + 2] * _q2.z + previous[p4 + 3] * _q2.w < 0) {
+        _q2.set(-_q2.x, -_q2.y, -_q2.z, -_q2.w);
       }
+      previous[p4] = _q2.x;
+      previous[p4 + 1] = _q2.y;
+      previous[p4 + 2] = _q2.z;
+      previous[p4 + 3] = _q2.w;
+      const o = (row * width + slot * RIG_TEXELS_PER_SLOT) * 4;
+      const rotation = o + RIG_TEXELS.rotation * 4;
+      data[rotation] = _q2.x;
+      data[rotation + 1] = _q2.y;
+      data[rotation + 2] = _q2.z;
+      data[rotation + 3] = _q2.w;
+      const placementTexel = o + RIG_TEXELS.placement * 4;
+      data[placementTexel] = _t.x;
+      data[placementTexel + 1] = _t.y;
+      data[placementTexel + 2] = _t.z;
+      data[placementTexel + 3] = scale;
     }
-    action.stop();
-    clipTable.push({
-      name: clip.name,
-      startFrame: rowOffset,
-      frames,
-      fps: frames / clip.duration,
-      duration: clip.duration,
-      maxDelta: Math.sqrt(maxDeltaSq),
-      ...resolved[ci].defaults
-    });
-    rowOffset += frames;
-  });
-  mixer.stopAllAction();
-  mixer.setTime(0);
-  root.updateMatrixWorld(true);
+    for (let v = 0; v < vertexCount; v++) {
+      const o3 = v * 3;
+      const o4 = v * 4;
+      const x = localPosition[o3];
+      const y = localPosition[o3 + 1];
+      const z = localPosition[o3 + 2];
+      let px = 0;
+      let py = 0;
+      let pz = 0;
+      for (let i = 0; i < 4; i++) {
+        const w = skinWeight[o4 + i];
+        if (w === 0) continue;
+        const m = skinIndex[o4 + i] * BONE_STRIDE;
+        px += w * (slotMatrices[m] * x + slotMatrices[m + 4] * y + slotMatrices[m + 8] * z + slotMatrices[m + 12]);
+        py += w * (slotMatrices[m + 1] * x + slotMatrices[m + 5] * y + slotMatrices[m + 9] * z + slotMatrices[m + 13]);
+        pz += w * (slotMatrices[m + 2] * x + slotMatrices[m + 6] * y + slotMatrices[m + 10] * z + slotMatrices[m + 14]);
+      }
+      if (px < minX) minX = px;
+      if (px > maxX) maxX = px;
+      if (py < minY) minY = py;
+      if (py > maxY) maxY = py;
+      if (pz < minZ) minZ = pz;
+      if (pz > maxZ) maxZ = pz;
+      const dx = px - restRoot[o3];
+      const dy = py - restRoot[o3 + 1];
+      const dz = pz - restRoot[o3 + 2];
+      const deltaSq = dx * dx + dy * dy + dz * dz;
+      if (deltaSq > maxDeltaSq) maxDeltaSq = deltaSq;
+    }
+    return maxDeltaSq;
+  };
+  const clipTable = sampleClips(root, resolved, frameCounts, poses, writeFrame);
   bounds.min.set(minX, minY, minZ);
   bounds.max.set(maxX, maxY, maxZ);
   geometry.boundingBox = bounds.clone();
@@ -811,29 +949,18 @@ function bakeRig(root, parts, resolved, { fps, maxTextureSize }) {
   };
 }
 function mergeRigGeometry(rigParts, total) {
-  const parts = rigParts.map((r) => r.part);
   const position = new Float32Array(total * 3);
   const normal = new Float32Array(total * 3);
   const slotIndex = new Uint16Array(total * 4);
   const slotWeight = new Float32Array(total * 4);
-  const want = optionalAttributes(parts);
-  const uv = want.uv ? new Float32Array(total * 2) : null;
-  const color = want.color ? new Float32Array(total * 3) : null;
-  const tangent = want.tangent ? new Float32Array(total * 4) : null;
   for (const { part, slotOf, position: restPos, normal: restNrm } of rigParts) {
-    const geometry = part.mesh.geometry;
     const start = part.vertexStart;
     const srcIndex = part.pose ? part.skinIndex : null;
     const srcWeight = part.pose ? part.skinWeight : null;
-    const srcUV = uv ? asAttribute(geometry.attributes.uv, part.mesh, "uv") : null;
-    const srcColor = color ? asAttribute(geometry.attributes.color, part.mesh, "color") : null;
-    const srcTangent = tangent ? geometry.attributes.tangent : null;
     position.set(restPos, start * 3);
     normal.set(restNrm, start * 3);
     for (let v = 0; v < part.vertexCount; v++) {
-      const vi = start + v;
-      const o3 = vi * 3;
-      const o4 = vi * 4;
+      const o4 = (start + v) * 4;
       if (srcIndex && srcWeight) {
         for (let i = 0; i < 4; i++) {
           slotIndex[o4 + i] = slotOf[srcIndex.getComponent(v, i)];
@@ -843,21 +970,6 @@ function mergeRigGeometry(rigParts, total) {
         slotIndex[o4] = slotOf[0];
         slotWeight[o4] = 1;
       }
-      if (uv && srcUV) {
-        uv[vi * 2] = srcUV.getX(v);
-        uv[vi * 2 + 1] = srcUV.getY(v);
-      }
-      if (color && srcColor) {
-        color[o3] = srcColor.getX(v);
-        color[o3 + 1] = srcColor.getY(v);
-        color[o3 + 2] = srcColor.getZ(v);
-      }
-      if (tangent && srcTangent) {
-        tangent[o4] = srcTangent.getX(v);
-        tangent[o4 + 1] = srcTangent.getY(v);
-        tangent[o4 + 2] = srcTangent.getZ(v);
-        tangent[o4 + 3] = srcTangent.getW(v);
-      }
     }
   }
   const merged = new BufferGeometry();
@@ -865,11 +977,472 @@ function mergeRigGeometry(rigParts, total) {
   merged.setAttribute("normal", new BufferAttribute(normal, 3));
   merged.setAttribute("skinIndex", new BufferAttribute(slotIndex, 4));
   merged.setAttribute("skinWeight", new BufferAttribute(slotWeight, 4));
-  if (uv) merged.setAttribute("uv", new BufferAttribute(uv, 2));
-  if (color) merged.setAttribute("color", new BufferAttribute(color, 3));
-  if (tangent) merged.setAttribute("tangent", new BufferAttribute(tangent, 4));
-  indexParts(merged, parts);
+  mergeSurface(merged, rigParts.map((r) => r.part), total, null);
   return merged;
 }
+var REQUEST = "three-vat:bake";
+var RESPONSE = "three-vat:baked";
+function transferable(array, owned, transfer) {
+  const whole = array.byteOffset === 0 && array.byteLength === array.buffer.byteLength;
+  const out = owned && whole ? array : array.slice();
+  transfer.add(out.buffer);
+  return out;
+}
+function recordGeometry(geometry, owned, transfer, interleaved, interleavedRecords) {
+  const attribute = (a, what) => {
+    if (a instanceof InterleavedBufferAttribute) {
+      let buffer = interleaved.get(a.data);
+      if (buffer === void 0) {
+        buffer = interleavedRecords.push({ array: transferable(a.data.array, owned, transfer), stride: a.data.stride }) - 1;
+        interleaved.set(a.data, buffer);
+      }
+      return { kind: "interleaved", buffer, itemSize: a.itemSize, offset: a.offset, normalized: a.normalized, name: a.name };
+    }
+    if (a instanceof BufferAttribute) {
+      return {
+        kind: "plain",
+        array: transferable(a.array, owned, transfer),
+        itemSize: a.itemSize,
+        normalized: a.normalized,
+        name: a.name,
+        ...a instanceof Float16BufferAttribute ? { half: true } : {}
+      };
+    }
+    throw new Error(`three-vat: the "${what}" attribute is neither a BufferAttribute nor an interleaved one; a worker cannot carry it`);
+  };
+  const index = geometry.getIndex();
+  return {
+    attributes: Object.fromEntries(Object.entries(geometry.attributes).map(([name, a]) => [name, attribute(a, name)])),
+    morphAttributes: Object.fromEntries(
+      Object.entries(geometry.morphAttributes).map(([name, list]) => [name, list.map((a) => attribute(a, `morph ${name}`))])
+    ),
+    morphTargetsRelative: geometry.morphTargetsRelative,
+    index: index ? attribute(index, "index") : null,
+    groups: geometry.groups.map((g) => ({ ...g })),
+    drawRange: { ...geometry.drawRange }
+  };
+}
+function rebuildGeometry(record, interleaved) {
+  const attribute = (a) => {
+    const built = a.kind === "plain" ? a.half ? new Float16BufferAttribute(a.array, a.itemSize, a.normalized) : new BufferAttribute(a.array, a.itemSize, a.normalized) : new InterleavedBufferAttribute(interleaved[a.buffer], a.itemSize, a.offset, a.normalized);
+    built.name = a.name;
+    return built;
+  };
+  const geometry = new BufferGeometry();
+  for (const [name, a] of Object.entries(record.attributes)) geometry.setAttribute(name, attribute(a));
+  for (const [name, list] of Object.entries(record.morphAttributes)) {
+    geometry.morphAttributes[name] = list.map(attribute);
+  }
+  geometry.morphTargetsRelative = record.morphTargetsRelative;
+  if (record.index) geometry.setIndex(attribute(record.index));
+  for (const g of record.groups) geometry.addGroup(g.start, g.count, g.materialIndex);
+  geometry.setDrawRange(record.drawRange.start, record.drawRange.count);
+  return geometry;
+}
+var TRACK_TYPES = {
+  bool: BooleanKeyframeTrack,
+  color: ColorKeyframeTrack,
+  number: NumberKeyframeTrack,
+  quaternion: QuaternionKeyframeTrack,
+  string: StringKeyframeTrack,
+  vector: VectorKeyframeTrack
+};
+var READ_PROPERTIES = /* @__PURE__ */ new Set(["position", "quaternion", "rotation", "scale", "morphTargetInfluences"]);
+function bakeReadsTrack(track, root, baked) {
+  const { nodeName, objectName, propertyName } = PropertyBinding.parseTrackName(track.name);
+  if (objectName && objectName !== "bones") return false;
+  if (!READ_PROPERTIES.has(propertyName)) return false;
+  if (propertyName !== "morphTargetInfluences" || objectName) return true;
+  return baked.has(PropertyBinding.findNode(root, nodeName));
+}
+function recordTrack(track, clip, transfer) {
+  const factory = track.createInterpolant;
+  const interpolation = factory.isInterpolantFactoryMethodGLTFCubicSpline ? "gltf-cubic" : track.getInterpolation();
+  if (interpolation === void 0) {
+    throw new Error(
+      `three-vat: track "${track.name}" of clip "${clip.name || "(unnamed)"}" uses a custom interpolant, which a worker cannot carry; bake this clip with bakeVAT on the main thread`
+    );
+  }
+  if (!(track.ValueTypeName in TRACK_TYPES)) {
+    throw new Error(`three-vat: track "${track.name}" is a "${track.ValueTypeName}" track, which a worker cannot rebuild`);
+  }
+  const values = ArrayBuffer.isView(track.values) ? transferable(track.values, false, transfer) : Array.from(track.values);
+  const settings = track.settings;
+  return {
+    name: track.name,
+    type: track.ValueTypeName,
+    times: transferable(track.times, false, transfer),
+    values,
+    interpolation,
+    ...settings?.inTangents && settings.outTangents ? { settings: { inTangents: settings.inTangents, outTangents: settings.outTangents } } : {}
+  };
+}
+var CubicSplineInterpolant = class extends Interpolant {
+  copySampleValue_(index) {
+    const result = this.resultBuffer;
+    const values = this.sampleValues;
+    const size = this.valueSize;
+    const offset = index * size * 3 + size;
+    for (let i = 0; i !== size; i++) result[i] = values[offset + i];
+    return result;
+  }
+  interpolate_(i1, t0, t, t1) {
+    const result = this.resultBuffer;
+    const values = this.sampleValues;
+    const stride = this.valueSize;
+    const stride2 = stride * 2;
+    const stride3 = stride * 3;
+    const td = t1 - t0;
+    const p = (t - t0) / td;
+    const pp = p * p;
+    const ppp = pp * p;
+    const offset1 = i1 * stride3;
+    const offset0 = offset1 - stride3;
+    const s2 = -2 * ppp + 3 * pp;
+    const s3 = ppp - pp;
+    const s0 = 1 - s2;
+    const s1 = s3 - pp + p;
+    for (let i = 0; i !== stride; i++) {
+      const p0 = values[offset0 + i + stride];
+      const m0 = values[offset0 + i + stride2] * td;
+      const p1 = values[offset1 + i + stride];
+      const m1 = values[offset1 + i] * td;
+      result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
+    }
+    return result;
+  }
+};
+var _q = new Quaternion();
+var CubicSplineQuaternionInterpolant = class extends CubicSplineInterpolant {
+  interpolate_(i1, t0, t, t1) {
+    const result = super.interpolate_(i1, t0, t, t1);
+    _q.fromArray(result).normalize().toArray(result);
+    return result;
+  }
+};
+function rebuildTrack(record) {
+  const Track = TRACK_TYPES[record.type];
+  const track = new Track(record.name, record.times, record.values);
+  if (record.interpolation === "gltf-cubic") {
+    const quaternion = track instanceof QuaternionKeyframeTrack;
+    const factory = function(result) {
+      const Kind = quaternion ? CubicSplineQuaternionInterpolant : CubicSplineInterpolant;
+      return new Kind(this.times, this.values, this.getValueSize() / 3, result);
+    };
+    factory.isInterpolantFactoryMethodGLTFCubicSpline = true;
+    track.createInterpolant = factory;
+  } else if (record.interpolation !== track.DefaultInterpolation) {
+    track.setInterpolation(record.interpolation);
+  }
+  if (record.settings) Object.assign(track, { settings: record.settings });
+  return track;
+}
+function isAction2(input) {
+  return typeof input.getClip === "function";
+}
+function recordScene(root, animations, mergeFlat) {
+  const transfer = /* @__PURE__ */ new Set();
+  const nodes = [];
+  const nodeIndex = /* @__PURE__ */ new Map();
+  const geometries = /* @__PURE__ */ new Map();
+  const geometryRecords = [];
+  const interleaved = /* @__PURE__ */ new Map();
+  const interleavedRecords = [];
+  const materials = [];
+  const skeletons = /* @__PURE__ */ new Map();
+  const skinned = [];
+  const baked = /* @__PURE__ */ new Set();
+  const materialOf = (m) => {
+    const i = materials.indexOf(m);
+    return i === -1 ? materials.push(m) - 1 : i;
+  };
+  root.traverse((o) => {
+    const mesh = o;
+    const skin = o;
+    const isBaked = mesh.isMesh && !!mesh.geometry;
+    const record = {
+      kind: isBaked ? skin.isSkinnedMesh ? "skinned" : "mesh" : o.isBone ? "bone" : "object",
+      parent: o === root ? -1 : nodeIndex.get(o.parent),
+      name: o.name,
+      uuid: o.uuid,
+      position: o.position.toArray(),
+      quaternion: o.quaternion.toArray(),
+      scale: o.scale.toArray(),
+      rotationOrder: o.rotation.order,
+      matrixAutoUpdate: o.matrixAutoUpdate,
+      matrixWorldAutoUpdate: o.matrixWorldAutoUpdate,
+      matrix: [...o.matrix.elements],
+      matrixWorld: [...o.matrixWorld.elements]
+    };
+    if (o.pivot) record.pivot = o.pivot.toArray();
+    nodeIndex.set(o, nodes.push(record) - 1);
+    if (isBaked) {
+      baked.add(o);
+      let g = geometries.get(mesh.geometry);
+      if (g === void 0) {
+        g = geometryRecords.push(recordGeometry(mesh.geometry, false, transfer, interleaved, interleavedRecords)) - 1;
+        geometries.set(mesh.geometry, g);
+      }
+      record.geometry = g;
+      record.material = Array.isArray(mesh.material) ? mesh.material.map(materialOf) : materialOf(mesh.material);
+      if (mesh.morphTargetInfluences) record.morphTargetInfluences = [...mesh.morphTargetInfluences];
+      if (mesh.morphTargetDictionary) record.morphTargetDictionary = { ...mesh.morphTargetDictionary };
+      if (skin.isSkinnedMesh) {
+        record.bindMode = skin.bindMode;
+        record.bindMatrix = [...skin.bindMatrix.elements];
+        record.bindMatrixInverse = [...skin.bindMatrixInverse.elements];
+        skinned.push([skin, record]);
+      }
+    }
+  });
+  const skeletonRecords = [];
+  for (const [mesh, record] of skinned) {
+    const skeleton = mesh.skeleton;
+    if (!skeleton) continue;
+    let s = skeletons.get(skeleton);
+    if (s === void 0) {
+      const bones = skeleton.bones.map((bone) => {
+        if (!bone) return -1;
+        const i = nodeIndex.get(bone);
+        if (i === void 0) {
+          throw new Error(
+            `three-vat: bone "${bone.name || "(unnamed)"}" of mesh "${mesh.name || "(unnamed)"}" is outside the subtree being baked; bake from an ancestor of the whole rig`
+          );
+        }
+        return i;
+      });
+      s = skeletonRecords.push({ bones, boneInverses: skeleton.boneInverses.map((m) => [...m.elements]) }) - 1;
+      skeletons.set(skeleton, s);
+    }
+    record.skeleton = s;
+  }
+  const clips = [];
+  const clipRecords = [];
+  const clipOf = (clip) => {
+    const i = clips.indexOf(clip);
+    if (i !== -1) return i;
+    clipRecords.push({
+      name: clip.name,
+      duration: clip.duration,
+      blendMode: clip.blendMode,
+      tracks: clip.tracks.filter((t) => bakeReadsTrack(t, root, baked)).map((t) => recordTrack(t, clip, transfer))
+    });
+    return clips.push(clip) - 1;
+  };
+  const inputs = animations.map(
+    (input) => isAction2(input) ? {
+      clip: clipOf(input.getClip()),
+      action: {
+        weight: input.weight,
+        blendMode: input.blendMode,
+        timeScale: input.timeScale,
+        loop: input.loop,
+        repetitions: input.repetitions,
+        clampWhenFinished: input.clampWhenFinished
+      }
+    } : { clip: clipOf(input) }
+  );
+  return {
+    scene: {
+      parentWorld: root.parent ? [...root.parent.matrixWorld.elements] : null,
+      nodes,
+      geometries: geometryRecords,
+      interleaved: interleavedRecords,
+      skeletons: skeletonRecords,
+      clips: clipRecords,
+      inputs,
+      materialCount: materials.length,
+      flat: mergeFlat ? materials.map(flatFacts) : null
+    },
+    materials,
+    transfer: [...transfer]
+  };
+}
+function rebuildScene(scene) {
+  const stand = /* @__PURE__ */ new Map();
+  const standIns = Array.from({ length: scene.materialCount }, (_, i) => {
+    const m = new Material();
+    stand.set(m, i);
+    return m;
+  });
+  const hooks = {
+    facts: (m) => scene.flat?.[stand.get(m)] ?? null,
+    merge: (members) => {
+      const merged = new Material();
+      stand.set(merged, members.map((m) => stand.get(m)));
+      return merged;
+    }
+  };
+  const interleaved = scene.interleaved.map(({ array, stride }) => new InterleavedBuffer(array, stride));
+  const geometries = scene.geometries.map((g) => rebuildGeometry(g, interleaved));
+  const nodes = scene.nodes.map((n) => {
+    const material = n.material === void 0 ? void 0 : Array.isArray(n.material) ? n.material.map((i) => standIns[i]) : standIns[n.material];
+    const geometry = n.geometry === void 0 ? void 0 : geometries[n.geometry];
+    const o = n.kind === "skinned" ? new SkinnedMesh(geometry, material) : n.kind === "mesh" ? new Mesh(geometry, material) : n.kind === "bone" ? new Bone() : new Object3D();
+    o.name = n.name;
+    o.uuid = n.uuid;
+    o.rotation.order = n.rotationOrder;
+    o.position.fromArray(n.position);
+    o.quaternion.fromArray(n.quaternion);
+    o.scale.fromArray(n.scale);
+    if (n.pivot) o.pivot = new Vector3().fromArray(n.pivot);
+    o.matrixAutoUpdate = n.matrixAutoUpdate;
+    o.matrixWorldAutoUpdate = n.matrixWorldAutoUpdate;
+    o.matrix.fromArray(n.matrix);
+    o.matrixWorld.fromArray(n.matrixWorld);
+    const mesh = o;
+    if (n.morphTargetInfluences) mesh.morphTargetInfluences = [...n.morphTargetInfluences];
+    if (n.morphTargetDictionary) mesh.morphTargetDictionary = { ...n.morphTargetDictionary };
+    return o;
+  });
+  scene.nodes.forEach((n, i) => {
+    if (n.parent !== -1) nodes[n.parent].add(nodes[i]);
+  });
+  const skeletons = scene.skeletons.map(
+    (s) => new Skeleton(
+      s.bones.map((b) => b === -1 ? void 0 : nodes[b]),
+      s.boneInverses.map((m) => new Matrix4().fromArray(m))
+    )
+  );
+  scene.nodes.forEach((n, i) => {
+    if (n.kind !== "skinned" || n.skeleton === void 0) return;
+    const mesh = nodes[i];
+    mesh.bindMode = n.bindMode;
+    mesh.bind(skeletons[n.skeleton], new Matrix4().fromArray(n.bindMatrix));
+    mesh.bindMatrixInverse.fromArray(n.bindMatrixInverse);
+  });
+  const root = nodes[0];
+  if (scene.parentWorld) {
+    const parent = new Object3D();
+    parent.matrixWorld.fromArray(scene.parentWorld);
+    parent.add(root);
+  }
+  const clips = scene.clips.map((c) => {
+    return new AnimationClip(c.name, c.duration, c.tracks.map(rebuildTrack), c.blendMode);
+  });
+  const animations = scene.inputs.map(({ clip, action }) => {
+    if (!action) return clips[clip];
+    const a = new AnimationMixer(root).clipAction(clips[clip], void 0, action.blendMode);
+    a.weight = action.weight;
+    a.timeScale = action.timeScale;
+    a.loop = action.loop;
+    a.repetitions = action.repetitions;
+    a.clampWhenFinished = action.clampWhenFinished;
+    return a;
+  });
+  return { root, animations, stand, hooks };
+}
+function recordVAT(vat, stand) {
+  const transfer = /* @__PURE__ */ new Set();
+  const texture = vat.encoding === "delta" ? vat.positionTexture : vat.rigTexture;
+  const normals = vat.encoding === "delta" && vat.normalTexture ? vat.normalTexture.image.data : null;
+  const record = {
+    encoding: vat.encoding,
+    texels: transferable(texture.image.data, true, transfer),
+    width: texture.image.width,
+    height: texture.image.height,
+    normals: normals ? transferable(normals, true, transfer) : null,
+    slotCount: vat.encoding === "rig" ? vat.slotCount : 0,
+    fallback: vat.encoding === "delta" ? vat.fallback : null,
+    rowsPerFrame: vat.encoding === "delta" ? vat.rowsPerFrame : 1,
+    geometry: recordGeometry(vat.geometry, true, transfer, /* @__PURE__ */ new Map(), []),
+    materials: vat.materials.map((m) => stand.get(m)),
+    clips: vat.clips,
+    bounds: { min: vat.bounds.min.toArray(), max: vat.bounds.max.toArray() },
+    vertexCount: vat.vertexCount,
+    totalFrames: vat.totalFrames
+  };
+  return { vat: record, transfer: [...transfer] };
+}
+function rebuildVAT(record, materials) {
+  const geometry = rebuildGeometry(record.geometry, []);
+  const bounds = new Box3(new Vector3().fromArray(record.bounds.min), new Vector3().fromArray(record.bounds.max));
+  geometry.boundingBox = bounds.clone();
+  geometry.boundingSphere = bounds.getBoundingSphere(new Sphere());
+  const base = {
+    geometry,
+    materials: record.materials.map(
+      (i) => typeof i === "number" ? materials[i] : mergedFlatMaterial(i.map((j) => materials[j]))
+    ),
+    clips: record.clips,
+    bounds,
+    vertexCount: record.vertexCount,
+    totalFrames: record.totalFrames
+  };
+  if (record.encoding === "rig") {
+    const vat2 = {
+      encoding: "rig",
+      rigTexture: makeVATTexture(record.texels, record.width, record.height, FloatType),
+      slotCount: record.slotCount,
+      ...base
+    };
+    return vat2;
+  }
+  const vat = {
+    positionTexture: makeVATTexture(record.texels, record.width, record.height, HalfFloatType),
+    normalTexture: record.normals ? makeVATNormalTexture(record.normals, record.width, record.height) : null,
+    encoding: "delta",
+    fallback: record.fallback,
+    rowsPerFrame: record.rowsPerFrame,
+    ...base
+  };
+  return vat;
+}
+var nextId = 0;
+function bakeVATInWorker(worker, root, animations, options = {}) {
+  return new Promise((resolve, reject) => {
+    root.updateMatrixWorld(true);
+    const { scene, materials, transfer } = recordScene(root, animations, !!options.mergeFlatMaterials);
+    const id = nextId++;
+    const done = () => {
+      worker.removeEventListener("message", onMessage);
+      worker.removeEventListener("error", onError);
+    };
+    const onMessage = (event) => {
+      const data = event.data;
+      if (data?.type !== RESPONSE || data.id !== id) return;
+      done();
+      if ("error" in data) reject(new Error(data.error));
+      else resolve(rebuildVAT(data.vat, materials));
+    };
+    const onError = (event) => {
+      done();
+      const message = event.message;
+      reject(
+        new Error(
+          `three-vat: the bake worker failed${message ? ` (${message})` : ""}; its module must import and call serveVATBakes()`
+        )
+      );
+    };
+    worker.addEventListener("message", onMessage);
+    worker.addEventListener("error", onError);
+    const request = { type: REQUEST, id, scene, options };
+    try {
+      worker.postMessage(request, transfer);
+    } catch (error) {
+      done();
+      reject(error);
+    }
+  });
+}
+function serveVATBakes(scope = globalThis) {
+  const onMessage = (event) => {
+    const data = event.data;
+    if (data?.type !== REQUEST) return;
+    let response;
+    let transfer = [];
+    try {
+      const { root, animations, stand, hooks } = rebuildScene(data.scene);
+      const recorded = recordVAT(bakeVATWith(root, animations, data.options, hooks), stand);
+      response = { type: RESPONSE, id: data.id, vat: recorded.vat };
+      transfer = recorded.transfer;
+    } catch (error) {
+      response = { type: RESPONSE, id: data.id, error: error instanceof Error ? error.message : String(error) };
+    }
+    scope.postMessage(response, transfer);
+  };
+  scope.addEventListener("message", onMessage);
+  return () => scope.removeEventListener("message", onMessage);
+}
 
-export { bakeVAT };
+export { bakeVAT, bakeVATInWorker, decodeOctahedral, encodeOctahedral, serveVATBakes };