three-vat 1.0.1 → 2.1.0

package/dist/index.js

@@ -1,7 +1,58 @@
-export { addVATInstanceAttributes } from './chunk-SXTVASKG.js';
-import { FloatType, Matrix4, AnimationMixer, Box3, Vector4, Vector3, Sphere, DataTexture, RGBAFormat, NearestFilter, BufferGeometry, BufferAttribute } from 'three';
+import { LoopMode, MAX_TEXTURE_SIZE, makeVATTexture, RIG_TEXELS_PER_SLOT, RIG_TEXELS, LIBRARY_PLAYBACK_DEFAULTS, FORWARD_ONLY_REASON, INFINITE_REPETITIONS } from './chunk-3PWAY6MD.js';
+export { EndMode, INFINITE_REPETITIONS, LoopMode, MAX_FADE_DURATION, MAX_TEXTURE_SIZE, createVATPlaybackTexture, endsAt, makeVATTexture, resolveVATFrame, setVATInstance } from './chunk-3PWAY6MD.js';
+import { LoopRepeat, LoopOnce, LoopPingPong, Matrix4, AnimationMixer, Box3, Vector4, Vector3, Sphere, Quaternion, BufferGeometry, BufferAttribute, AdditiveAnimationBlendMode, PropertyBinding } from 'three';
 
-var MAX_TEXTURE_SIZE = 16384;
+var LOOP_MODES = /* @__PURE__ */ new Map([
+  [LoopRepeat, LoopMode.Repeat],
+  [LoopOnce, LoopMode.Once],
+  [LoopPingPong, LoopMode.PingPong]
+]);
+function isAction(input) {
+  return typeof input.getClip === "function";
+}
+function resolveAnimation(input) {
+  if (!isAction(input)) return { clip: input, defaults: { ...LIBRARY_PLAYBACK_DEFAULTS } };
+  const clip = input.getClip();
+  const name = clip.name || "(unnamed)";
+  const cannotBlend = (field, value) => new Error(
+    `three-vat: action for clip "${name}" has ${field} ${value}; that blends several actions at once, which a single baked band cannot represent \u2014 bake the clips separately and crossfade between them (three-vat#30), or reset the action before baking`
+  );
+  if (input.weight !== 1) throw cannotBlend("weight", String(input.weight));
+  if (input.blendMode === AdditiveAnimationBlendMode) throw cannotBlend("blendMode", "additive");
+  if (input.timeScale < 0) {
+    throw new Error(
+      `three-vat: action for clip "${name}" has timeScale ${input.timeScale}; ${FORWARD_ONLY_REASON}.`
+    );
+  }
+  const loopMode = LOOP_MODES.get(input.loop);
+  if (loopMode === void 0) {
+    throw new Error(
+      `three-vat: action for clip "${name}" has an unrecognised loop mode ${input.loop}; expected THREE.LoopRepeat, LoopOnce or LoopPingPong`
+    );
+  }
+  return {
+    clip,
+    defaults: {
+      loopMode,
+      // three's `repetitions` defaults to Infinity and `LoopOnce` ignores it
+      // outright — so a one-shot is one play whatever the field says, and an
+      // endless count becomes the sentinel a Float32Array can carry.
+      repetitions: loopMode === LoopMode.Once ? 1 : Number.isFinite(input.repetitions) ? input.repetitions : INFINITE_REPETITIONS,
+      // Not read off the action (see the rule above), so a bake clamps whichever
+      // input it was handed. Uniform across loop modes on purpose: an instance
+      // may override a repeating clip's `loopMode` to `Once` and inherit this
+      // field, so there is no mode whose end mode is safely unreachable and
+      // could hold a different answer. Rewind is per instance:
+      // `{ ..., endMode: EndMode.Rewind }` (#43, ADR-0017).
+      endMode: LIBRARY_PLAYBACK_DEFAULTS.endMode,
+      speed: input.timeScale
+    }
+  };
+}
+function morphCountOf({ mesh, morphPos, morphNrm }) {
+  const influences = mesh.morphTargetInfluences;
+  return influences ? Math.min(influences.length, Math.max(morphPos?.length ?? 0, morphNrm?.length ?? 0)) : 0;
+}
 function asAttribute(value, mesh, name) {
   if (!(value instanceof BufferAttribute)) {
     throw new Error(
@@ -44,6 +95,8 @@ function collectParts(root) {
       baseNrm: asAttribute(geometry.attributes.normal, mesh, "normal"),
       isSkinned: !!geometry.attributes.skinWeight && !!skinned.skeleton,
       skeleton: skinned.skeleton,
+      pose: void 0,
+      // assigned below, once the distinct rigs are known
       skinIndex: geometry.attributes.skinIndex,
       skinWeight: geometry.attributes.skinWeight,
       morphPos: geometry.morphAttributes.position,
@@ -62,20 +115,20 @@ function collectParts(root) {
 function mergeGeometry(parts, restMatrices, total) {
   const position = new Float32Array(total * 3);
   const normal = new Float32Array(total * 3);
-  const wantUV = parts.every((p) => !!p.mesh.geometry.attributes.uv);
-  const wantColor = parts.every((p) => !!p.mesh.geometry.attributes.color);
-  const uv = wantUV ? new Float32Array(total * 2) : null;
-  const color = wantColor ? new Float32Array(total * 3) : null;
-  const indices = [];
-  const groups = [];
+  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;
   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 srcTangent = tangent ? geometry.attributes.tangent : null;
     for (let v = 0; v < part.vertexCount; v++) {
       _v.fromBufferAttribute(part.basePos, v).applyMatrix4(m);
       _n.fromBufferAttribute(part.baseNrm, v).transformDirection(m);
@@ -95,9 +148,42 @@ function mergeGeometry(parts, restMatrices, total) {
         color[o3 + 1] = srcColor.getY(v);
         color[o3 + 2] = srcColor.getZ(v);
       }
+      if (tangent && srcTangent) {
+        _t.fromBufferAttribute(srcTangent, v).transformDirection(m);
+        const o4 = (start + v) * 4;
+        tangent[o4] = _t.x;
+        tangent[o4 + 1] = _t.y;
+        tangent[o4 + 2] = _t.z;
+        tangent[o4 + 3] = srcTangent.getW(v);
+      }
     }
+  });
+  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) {
+  return {
+    uv: parts.every((p) => !!p.mesh.geometry.attributes.uv),
+    color: 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;
+    })
+  };
+}
+function indexParts(merged, parts) {
+  const indices = [];
+  const groups = [];
+  for (const part of parts) {
+    const start = part.vertexStart;
     const groupStart = indices.length;
-    const index = geometry.index;
+    const index = part.mesh.geometry.index;
     if (index) {
       for (let i = 0; i < index.count; i++) indices.push(start + index.getX(i));
     } else {
@@ -113,32 +199,34 @@ function mergeGeometry(parts, restMatrices, total) {
         materialIndex: part.materialIndex
       });
     }
-  });
-  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));
+  }
   merged.setIndex(indices);
   for (const g of groups) merged.addGroup(g.start, g.count, g.materialIndex);
