three-vat 4.0.0 → 4.2.0

package/dist/{chunk-BSAJL5PG.js → chunk-4IKOXUSX.js}

@@ -3,6 +3,20 @@ import { FloatType, DataTexture, RGBAFormat, RGFormat, UnsignedByteType, HalfFlo
 // src/vat-texture.ts
 var MAX_TEXTURE_SIZE = 16384;
 var HALF_FLOAT_MAX = 65504;
+function vertexLayoutFor(vertexCount, totalFrames, maxTextureSize) {
+  const rowsPerFrame = Math.max(1, Math.ceil(vertexCount / maxTextureSize));
+  const width = vertexWidthOf({ vertexCount, rowsPerFrame });
+  const height = totalFrames * rowsPerFrame;
+  if (height > maxTextureSize) {
+    throw new Error(
+      `three-vat: totalFrames ${totalFrames} at ${rowsPerFrame} rows a frame is ${height} rows, which exceeds maxTextureSize ${maxTextureSize} \u2014 the vertex encoding spans each frame's ${vertexCount} vertices across ${rowsPerFrame} rows of ${width}; lower fps or bake fewer clips`
+    );
+  }
+  return { rowsPerFrame, width, height, frameStride: rowsPerFrame * width };
+}
+function vertexWidthOf({ vertexCount, rowsPerFrame }) {
+  return Math.ceil(vertexCount / rowsPerFrame);
+}
 function sampledExactly(tex) {
   tex.minFilter = NearestFilter;
   tex.magFilter = NearestFilter;
@@ -77,6 +91,7 @@ function crossfadeOf(instance) {
   if (!from || !asksToBlend(instance)) return null;
   return { from, duration: instance.fadeDuration };
 }
+var fadeStartOf = (instance) => instance.fadeStart ?? instance.startTime;
 var asksToBlend = (instance) => (instance.fadeDuration ?? 0) > 0;
 function resolveVATFrame(instance, time) {
   const { clip } = instance;
@@ -84,16 +99,14 @@ function resolveVATFrame(instance, time) {
   const last = frames - 1;
   const duration = frames / clip.fps;
   const { loopMode, repetitions, endMode, speed } = resolvedPlaybackOf(instance);
-  const local = (time - instance.startTime) * speed;
-  const loops = local / duration;
+  const reversed = speed < 0;
+  const local = (time - instance.startTime) * Math.abs(speed);
   const started = local >= 0;
+  const loops = Math.max(local, 0) / duration;
   const finished = started && repetitions !== INFINITE_REPETITIONS && loops >= repetitions;
   let phase;
   let looping;
-  if (!started) {
-    phase = 0;
-    looping = false;
-  } else if (finished) {
+  if (finished) {
     phase = endMode === EndMode.Clamp ? 1 : 0;
     looping = false;
   } else if (loopMode === LoopMode.PingPong) {
@@ -104,15 +117,18 @@ function resolveVATFrame(instance, time) {
     phase = loops % 1;
     looping = true;
   }
-  const holds = looping && endMode === EndMode.Clamp && repetitions !== INFINITE_REPETITIONS && Math.floor(loops) + 1 >= repetitions;
+  const holds = looping && repetitions !== INFINITE_REPETITIONS && (reversed ? loops < 1 : endMode === EndMode.Clamp && Math.floor(loops) + 1 >= repetitions);
   const wraps = looping && !holds;
-  const f = phase * (looping ? frames : last);
+  const mirrored = 1 - phase;
+  phase = reversed ? wraps && mirrored >= 1 ? 0 : mirrored : phase;
+  const spread = phase * (looping ? frames : last);
+  const f = holds ? Math.min(spread, last) : spread;
   const f0 = Math.min(Math.floor(f), last);
   const next = f0 + 1;
   const f1 = wraps ? next >= frames ? 0 : next : Math.min(next, last);
   const row = clip.startFrame + f0;
   const crossfade = crossfadeOf(instance);
-  const elapsed = crossfade ? (time - instance.startTime) / crossfade.duration : 0;
+  const elapsed = crossfade ? (time - fadeStartOf(instance)) / crossfade.duration : 0;
   return {
     row,
     rowNext: clip.startFrame + f1,
@@ -155,16 +171,8 @@ function createVATPlaybackTexture(instances, options = {}) {
   for (let i = 0; i < count; i++) writePack(data, i, instances[i] ?? RESERVED_ROW);
   return { texture: makeVATTexture(data, PACK_WIDTH, count), count };
 }
-var FORWARD_ONLY_REASON = "a baked band plays forward from its own first row, so a negative speed would freeze it on that row rather than run it backwards \u2014 bake a reversed clip instead. A speed of 0 is a held first row, and is fine";
 var rowStart = (index) => index * PACK_STRIDE;
 var texelStart = (index, field) => rowStart(index) + field * 4;
-function checkedPolicyOf(state, index, what) {
-  const policy = resolvedPlaybackOf(state);
-  if (policy.speed < 0) {
-    throw new Error(`three-vat: ${what} ${index} has speed ${policy.speed}; ${FORWARD_ONLY_REASON}.`);
-  }
-  return policy;
-}
 function putBand(data, index, at, state, policy) {
   const clip = texelStart(index, at.clip);
   const playback = texelStart(index, at.playback);
@@ -186,18 +194,24 @@ function checkedCrossfadeOf(instance, index) {
       `three-vat: instance ${index} has fadeDuration ${duration}; a transition lasts a finite number of seconds, and 0 (or no fadeDuration at all) is the cut.`
     );
   }
+  const start = instance.fadeStart;
+  if (start !== void 0 && !Number.isFinite(start)) {
+    throw new Error(
+      `three-vat: instance ${index} has fadeStart ${start}; a blend begins at a finite clock time, and no fadeStart at all begins it at startTime.`
+    );
+  }
   return crossfadeOf(instance);
 }
 function writePack(data, index, instance) {
   const crossfade = checkedCrossfadeOf(instance, index);
-  const live = checkedPolicyOf(instance, index, "instance");
-  const outgoing = crossfade ? { state: crossfade.from, policy: checkedPolicyOf(crossfade.from, index, "the outgoing band of instance") } : null;
+  const live = resolvedPlaybackOf(instance);
+  const outgoing = crossfade ? { state: crossfade.from, policy: resolvedPlaybackOf(crossfade.from) } : null;
   const crossfadeTexel = texelStart(index, PACK_TEXELS.crossfade);
   putBand(data, index, LIVE_PAIR, instance, live);
   if (outgoing) putBand(data, index, OUTGOING_PAIR, outgoing.state, outgoing.policy);
   else clearTexels(data, index, OUTGOING_PAIR);
   data[crossfadeTexel] = crossfade ? crossfade.duration : 0;
-  data[crossfadeTexel + 1] = 0;
+  data[crossfadeTexel + 1] = fadeStartOf(instance);
   data[crossfadeTexel + 2] = 0;
   data[crossfadeTexel + 3] = 0;
 }
@@ -205,9 +219,9 @@ function clearTexels(data, index, at) {
   data.fill(0, texelStart(index, at.clip), texelStart(index, at.clip) + 4);
   data.fill(0, texelStart(index, at.playback), texelStart(index, at.playback) + 4);
 }
-function readPack(data, index) {
-  const clip = texelStart(index, PACK_TEXELS.clip);
-  const playback = texelStart(index, PACK_TEXELS.playback);
+function readPack(data, index, at = LIVE_PAIR) {
+  const clip = texelStart(index, at.clip);
+  const playback = texelStart(index, at.playback);
   return {
     clip: { startFrame: data[clip], frames: data[clip + 1], fps: data[clip + 2] },
     startTime: data[playback],
@@ -217,6 +231,13 @@ function readPack(data, index) {
     endMode: data[playback + 3]
   };
 }
+function readInstance(data, index) {
+  const live = readPack(data, index);
+  const crossfade = texelStart(index, PACK_TEXELS.crossfade);
+  const fadeDuration = data[crossfade];
+  if (fadeDuration === 0) return live;
+  return { ...live, from: readPack(data, index, OUTGOING_PAIR), fadeDuration, fadeStart: data[crossfade + 1] };
+}
 function assertInstance(playback, index) {
   if (!Number.isInteger(index) || index < 0 || index >= playback.count) {
     throw new Error(`three-vat: instance ${index} is outside this crowd's ${playback.count} rows`);
@@ -227,14 +248,66 @@ function setVATInstance(playback, index, instance) {
   const data = playback.texture.image.data;
   const transitioning = instance.from === void 0 && asksToBlend(instance) ? { ...instance, from: readPack(data, index) } : instance;
   writePack(data, index, transitioning);
+  flagRow(playback, index);
+}
+function flagRow(playback, index) {
   playback.texture.addUpdateRange(rowStart(index), PACK_STRIDE);
   playback.texture.needsUpdate = true;
 }
+function turnVATInstance(playback, index, time) {
+  assertInstance(playback, index);
+  const data = playback.texture.image.data;
+  const current = readInstance(data, index);
+  const { from, fadeDuration, fadeStart: _fadeStart, ...live } = current;
+  const outgoing = resolveVATFrame(current, time).outgoing;
+  const back = outgoing && outgoing.weight > 0 ? {
+    ...turnedAt(from, time, true),
+    from: turnedAt(live, time, true),
+    fadeDuration,
+    fadeStart: 2 * time - fadeStartOf(current) - fadeDuration
+  } : turnedAt(live, time);
+  writePack(data, index, back);
+  flagRow(playback, index);
+  return back;
+}
+function turnedAt(instance, time, retracesHold = false) {
+  const { loopMode, repetitions, endMode, speed } = resolvedPlaybackOf(instance);
+  const { startFrame, frames, fps } = instance.clip;
+  const clip = { startFrame, frames, fps };
+  const rate = Math.abs(speed);
+  if (rate === 0) return { clip, startTime: instance.startTime, speed, loopMode, repetitions, endMode };
+  const duration = frames / fps;
+  const shown = resolveVATFrame(instance, time);
+  const endless = repetitions === INFINITE_REPETITIONS;
+  const loops = (time - instance.startTime) * rate / duration;
+  const waiting = loops < 0;
+  const rewound = shown.finished && endMode === EndMode.Rewind;
+  const retraced = shown.finished ? repetitions : loops;
+  const play = (startTime, speed2, repetitions2) => ({
+    clip,
+    startTime,
+    speed: speed2,
+    loopMode,
+    repetitions: repetitions2,
+    endMode: EndMode.Clamp
+  });
+  if (waiting || rewound || !endless && retraced === 0) {
+    return play(time, shown.phase > 0.5 ? rate : -rate, 0);
+  }
+  const pingPong = loopMode === LoopMode.PingPong;
+  const lead = !pingPong && speed > 0 && endMode === EndMode.Rewind ? 1 : 0;
+  const count = endless ? INFINITE_REPETITIONS : pingPong ? 2 * Math.ceil((repetitions - 1) / 2) + 1 : Math.ceil(repetitions) + lead;
+  const retracedInBlend = retracesHold && shown.finished && count === repetitions ? loops : retraced;
+  const into = endless ? pingPong ? modulo(-retraced - 1, 2) : modulo(-retraced, 1) : count - retracedInBlend;
+  return play(time - into * duration / rate, -speed, count);
+}
+var modulo = (a, n) => (a % n + n) % n;
 function endsAt(instance) {
   const { repetitions, speed } = resolvedPlaybackOf(instance);
-  if (repetitions === INFINITE_REPETITIONS || speed <= 0) return null;
+  const rate = Math.abs(speed);
+  if (repetitions === INFINITE_REPETITIONS || rate === 0) return null;
   const duration = instance.clip.frames / instance.clip.fps;
-  return instance.startTime + duration * repetitions / speed;
+  return instance.startTime + duration * repetitions / rate;
 }
 
 // src/rig-texture.ts
@@ -246,4 +319,4 @@ var RIG_TEXELS = {
 };
 var RIG_TEXELS_PER_SLOT = 2;
 
-export { EndMode, FORWARD_ONLY_REASON, HALF_FLOAT_MAX, INFINITE_REPETITIONS, LIBRARY_PLAYBACK_DEFAULTS, LoopMode, MAX_TEXTURE_SIZE, PACK_TEXELS, RIG_TEXELS, RIG_TEXELS_PER_SLOT, createVATPlaybackTexture, endsAt, makeVATNormalTexture, makeVATTexture, resolveVATFrame, setVATInstance };
+export { EndMode, HALF_FLOAT_MAX, INFINITE_REPETITIONS, LIBRARY_PLAYBACK_DEFAULTS, LoopMode, MAX_TEXTURE_SIZE, PACK_TEXELS, RIG_TEXELS, RIG_TEXELS_PER_SLOT, createVATPlaybackTexture, endsAt, makeVATNormalTexture, makeVATTexture, resolveVATFrame, setVATInstance, turnVATInstance, vertexLayoutFor, vertexWidthOf };

package/dist/chunk-7TT7B5WS.js

@@ -0,0 +1,263 @@
+import { BAKED_FILE_EXTENSION, positionDigest, BAKED_FILE_VERSION, BAKED_LAYER_FORMATS, restSlotsOf } from './chunk-P6AFXEBT.js';
+import { LoaderUtils, Mesh, BufferAttribute, Matrix4, Bone, SkinnedMesh, Skeleton, Group } from 'three';
+import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter.js';
+
+var IMAGE_EXTENSIONS = ["KHR_texture_basisu", "EXT_texture_webp", "EXT_texture_avif"];
+var MIME_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  avif: "image/avif",
+  ktx2: "image/ktx2"
+};
+async function readSourceImages(parser, readFile = fetchBeside(parser)) {
+  const json = parser.json;
+  const read = /* @__PURE__ */ new Map();
+  const image = async (index) => {
+    const cached = read.get(index);
+    if (cached) return cached;
+    const def = json.images[index];
+    const bytes = def.bufferView !== void 0 ? new Uint8Array((await parser.getDependency("bufferView", def.bufferView)).slice(0)) : new Uint8Array(dataURI(def.uri) ?? await readFile(def.uri));
+    const mimeType = def.mimeType ?? mimeTypeOf(def.uri);
+    if (mimeType === void 0) {
+      const where = def.uri.startsWith("data:") ? "embedded" : def.uri;
+      throw new Error(`image ${index} (${where}) is of no type a baked file knows`);
+    }
+    const loaded = { bytes, mimeType, ...def.name ? { name: def.name } : {} };
+    read.set(index, loaded);
+    return loaded;
+  };
+  const images = /* @__PURE__ */ new Map();
+  for (const [object, reference] of parser.associations) {
+    const texture = object;
+    if (!texture.isTexture || reference.textures === void 0 || images.has(texture.source)) continue;
+    const def = json.textures[reference.textures];
+    const entry = { extensions: {}, required: [] };
+    if (def.source !== void 0) entry.source = await image(def.source);
+    for (const name of IMAGE_EXTENSIONS) {
+      const source = def.extensions?.[name]?.source;
+      if (source === void 0) continue;
+      entry.extensions[name] = await image(source);
+      if (json.extensionsRequired?.includes(name)) entry.required.push(name);
+    }
+    images.set(texture.source, entry);
+  }
+  return images;
+}
+function dataURI(uri) {
+  const data = /^data:([^,]*),(.*)$/s.exec(uri);
+  if (!data) return void 0;
+  if (/;base64$/.test(data[1])) return Uint8Array.from(atob(data[2]), (c) => c.charCodeAt(0)).buffer;
+  return Uint8Array.from(unescape(data[2]), (c) => c.charCodeAt(0)).buffer;
+}
+function fetchBeside(parser) {
+  const path = parser.options.path ?? "";
+  return async (uri) => {
+    const url = LoaderUtils.resolveURL(uri, path);
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`cannot fetch ${url}: ${response.status} ${response.statusText}`);
+    return response.arrayBuffer();
+  };
+}
+function mimeTypeOf(uri) {
+  const data = /^data:([^;,]+)/.exec(uri);
+  if (data) return data[1];
+  return MIME_TYPES[/\.([^./]+)$/.exec(uri)?.[1]?.toLowerCase() ?? ""];
+}
+var SLOTS = ["map", "normalMap", "emissiveMap", "aoMap", "metalnessMap", "roughnessMap"];
+function strippedMaterials(materials, images) {
+  const originals = /* @__PURE__ */ new Map();
+  const stripped = materials.map((material) => {
+    const textured = material;
+    const keys = Object.keys(material).filter((key) => textured[key]?.isTexture);
+    if (keys.length === 0) return material;
+    for (const key of keys) refuseUncarriedTexture(material, key, textured[key], images);
+    const { metalnessMap, roughnessMap } = textured;
+    if (metalnessMap && roughnessMap && metalnessMap.source !== roughnessMap.source) {
+      throw new Error(
+        `three-vat: material "${material.name}" reads metalness and roughness from two images, which glTF packs into one; a baked file carries them as its source packed them`
+      );
+    }
+    const copy = material.clone();
+    for (const key of keys) copy[key] = null;
+    originals.set(copy, textured);
+    return copy;
+  });
+  return { stripped, originals };
+}
+function refuseUncarriedTexture(material, key, texture, images) {
+  if (!SLOTS.includes(key)) {
+    throw new Error(
+      `three-vat: material "${material.name}" carries a texture in ${key}, which a baked file does not carry; it carries ${SLOTS.join(", ")}`
+    );
+  }
+  if (!images.has(texture.source)) {
+    throw new Error(
+      `three-vat: material "${material.name}" carries a texture (${key}) whose image was not read from a glTF source, so there are no bytes to copy into a baked file`
+    );
+  }
+}
+var BakedMaterialsWriter = class {
+  constructor(writer, originals, sources) {
+    this.writer = writer;
+    this.originals = originals;
+    this.sources = sources;
+    this.name = "three-vat:materials";
+    this.images = /* @__PURE__ */ new Map();
+    this.textures = /* @__PURE__ */ new Map();
+  }
+  async writeMaterialAsync(material, def) {
+    const original = this.originals.get(material);
+    if (original === void 0) return;
+    const { map, normalMap, emissiveMap, aoMap, metalnessMap, roughnessMap } = original;
+    def.pbrMetallicRoughness ?? (def.pbrMetallicRoughness = {});
+    if (map) def.pbrMetallicRoughness.baseColorTexture = this.info(map);
+    const metalRough = metalnessMap ?? roughnessMap;
+    if (metalRough) def.pbrMetallicRoughness.metallicRoughnessTexture = this.info(metalRough);
+    if (normalMap) {
+      def.normalTexture = this.info(normalMap);
+      const scale = original.normalScale.x;
+      if (scale !== 1) def.normalTexture.scale = scale;
+    }
+    if (emissiveMap) def.emissiveTexture = this.info(emissiveMap);
+    if (aoMap) {
+      def.occlusionTexture = this.info(aoMap);
+      if (original.aoMapIntensity !== 1) def.occlusionTexture.strength = original.aoMapIntensity;
+    }
+  }
+  info(texture) {
+    const info = { index: this.texture(texture), texCoord: texture.channel };
+    this.writer.applyTextureTransform(info, texture);
+    return info;
+  }
+  /** A texture definition: the source's image layout, with this map's sampler. */
+  texture(texture) {
+    var _a;
+    const { writer } = this;
+    const { magFilter, minFilter, wrapS, wrapT } = texture;
+    const key = [texture.source.uuid, texture.name, magFilter, minFilter, wrapS, wrapT].join(":");
+    const cached = this.textures.get(key);
+    if (cached !== void 0) return cached;
+    const source = this.sources.get(texture.source);
+    const def = {
+      sampler: writer.processSampler(texture)
+    };
+    if (texture.name) def.name = texture.name;
+    if (source.source) def.source = this.image(source.source);
+    for (const [name, image] of Object.entries(source.extensions)) {
+      def.extensions = { ...def.extensions, [name]: { source: this.image(image) } };
+      writer.extensionsUsed[name] = true;
+      if (source.required.includes(name)) writer.extensionsRequired[name] = true;
+    }
+    const index = ((_a = writer.json).textures ?? (_a.textures = [])).push(def) - 1;
+    this.textures.set(key, index);
+    return index;
+  }
+  /**
+   * An image: its bytes as they were, in a buffer view of its own. Not the
+   * exporter's `processBufferViewImage`, whose view spans the padding to four
+   * bytes as well, so the image it holds would end in up to three zeros.
+   */
+  image(image) {
+    var _a, _b;
+    const cached = this.images.get(image);
+    if (cached !== void 0) return cached;
+    const { writer } = this;
+    const padded = new Uint8Array(Math.ceil(image.bytes.byteLength / 4) * 4);
+    padded.set(image.bytes);
+    const view = { buffer: writer.processBuffer(padded.buffer), byteOffset: writer.byteOffset, byteLength: image.bytes.byteLength };
+    writer.byteOffset += padded.byteLength;
+    const bufferView = ((_a = writer.json).bufferViews ?? (_a.bufferViews = [])).push(view) - 1;
+    const def = { mimeType: image.mimeType, bufferView };
+    if (image.name) def.name = image.name;
+    const index = ((_b = writer.json).images ?? (_b.images = [])).push(def) - 1;
+    this.images.set(image, index);
+    return index;
+  }
+};
+var KEPT = ["MeshStandardMaterial", "MeshPhysicalMaterial", "MeshBasicMaterial"];
+var LOST = {
+  MeshPhongMaterial: ["specular", "shininess"]
+};
+function pbrConversions(materials) {
+  return materials.filter((material) => !KEPT.includes(material.type)).map((material) => ({ name: material.name, from: material.type, lost: LOST[material.type] ?? [] }));
+}
+async function writeBakedFile(vat, { images = /* @__PURE__ */ new Map() } = {}) {
+  const { stripped, originals } = strippedMaterials(vat.materials, images);
+  const mesh = vat.encoding === "rig" ? previewSkin(vat, stripped) : new Mesh(vat.geometry, stripped);
+  const exporter = new GLTFExporter().register((writer) => new VATExtensionWriter(writer, vat)).register((writer) => new BakedMaterialsWriter(writer, originals, images));
+  const glb = await exporter.parseAsync(mesh, { binary: true });
+  return new Uint8Array(glb);
+}
+var VATExtensionWriter = class {
+  constructor(writer, vat) {
+    this.writer = writer;
+    this.vat = vat;
+    this.name = BAKED_FILE_EXTENSION;
+    this.mesh = -1;
+  }
+  writeMesh() {
+    this.mesh = this.writer.json.meshes?.length ?? 0;
+  }
+  afterParse() {
+    const { vat, writer } = this;
+    const common = {
+      version: BAKED_FILE_VERSION,
+      mesh: this.mesh,
+      groups: vat.geometry.groups.map(({ start, count, materialIndex }) => ({ start, count, materialIndex })),
+      vertexCount: vat.vertexCount,
+      totalFrames: vat.totalFrames,
+      clips: vat.clips,
+      bounds: { min: vat.bounds.min.toArray(), max: vat.bounds.max.toArray() },
+      digest: positionDigest(vat.geometry.attributes.position)
+    };
+    let extension;
+    if (vat.encoding === "rig") {
+      extension = {
+        ...common,
+        encoding: "rig",
+        slotCount: vat.slotCount,
+        layers: { rig: this.layer(vat.rigTexture, "RGBA32F") }
+      };
+    } else {
+      extension = {
+        ...common,
+        encoding: "delta",
+        fallback: vat.fallback,
+        rowsPerFrame: vat.rowsPerFrame,
+        layers: { position: this.layer(vat.positionTexture, "RGBA16F") }
+      };
+      if (vat.normalTexture) extension.layers.normal = this.layer(vat.normalTexture, "RG8");
+    }
+    writer.json.extensions = { ...writer.json.extensions, [BAKED_FILE_EXTENSION]: extension };
+    writer.extensionsUsed[BAKED_FILE_EXTENSION] = true;
+  }
+  /** One texture's texels as a buffer view, written as the integers or floats they are. */
+  layer(texture, format) {
+    const data = texture.image.data;
+    const { componentType } = BAKED_LAYER_FORMATS[format];
+    const view = this.writer.processBufferView(new BufferAttribute(data, 1), componentType, 0, data.length);
+    return { bufferView: view.id, width: texture.image.width, height: texture.image.height, format };
+  }
+};
+function previewSkin(vat, materials) {
+  const rest = restSlotsOf(vat);
+  if (rest === void 0) {
+    throw new Error(
+      "three-vat: this rig-encoded VAT does not know its slots' rest matrices, which its baked file's preview skin is built from. Only a VAT bakeVAT or bakeVATInWorker returned carries them, not one loadVAT read; bake the asset and write that"
+    );
+  }
+  const matrix = new Matrix4();
+  const joints = Array.from({ length: vat.slotCount }, (_, slot) => {
+    const joint = new Bone();
+    joint.name = `slot ${slot}`;
+    matrix.fromArray(rest, slot * 16).decompose(joint.position, joint.quaternion, joint.scale);
+    return joint;
+  });
+  const mesh = new SkinnedMesh(vat.geometry, materials);
+  mesh.bind(new Skeleton(joints, joints.map(() => new Matrix4())), new Matrix4());
+  return new Group().add(mesh, ...joints);
+}
+
+export { dataURI, pbrConversions, readSourceImages, writeBakedFile };