three-vat 4.1.0 → 4.2.0

package/dist/chunk-P6AFXEBT.js

@@ -0,0 +1,1104 @@
+import { LoopMode, MAX_TEXTURE_SIZE, vertexLayoutFor, makeVATNormalTexture, makeVATTexture, RIG_TEXELS_PER_SLOT, LIBRARY_PLAYBACK_DEFAULTS, INFINITE_REPETITIONS, HALF_FLOAT_MAX, RIG_TEXELS } from './chunk-4IKOXUSX.js';
+import { LoopRepeat, LoopOnce, LoopPingPong, DataUtils, Matrix4, Box3, Vector4, Vector3, Sphere, HalfFloatType, Quaternion, BufferGeometry, BufferAttribute, FloatType, AdditiveAnimationBlendMode, AnimationMixer, PropertyBinding, Color, InterleavedBufferAttribute, InterleavedBuffer } from 'three';
+
+// 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;
+}
+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/bake.ts
+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");
+  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;
+}
+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(
+      `three-vat: mesh ${meshName(mesh)} has an interleaved or unsupported "${name}" attribute; VAT bakes plain BufferAttributes`
+    );
+  }
+  return value;
+}
+function deriveNormals(position, index) {
+  const scratch = new BufferGeometry();
+  scratch.setAttribute("position", position);
+  scratch.setIndex(index);
+  scratch.computeVertexNormals();
+  return scratch.attributes.normal;
+}
+function piecesOf(mesh) {
+  const { geometry } = mesh;
+  if (!Array.isArray(mesh.material)) return [{ geometry, material: mesh.material }];
+  const materials = mesh.material;
+  if (geometry.groups.length === 0) {
+    throw new Error(
+      `three-vat: mesh ${meshName(mesh)} uses a material array but its geometry has no groups; give it one group per material, or a single material`
+    );
+  }
+  const normal = geometry.attributes.normal ?? deriveNormals(asAttribute(geometry.attributes.position, mesh, "position"), geometry.index);
+  return geometry.groups.flatMap((group, g) => {
+    const index = group.materialIndex ?? 0;
+    const material = materials[index];
+    if (!material) {
+      throw new Error(
+        `three-vat: mesh ${meshName(mesh)}: group ${g} draws material ${index}, which its material array of ${materials.length} does not hold`
+      );
+    }
+    const piece = groupGeometry(geometry, normal, group);
+    return piece ? [{ geometry: piece, material }] : [];
+  });
+}
+function groupGeometry(source, normal, group) {
+  const index = source.index;
+  const end = Math.min(group.start + group.count, index ? index.count : source.attributes.position.count);
+  const vertices = [];
+  const local = /* @__PURE__ */ new Map();
+  const remapped = [];
+  for (let i = group.start; i < end; i++) {
+    const v = index ? index.getX(i) : i;
+    let at = local.get(v);
+    if (at === void 0) {
+      at = vertices.push(v) - 1;
+      local.set(v, at);
+    }
+    remapped.push(at);
+  }
+  if (vertices.length === 0) return null;
+  const copy = vertexCopier(vertices);
+  const geometry = new BufferGeometry();
+  for (const [name, attribute] of Object.entries(source.attributes)) {
+    geometry.setAttribute(name, copy(name === "normal" ? normal : attribute));
+  }
+  if (!source.attributes.normal) geometry.setAttribute("normal", copy(normal));
+  for (const [name, targets] of Object.entries(source.morphAttributes)) {
+    geometry.morphAttributes[name] = targets.map(copy);
+  }
+  geometry.morphTargetsRelative = source.morphTargetsRelative;
+  if (index) geometry.setIndex(remapped);
+  return geometry;
+}
+function vertexCopier(vertices) {
+  const buffers = /* @__PURE__ */ new Map();
+  const rows = (array, stride) => {
+    const out = new array.constructor(vertices.length * stride);
+    vertices.forEach((v, i) => out.set(array.subarray(v * stride, (v + 1) * stride), i * stride));
+    return out;
+  };
+  return (attribute) => {
+    const { itemSize, normalized } = attribute;
+    if (attribute instanceof InterleavedBufferAttribute) {
+      const { data } = attribute;
+      let copied = buffers.get(data);
+      if (!copied) buffers.set(data, copied = new InterleavedBuffer(rows(data.array, data.stride), data.stride));
+      return new InterleavedBufferAttribute(copied, itemSize, attribute.offset, normalized);
+    }
+    return new attribute.constructor(rows(attribute.array, itemSize), itemSize, normalized);
+  };
+}
+function collectParts(root, hooks) {
+  const found = [];
+  root.traverse((o) => {
+    const mesh = o;
+    if (mesh.isMesh && mesh.geometry) found.push(mesh);
+  });
+  if (found.length === 0) {
+    throw new Error("three-vat: no Mesh found under root; nothing to bake");
+  }
+  const pieces = found.flatMap((mesh) => piecesOf(mesh).map((piece) => ({ mesh, ...piece })));
+  if (pieces.length === 0) {
+    throw new Error("three-vat: no geometry group under root draws anything; nothing to bake");
+  }
+  const flat = hooks ? planFlatMerge(
+    pieces.map((piece) => piece.material),
+    hooks
+  ) : null;
+  const materials = [];
+  const parts = [];
+  for (const { mesh, geometry, material: source } of pieces) {
+    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,
+      geometry,
+      material,
+      materialIndex,
+      vertexStart: 0,
+      // assigned below, after material sorting
+      vertexCount: geometry.attributes.position.count,
+      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,
+      // assigned below, once the distinct rigs are known
+      skinIndex: geometry.attributes.skinIndex,
+      skinWeight: geometry.attributes.skinWeight,
+      morphPos: geometry.morphAttributes.position,
+      morphNrm: geometry.morphAttributes.normal,
+      morphRelative: geometry.morphTargetsRelative,
+      tint: merged?.tint ?? null
+    });
+  }
+  parts.sort((a, b) => a.materialIndex - b.materialIndex);
+  let offset = 0;
+  for (const part of parts) {
+    part.vertexStart = offset;
+    offset += part.vertexCount;
+  }
+  return parts;
+}
+function mergeGeometry(parts, restMatrices, total) {
+  const position = new Float32Array(total * 3);
+  const normal = new Float32Array(total * 3);
+  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 _t = new Vector3();
+  parts.forEach((part, pi) => {
+    const geometry = part.geometry;
+    const start = part.vertexStart;
+    const srcUV = uv ? asAttribute(geometry.attributes.uv, part.mesh, "uv") : 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++) {
+      const vi = start + v;
+      if (uv && srcUV) {
+        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);
+        if (m) _t.transformDirection(m);
+        const o4 = vi * 4;
+        tangent[o4] = _t.x;
+        tangent[o4 + 1] = _t.y;
+        tangent[o4 + 2] = _t.z;
+        tangent[o4 + 3] = srcTangent.getW(v);
+      }
+    }
+  });
+  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);
+}
+function colorSource(part, merging) {
+  const source = part.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.geometry.attributes.uv),
+    // 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.geometry.attributes.color),
+    tangent: parts.every((p) => {
+      const t = p.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 = part.geometry.index;
+    if (index) {
+      for (let i = 0; i < index.count; i++) indices.push(start + index.getX(i));
+    } else {
+      for (let v = 0; v < part.vertexCount; v++) indices.push(start + v);
+    }
+    const last = groups[groups.length - 1];
+    if (last && last.materialIndex === part.materialIndex) {
+      last.count += indices.length - groupStart;
+    } else {
+      groups.push({
+        start: groupStart,
+        count: indices.length - groupStart,
+        materialIndex: part.materialIndex
+      });
+    }
+  }
+  merged.setIndex(indices);
+  for (const g of groups) merged.addGroup(g.start, g.count, g.materialIndex);
+}
+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 = {}) {
+  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);
+  root.updateMatrixWorld(true);
+  const parts = collectParts(root, mergeFlatMaterials ? hooks : null);
+  if (encoding === "rig") return bakeRig(root, parts, resolved, { fps, 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: 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 Uint16Array(frameStride * totalFrames * 4);
+  const nrmData = bakeNormals ? new Uint8Array(frameStride * totalFrames * 2) : null;
+  const bakeNormal = nrmData !== null;
+  const bounds = new Box3();
+  const _si = new Vector4();
+  const _sw = new Vector4();
+  const _acc = new Matrix4();
+  const _skin = new Matrix4();
+  const _partMatrix = new Matrix4();
+  const _p = new Vector3();
+  const _bp = new Vector3();
+  const _n = new Vector3();
+  const poses = attachPoseBuffers(parts);
+  const influencers = bakeNormals ? parts.filter((p) => p.pose).map(influencedBones) : [];
+  let warnedNonUniformScale = false;
+  const writeFrame = (clip, f, row) => {
+    let maxDeltaSq = 0;
+    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);
+      }
+    }
+    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, 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) {
+  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;
+  const weight = part.skinWeight;
+  for (let v = 0; v < part.vertexCount; v++) {
+    for (let i = 0; i < 4; i++) {
+      if (weight.getComponent(v, i) !== 0) used.add(index.getComponent(v, i));
+    }
+  }
+  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(
+    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 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;
+}
+function warnOnNonUniformBoneScale(influencers) {
+  for (const { pose, bones } of influencers) {
+    for (const b of bones) {
+      if (!hasNonUniformScale(pose.matrices, b)) continue;
+      console.warn(
+        `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;
+}
+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);
+  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 = partNames(slot.parts);
+  if (!slot.rig) return `rigid part ${parts}`;
+  const { pose, bone } = slot.rig;
+  return `bone "${pose.skeleton.bones[bone]?.name || `bone ${bone}`}" of ${parts}`;
+}
+function meshName(mesh) {
+  return `"${mesh.name || "(unnamed)"}"`;
+}
+function partName(part) {
+  return meshName(part.mesh);
+}
+function partNames(parts) {
+  return [...new Set(parts.map((p) => p.mesh))].map(meshName).join(", ");
+}
+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();
+  const rigidSlots = /* @__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 {
+      const shared = rigidSlots.get(part.mesh);
+      if (shared !== void 0) {
+        slots[shared].parts.push(part);
+        slotMaps.set(part, [shared]);
+      } else {
+        rigidSlots.set(part.mesh, slots.length);
+        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 single = new Set(parts.map((p) => p.mesh)).size === 1;
+    const its = single ? "its" : "their";
+    return `clip${one ? "" : "s"} ${clips.join(", ")} animate${one ? "s" : ""} morph target ${target} of part${single ? "" : "s"} ${partNames(parts)}, ${its} vertices moving where no bone does`;
+  });
+  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 } = 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();
+  for (let v = 0; v < vertexCount; v++) {
+    _p.fromBufferAttribute(basePos, v);
+    _n.fromBufferAttribute(baseNrm, v);
+    if (active) {
+      morphVertex(part, v, statics, statics.length, _p, _n);
+      _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 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 }) {
+  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 RigRefusal(
+      `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 restSlots = new Float32Array(slotCount * 16);
+  for (let slot = 0; slot < slotCount; slot++) {
+    _slot.multiplyMatrices(rootInverse, slots[slot].parts[0].mesh.matrixWorld).toArray(restSlots, slot * 16);
+  }
+  const data = new Float32Array(width * totalFrames * 4);
+  const slotMatrices = new Float64Array(slotCount * BONE_STRIDE);
+  const previous = new Float64Array(slotCount * 4);
+  const bounds = new Box3();
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  const writeFrame = (clip, _f, row) => {
+    let maxDeltaSq = 0;
+    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}`
+          );
+        }
+      }
+      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);
+        _q.fromArray(previous, p4);
+        if (_q.lengthSq() === 0) _q.identity();
+        scale = 0;
+      } else {
+        if (det < 0) for (const e of MATRIX_BASIS) _slot.elements[e] = -_slot.elements[e];
+        _slot.decompose(_t, _q, _s);
+        scale = det < 0 ? -_s.x : _s.x;
+      }
+      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] = scale;
+    }
+    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();
+  geometry.boundingSphere = bounds.getBoundingSphere(new Sphere());
+  const materials = [];
+  for (const part of parts) materials[part.materialIndex] = part.material;
+  const vat = {
+    encoding: "rig",
+    rigTexture: makeVATTexture(data, width, totalFrames),
+    slotCount,
+    clips: clipTable,
+    bounds,
+    vertexCount,
+    totalFrames,
+    geometry,
+    materials
+  };
+  REST_SLOTS.set(vat, restSlots);
+  return vat;
+}
+var REST_SLOTS = /* @__PURE__ */ new WeakMap();
+function restSlotsOf(vat) {
+  return REST_SLOTS.get(vat);
+}
+function keepRestSlots(vat, rest) {
+  REST_SLOTS.set(vat, rest);
+}
+function mergeRigGeometry(rigParts, total) {
+  const position = new Float32Array(total * 3);
+  const normal = new Float32Array(total * 3);
+  const slotIndex = new Uint16Array(total * 4);
+  const slotWeight = new Float32Array(total * 4);
+  for (const { part, slotOf, position: restPos, normal: restNrm } of rigParts) {
+    const start = part.vertexStart;
+    const srcIndex = part.pose ? part.skinIndex : null;
+    const srcWeight = part.pose ? part.skinWeight : null;
+    position.set(restPos, start * 3);
+    normal.set(restNrm, start * 3);
+    for (let v = 0; v < part.vertexCount; v++) {
+      const o4 = (start + v) * 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;
+      }
+    }
+  }
+  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));
+  mergeSurface(merged, rigParts.map((r) => r.part), total, null);
+  return merged;
+}
+var BAKED_FILE_EXTENSION = "THREEVAT_vat";
+var BAKED_FILE_VERSION = 1;
+var BAKED_LAYER_FORMATS = {
+  /** The position layer: four half-floats a texel, written as the unsigned shorts that hold their bits. */
+  RGBA16F: {
+    componentType: 5123,
+    bytesPerTexel: 8,
+    build: (texels, width, height) => makeVATTexture(new Uint16Array(texels), width, height, HalfFloatType)
+  },
+  /** The normal layer: an octahedral pair of unsigned bytes a texel. */
+  RG8: {
+    componentType: 5121,
+    bytesPerTexel: 2,
+    build: (texels, width, height) => makeVATNormalTexture(new Uint8Array(texels), width, height)
+  },
+  /** The rig texture: four floats a texel, two texels a slot. */
+  RGBA32F: {
+    componentType: 5126,
+    bytesPerTexel: 16,
+    build: (texels, width, height) => makeVATTexture(new Float32Array(texels), width, height, FloatType)
+  }
+};
+function positionDigest(position) {
+  const values = new Float32Array(position.count * position.itemSize);
+  for (let v = 0; v < position.count; v++) {
+    for (let c = 0; c < position.itemSize; c++) values[v * position.itemSize + c] = position.getComponent(v, c);
+  }
+  const bytes = new Uint8Array(values.buffer);
+  let hash = 2166136261;
+  for (let i = 0; i < bytes.length; i++) hash = Math.imul(hash ^ bytes[i], 16777619);
+  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+
+export { BAKED_FILE_EXTENSION, BAKED_FILE_VERSION, BAKED_LAYER_FORMATS, bakeVAT, bakeVATWith, decodeOctahedral, encodeOctahedral, flatFacts, keepRestSlots, mergedFlatMaterial, positionDigest, restSlotsOf };