-  return merged;
 }
-function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } = {}) {
+function frameCountsFor(clips, fps, maxTextureSize) {
+  const frameCounts = clips.map((c) => Math.max(2, Math.round(c.duration * fps)));
+  const totalFrames = frameCounts.reduce((a, b) => a + b, 0);
+  if (totalFrames > maxTextureSize) {
+    throw new Error(
+      `three-vat: totalFrames ${totalFrames} exceeds maxTextureSize ${maxTextureSize}; lower fps or bake fewer clips`
+    );
+  }
+  return { frameCounts, totalFrames };
+}
+function bakeVAT(root, animations, options = {}) {
+  const { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE, bakeNormals = true, encoding = "delta" } = options;
+  const resolved = animations.map(resolveAnimation);
+  const clips = resolved.map((a) => a.clip);
   root.updateMatrixWorld(true);
   const parts = collectParts(root);
+  if (encoding === "rig") return bakeRig(root, parts, resolved, { fps, maxTextureSize });
   const vertexCount = parts.reduce((n, p) => n + p.vertexCount, 0);
   if (vertexCount > maxTextureSize) {
     throw new Error(
       `three-vat: vertexCount ${vertexCount} exceeds maxTextureSize ${maxTextureSize}; row wrapping is not implemented`
     );
   }
-  const frameCounts = clips.map((c) => Math.max(2, Math.round(c.duration * fps)));
-  const totalFrames = frameCounts.reduce((a, b) => a + b, 0);
-  if (totalFrames > maxTextureSize) {
-    throw new Error(
-      `three-vat: totalFrames ${totalFrames} exceeds maxTextureSize ${maxTextureSize}; lower fps or bake fewer clips`
-    );
-  }
+  const { frameCounts, totalFrames } = frameCountsFor(clips, fps, maxTextureSize);
   const rootInverse = root.matrixWorld.clone().invert();
   const restMatrices = parts.map(
     (p) => new Matrix4().multiplyMatrices(rootInverse, p.mesh.matrixWorld)
@@ -146,13 +234,13 @@ function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } =
   const geometry = mergeGeometry(parts, restMatrices, vertexCount);
   const mergedBase = geometry.attributes.position;
   const posData = new Float32Array(vertexCount * totalFrames * 4);
-  const nrmData = new Float32Array(vertexCount * totalFrames * 4);
+  const nrmData = bakeNormals ? new Float32Array(vertexCount * totalFrames * 4) : 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 _bone = new Matrix4();
   const _acc = new Matrix4();
   const _skin = new Matrix4();
   const _partMatrix = new Matrix4();
@@ -162,7 +250,8 @@ function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } =
   const _mt = new Vector3();
   const _mb = new Vector3();
   const _mbn = new Vector3();
-  const influencers = parts.filter((p) => p.isSkinned && p.skeleton).map(influencedBones);
+  const poses = attachPoseBuffers(parts);
+  const influencers = bakeNormals ? parts.filter((p) => p.pose).map(influencedBones) : [];
   let warnedNonUniformScale = false;
   let rowOffset = 0;
   clips.forEach((clip, ci) => {
@@ -174,22 +263,24 @@ function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } =
       mixer.setTime(f / frames * clip.duration);
       root.updateMatrixWorld(true);
       const row = rowOffset + f;
+      poseSkeletons(poses);
       if (!warnedNonUniformScale) {
-        warnedNonUniformScale = warnOnNonUniformBoneScale(influencers, _bone);
+        warnedNonUniformScale = warnOnNonUniformBoneScale(influencers);
       }
       for (const part of parts) {
         _partMatrix.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
         const influences = part.mesh.morphTargetInfluences;
-        const { morphPos, morphNrm, morphRelative, isSkinned, skeleton, skinIndex, skinWeight } = part;
-        const morphCount = influences ? Math.min(influences.length, Math.max(morphPos?.length ?? 0, morphNrm?.length ?? 0)) : 0;
+        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);
-          _n.fromBufferAttribute(part.baseNrm, v);
+          if (bakeNormal) _n.fromBufferAttribute(part.baseNrm, v);
           if (influences && morphCount > 0) {
             if (!morphRelative) {
               _mb.fromBufferAttribute(part.basePos, v);
-              _mbn.fromBufferAttribute(part.baseNrm, v);
+              if (bakeNormal) _mbn.fromBufferAttribute(part.baseNrm, v);
             }
             for (let t = 0; t < morphCount; t++) {
               const w = influences[t];
@@ -200,7 +291,7 @@ function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } =
                 if (!morphRelative) _mt.sub(_mb);
                 _p.addScaledVector(_mt, w);
               }
-              const targetNrm = morphNrm?.[t];
+              const targetNrm = bakeNormal ? morphNrm?.[t] : void 0;
               if (targetNrm) {
                 _mt.fromBufferAttribute(targetNrm, v);
                 if (!morphRelative) _mt.sub(_mbn);
@@ -208,26 +299,24 @@ function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } =
               }
             }
           }
