three-vat 2.0.0 → 3.0.0

package/dist/index.js

@@ -1,6 +1,6 @@
-import { LoopMode, MAX_TEXTURE_SIZE, makeVATTexture, LIBRARY_PLAYBACK_DEFAULTS, FORWARD_ONLY_REASON, INFINITE_REPETITIONS } from './chunk-2PGZ44TP.js';
-export { EndMode, INFINITE_REPETITIONS, LoopMode, MAX_FADE_DURATION, MAX_TEXTURE_SIZE, createVATPlaybackTexture, endsAt, makeVATTexture, resolveVATFrame, setVATInstance } from './chunk-2PGZ44TP.js';
-import { LoopRepeat, LoopOnce, LoopPingPong, Matrix4, AnimationMixer, Box3, Vector4, Vector3, Sphere, AdditiveAnimationBlendMode, BufferAttribute, BufferGeometry } from 'three';
+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';
 
 var LOOP_MODES = /* @__PURE__ */ new Map([
   [LoopRepeat, LoopMode.Repeat],
@@ -49,6 +49,10 @@ function resolveAnimation(input) {
     }
   };
 }
+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(
@@ -111,17 +115,10 @@ 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 wantTangent = parts.every((p) => {
-    const t = p.mesh.geometry.attributes.tangent;
-    return t instanceof BufferAttribute && t.itemSize === 4;
-  });
-  const uv = wantUV ? new Float32Array(total * 2) : null;
-  const color = wantColor ? new Float32Array(total * 3) : null;
-  const tangent = wantTangent ? new Float32Array(total * 4) : 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();
@@ -160,8 +157,33 @@ function mergeGeometry(parts, restMatrices, total) {
         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 {
@@ -177,35 +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));
-  if (tangent) merged.setAttribute("tangent", new BufferAttribute(tangent, 4));
+  }
   merged.setIndex(indices);
   for (const g of groups) merged.addGroup(g.start, g.count, g.materialIndex);
-  return merged;
 }
-function bakeVAT(root, animations, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE, bakeNormals = true } = {}) {
+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)
@@ -251,7 +272,7 @@ function bakeVAT(root, animations, { fps = 30, maxTextureSize = MAX_TEXTURE_SIZE
         const influences = part.mesh.morphTargetInfluences;
         const { morphPos, morphNrm, morphRelative, isSkinned, skinIndex, skinWeight } = part;
         const boneMatrices = part.pose?.matrices;
-        const morphCount = influences ? Math.min(influences.length, Math.max(morphPos?.length ?? 0, morphNrm?.length ?? 0)) : 0;
+        const morphCount = morphCountOf(part);
         for (let v = 0; v < part.vertexCount; v++) {
           const vi = part.vertexStart + v;
           _p.fromBufferAttribute(part.basePos, v);
@@ -389,9 +410,13 @@ function influencedBones(part) {
 var SCALE_UNIFORMITY_EPSILON = 1e-4;
 function hasNonUniformScale(matrices, b) {
   const o = b * BONE_STRIDE;
-  const x = matrices[o] ** 2 + matrices[o + 1] ** 2 + matrices[o + 2] ** 2;
-  const y = matrices[o + 4] ** 2 + matrices[o + 5] ** 2 + matrices[o + 6] ** 2;
-  const z = matrices[o + 8] ** 2 + matrices[o + 9] ** 2 + matrices[o + 10] ** 2;
+  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;
 }
@@ -407,5 +432,444 @@ function warnOnNonUniformBoneScale(influencers) {
   }
   return false;
 }
+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 { bakeVAT };