-          if (isSkinned && skeleton) {
+          if (isSkinned && boneMatrices) {
             const skinned = part.mesh;
             _si.fromBufferAttribute(skinIndex, v);
             _sw.fromBufferAttribute(skinWeight, v);
-            _acc.elements.fill(0);
+            const ae = _acc.elements;
+            ae.fill(0);
             for (let i = 0; i < 4; i++) {
               const w = _sw.getComponent(i);
               if (w === 0) continue;
-              const bi = _si.getComponent(i);
-              _bone.multiplyMatrices(skeleton.bones[bi].matrixWorld, skeleton.boneInverses[bi]);
-              const ae = _acc.elements;
-              const be = _bone.elements;
-              for (let e = 0; e < 16; e++) ae[e] += be[e] * w;
+              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);
-            _n.transformDirection(_skin);
+            if (bakeNormal) _n.transformDirection(_skin);
           }
           _p.applyMatrix4(_partMatrix);
-          _n.transformDirection(_partMatrix);
+          if (bakeNormal) _n.transformDirection(_partMatrix);
           bounds.expandByPoint(_p);
           _bp.fromBufferAttribute(mergedBase, vi);
           const o = (row * vertexCount + vi) * 4;
@@ -239,10 +328,12 @@ function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } =
           posData[o + 1] = dy;
           posData[o + 2] = dz;
           posData[o + 3] = 1;
-          nrmData[o] = _n.x;
-          nrmData[o + 1] = _n.y;
-          nrmData[o + 2] = _n.z;
-          nrmData[o + 3] = 1;
+          if (bakeNormal) {
+            nrmData[o] = _n.x;
+            nrmData[o + 1] = _n.y;
+            nrmData[o + 2] = _n.z;
+            nrmData[o + 3] = 1;
+          }
         }
       }
     }
@@ -253,7 +344,10 @@ function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } =
       frames,
       fps: frames / clip.duration,
       duration: clip.duration,
-      maxDelta: Math.sqrt(maxDeltaSq)
+      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;
   });
@@ -266,7 +360,7 @@ function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } =
   for (const part of parts) materials[part.materialIndex] = part.material;
   return {
     positionTexture: makeVATTexture(posData, vertexCount, totalFrames),
-    normalTexture: makeVATTexture(nrmData, vertexCount, totalFrames),
+    normalTexture: nrmData ? makeVATTexture(nrmData, vertexCount, totalFrames) : null,
     clips: clipTable,
     bounds,
     vertexCount,
@@ -276,6 +370,32 @@ function bakeVAT(root, clips, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE } =
     materials
   };
 }
+var BONE_STRIDE = 16;
+var IDENTITY = /* @__PURE__ */ new Matrix4();
+function attachPoseBuffers(parts) {
+  const byRig = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    if (!part.isSkinned || !part.skeleton) continue;
+    let pose = byRig.get(part.skeleton);
+    if (!pose) {
+      const matrices = new Float64Array(part.skeleton.bones.length * BONE_STRIDE);
+      pose = { skeleton: part.skeleton, matrices };
+      byRig.set(part.skeleton, pose);
+    }
+    part.pose = pose;
+  }
+  return [...byRig.values()];
+}
+function poseSkeletons(poses) {
+  const scratch = new Matrix4();
+  for (const { skeleton, matrices } of poses) {
+    const { bones, boneInverses } = skeleton;
+    for (let b = 0; b < bones.length; b++) {
+      scratch.multiplyMatrices(bones[b]?.matrixWorld ?? IDENTITY, boneInverses[b]);
+      matrices.set(scratch.elements, b * BONE_STRIDE);
+    }
+  }
+}
 function influencedBones(part) {
   const used = /* @__PURE__ */ new Set();
   const index = part.skinIndex;
@@ -285,37 +405,471 @@ function influencedBones(part) {
       if (weight.getComponent(v, i) !== 0) used.add(index.getComponent(v, i));
     }
   }
-  return { skeleton: part.skeleton, bones: [...used] };
+  return { pose: part.pose, bones: [...used] };
 }
 var SCALE_UNIFORMITY_EPSILON = 1e-4;
-function hasNonUniformScale(m) {
-  const e = m.elements;
-  const x = e[0] * e[0] + e[1] * e[1] + e[2] * e[2];
-  const y = e[4] * e[4] + e[5] * e[5] + e[6] * e[6];
-  const z = e[8] * e[8] + e[9] * e[9] + e[10] * e[10];
+function hasNonUniformScale(matrices, b) {
+  const o = b * BONE_STRIDE;
+  return unevenSquares(
+    matrices[o] ** 2 + matrices[o + 1] ** 2 + matrices[o + 2] ** 2,
+    matrices[o + 4] ** 2 + matrices[o + 5] ** 2 + matrices[o + 6] ** 2,
+    matrices[o + 8] ** 2 + matrices[o + 9] ** 2 + matrices[o + 10] ** 2
+  );
+}
+function unevenSquares(x, y, z) {
   const max = Math.max(x, y, z);
   return max - Math.min(x, y, z) > SCALE_UNIFORMITY_EPSILON * max;
 }
-function warnOnNonUniformBoneScale(influencers, scratch) {
-  for (const { skeleton, bones } of influencers) {
+function warnOnNonUniformBoneScale(influencers) {
+  for (const { pose, bones } of influencers) {
     for (const b of bones) {
-      scratch.multiplyMatrices(skeleton.bones[b].matrixWorld, skeleton.boneInverses[b]);
-      if (!hasNonUniformScale(scratch)) continue;
+      if (!hasNonUniformScale(pose.matrices, b)) continue;
       console.warn(
-        `three-vat: bone "${skeleton.bones[b].name || "(unnamed)"}" animates with non-uniform scale; baked normals under it are approximate, because linear-blend skinning transforms a normal by the skin matrix rather than its inverse-transpose \u2014 the same shortcut three's own skinning shader takes. Positions are exact.`
+        `three-vat: bone "${pose.skeleton.bones[b].name || "(unnamed)"}" animates with non-uniform scale; baked normals under it are approximate, because linear-blend skinning transforms a normal by the skin matrix rather than its inverse-transpose \u2014 the same shortcut three's own skinning shader takes. Positions are exact.`
       );
       return true;
     }
   }
   return false;
 }
-function makeVATTexture(data, width, height, type = FloatType) {
-  const tex = new DataTexture(data, width, height, RGBAFormat, type);
-  tex.minFilter = NearestFilter;
-  tex.magFilter = NearestFilter;
-  tex.generateMipmaps = false;
-  tex.needsUpdate = true;
-  return tex;
+var USE_VERTEX_ENCODING = "bake this subtree with the vertex encoding (the default) instead";
+function placementOf(part, rootInverse, out) {
+  out.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
+  if (part.pose) out.multiply(part.mesh.bindMatrixInverse);
+  return out;
+}
+var MATRIX_EPSILON = 1e-6;
+function matricesClose(a, b) {
+  const ae = a.elements;
+  const be = b.elements;
+  for (let e = 0; e < 16; e++) if (Math.abs(ae[e] - be[e]) > MATRIX_EPSILON) return false;
+  return true;
+}
+function slotLabel(slot) {
+  const parts = slot.parts.map(partName).join(", ");
+  if (!slot.rig) return `rigid part ${parts}`;
+  const { pose, bone } = slot.rig;
+  return `bone "${pose.skeleton.bones[bone]?.name || `bone ${bone}`}" of ${parts}`;
+}
+function partName(part) {
+  return `"${part.mesh.name || "(unnamed)"}"`;
+}
+function slotReads(slot, bone, boneInverse, bindMatrix, placement) {
+  const { rig } = slot;
+  return rig !== void 0 && rig.pose.skeleton.bones[rig.bone] === bone && matricesClose(rig.pose.skeleton.boneInverses[rig.bone], boneInverse) && matricesClose(rig.bindMatrix, bindMatrix) && matricesClose(slot.restPlacement, placement);
+}
+function layoutSlots(parts, rootInverse) {
+  const slots = [];
+  const slotMaps = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    const restPlacement = placementOf(part, rootInverse, new Matrix4());
+    if (part.pose) {
+      const { pose } = part;
+      const { bones, boneInverses } = pose.skeleton;
+      const bindMatrix = part.mesh.bindMatrix.clone();
+      const map = [];
+      for (let b = 0; b < bones.length; b++) {
+        const bone = bones[b];
+        const shared = bone ? slots.findIndex((s) => slotReads(s, bone, boneInverses[b], bindMatrix, restPlacement)) : -1;
+        if (shared >= 0) {
+          const slot = slots[shared];
+          if (!slot.parts.includes(part)) slot.parts.push(part);
+          map.push(shared);
+        } else {
+          map.push(slots.length);
+          slots.push({ rig: { pose, bone: b, bindMatrix }, parts: [part], restPlacement });
+        }
+      }
+      slotMaps.set(part, map);
+    } else {
+      slotMaps.set(part, [slots.length]);
+      slots.push({ rig: void 0, parts: [part], restPlacement });
+    }
+  }
+  return { slots, slotMaps };
+}
+function morphTracksOn(mesh, clip, root) {
+  const driven = /* @__PURE__ */ new Map();
+  for (const track of clip.tracks) {
+    const parsed = PropertyBinding.parseTrackName(track.name);
+    if (parsed.propertyName !== "morphTargetInfluences") continue;
+    if (PropertyBinding.findNode(root, parsed.nodeName) !== mesh) continue;
+    const size = track.getValueSize();
+    const keys = track.times.length;
+    const values = track.values;
+    const add = (t, read) => {
+      const list = driven.get(t) ?? [];
+      for (let k = 0; k < keys; k++) list.push(read(k));
+      driven.set(t, list);
+    };
+    if (parsed.propertyIndex === void 0) {
+      for (let t = 0; t < size; t++) add(t, (k) => values[k * size + t]);
+    } else {
+      const byIndex = Number(parsed.propertyIndex);
+      const t = Number.isInteger(byIndex) ? byIndex : mesh.morphTargetDictionary?.[parsed.propertyIndex];
+      if (t !== void 0) add(t, (k) => values[k]);
+    }
+  }
+  return driven;
+}
+function morphInfluences(part, clips, root) {
+  const { mesh } = part;
+  const influences = mesh.morphTargetInfluences;
+  const count = morphCountOf(part);
+  if (!influences || count === 0) return { statics: [], animated: [] };
+  const driven = clips.map((clip) => morphTracksOn(mesh, clip, root));
+  const statics = [];
+  const animated = [];
+  for (let t = 0; t < count; t++) {
+    const seen = /* @__PURE__ */ new Set();
+    const offending = [];
+    driven.forEach((tracks, ci) => {
+      const values = tracks.get(t);
+      if (!values) {
+        seen.add(influences[t]);
+        return;
+      }
+      offending.push(`"${clips[ci].name}"`);
+      for (const value of values) seen.add(value);
+    });
+    if (seen.size > 1) {
+      const name = Object.entries(mesh.morphTargetDictionary ?? {}).find(([, i]) => i === t)?.[0];
+      animated.push({ part, target: name ? `"${name}"` : String(t), clips: offending });
+    }
+    statics.push(seen.values().next().value);
+  }
+  return { statics, animated };
+}
+function refuseAnimatedMorphs(animated) {
+  const byDriver = /* @__PURE__ */ new Map();
+  for (const { part, target, clips } of animated) {
+    const key = `${target}
+${clips.join("\n")}`;
+    const entry = byDriver.get(key) ?? { target, clips, parts: [] };
+    if (!entry.parts.includes(part)) entry.parts.push(part);
+    byDriver.set(key, entry);
+  }
+  const offences = [...byDriver.values()].map(({ target, clips, parts }) => {
+    const one = clips.length === 1;
+    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}`
+  );
+}
+function foldMorphs(part, statics) {
+  const { vertexCount, basePos, baseNrm, morphPos, morphNrm, morphRelative } = 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);
+        }
+      }
+      _n.normalize();
+    }
+    _p.toArray(position, v * 3);
+    _n.toArray(normal, v * 3);
+  }
+  return { position, normal };
+}
+function scaleSensitiveNodes(slots, root, influenced) {
+  const sensitive = /* @__PURE__ */ new Map();
+  slots.forEach((slot, i) => {
+    if (!influenced[i]) return;
+    if (slot.rig) {
+      const { bones } = slot.rig.pose.skeleton;
+      for (let node = bones[slot.rig.bone] ?? null; node && bones.includes(node); node = node.parent) {
+        sensitive.set(node, slot);
+      }
+    } else {
+      for (let node = slot.parts[0].mesh; node && node !== root; node = node.parent) {
+        sensitive.set(node, slot);
+      }
+    }
+  });
+  return sensitive;
+}
+function refuseAnimatedNonUniformScale(slots, clips, root, influenced) {
+  const sensitive = scaleSensitiveNodes(slots, root, influenced);
+  for (const clip of clips) {
+    for (const track of clip.tracks) {
+      const parsed = PropertyBinding.parseTrackName(track.name);
+      if (parsed.propertyName !== "scale" || track.getValueSize() !== 3) continue;
+      const node = PropertyBinding.findNode(root, parsed.nodeName);
+      const reached = node && sensitive.get(node);
+      if (!reached) continue;
+      const values = track.values;
+      for (let k = 0; k < track.times.length; k++) {
+        const o = k * 3;
+        if (unevenSquares(values[o] ** 2, values[o + 1] ** 2, values[o + 2] ** 2)) {
+          throw nonUniformScale(slotLabel(reached), clip);
+        }
+      }
+    }
+  }
+}
+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.`
+  );
+}
+function bakeRig(root, parts, resolved, { fps, maxTextureSize }) {
+  const clips = resolved.map((a) => a.clip);
+  const rootInverse = root.matrixWorld.clone().invert();
+  const poses = attachPoseBuffers(parts);
+  const { slots, slotMaps } = layoutSlots(parts, rootInverse);
+  const slotCount = slots.length;
+  const morphs = parts.map((part) => morphInfluences(part, clips, root));
+  const animated = morphs.flatMap((m) => m.animated);
+  if (animated.length > 0) throw refuseAnimatedMorphs(animated);
+  const rigParts = parts.map((part, i) => ({
+    part,
+    slotOf: slotMaps.get(part),
+    ...foldMorphs(part, morphs[i].statics)
+  }));
+  const width = slotCount * RIG_TEXELS_PER_SLOT;
+  if (width > maxTextureSize) {
+    throw new Error(
+      `three-vat: rig texture width ${width} (${slotCount} slots \xD7 ${RIG_TEXELS_PER_SLOT} texels) exceeds maxTextureSize ${maxTextureSize}`
+    );
+  }
+  const { frameCounts, totalFrames } = frameCountsFor(clips, fps, maxTextureSize);
+  const vertexCount = parts.reduce((n, p) => n + p.vertexCount, 0);
+  const geometry = mergeRigGeometry(rigParts, vertexCount);
+  const localPosition = geometry.attributes.position.array;
+  const skinIndex = geometry.attributes.skinIndex.array;
+  const skinWeight = geometry.attributes.skinWeight.array;
+  const influenced = new Uint8Array(slotCount);
+  for (let i = 0; i < skinWeight.length; i++) {
+    if (skinWeight[i] !== 0) influenced[skinIndex[i]] = 1;
+  }
+  refuseAnimatedNonUniformScale(slots, clips, root, influenced);
+  const _p = new Vector3();
+  const _slot = new Matrix4();
+  const _partMatrix = new Matrix4();
+  const placements = new Map(parts.map((part) => [part, new Matrix4()]));
+  const _q = new Quaternion();
+  const _t = new Vector3();
+  const _s = new Vector3();
+  const restRoot = new Float64Array(vertexCount * 3);
+  for (const part of parts) {
+    _partMatrix.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
+    for (let v = 0; v < part.vertexCount; v++) {
+      _p.fromBufferAttribute(part.basePos, v).applyMatrix4(_partMatrix);
+      _p.toArray(restRoot, (part.vertexStart + v) * 3);
+    }
+  }
+  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();
+    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);
+        }
+        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;
+      }
+    }
+    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);
+  bounds.min.set(minX, minY, minZ);
+  bounds.max.set(maxX, maxY, maxZ);
+  geometry.boundingBox = bounds.clone();
+  geometry.boundingSphere = bounds.getBoundingSphere(new Sphere());
+  const materials = [];
+  for (const part of parts) materials[part.materialIndex] = part.material;
+  return {
+    encoding: "rig",
+    rigTexture: makeVATTexture(data, width, totalFrames),
+    slotCount,
+    clips: clipTable,
+    bounds,
+    vertexCount,
+    totalFrames,
+    geometry,
+    materials
+  };
+}
+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;
+      if (srcIndex && srcWeight) {
+        for (let i = 0; i < 4; i++) {
+          slotIndex[o4 + i] = slotOf[srcIndex.getComponent(v, i)];
+          slotWeight[o4 + i] = srcWeight.getComponent(v, i);
+        }
+      } else {
+        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();
+  merged.setAttribute("position", new BufferAttribute(position, 3));
+  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);
+  return merged;
 }
 
-export { MAX_TEXTURE_SIZE, bakeVAT, makeVATTexture };
+export { bakeVAT };