three-vat 4.0.0 → 4.1.0

package/README.md

@@ -84,8 +84,8 @@ Two things worth knowing the first time:
 
 **A skinned character?** The bake picks the rig encoding for it by itself: the
 posed rig instead of the posed vertices, for two orders of magnitude less
-texture, a bake in milliseconds, and no vertex ceiling for a phone's 4096 to
-refuse. Assets a rig cannot express fall back to vertices, and `vat.fallback`
+texture, a bake in milliseconds, and a texture whose width is the rig's, not
+the mesh's. Assets a rig cannot express fall back to vertices, and `vat.fallback`
 says why. [The rig encoding](./docs/usage.md#the-rig-encoding-encoding-rig).
 
 <details>

package/dist/{carrier-D4pkftSk.d.ts → carrier-VLSJLgjX.d.ts}

@@ -478,9 +478,17 @@ interface VATBase {
     clips: VATClip[];
     /** Union of every baked frame's bounds; use as the geometry bounding box. */
     bounds: Box3;
-    /** Vertex count (texture width). */
+    /**
+     * Vertices in the merged geometry — the vertex encoding's texture width
+     * wherever they fit one row, which is every bake below the ceiling
+     * ({@link DeltaVAT.rowsPerFrame}).
+     */
     vertexCount: number;
-    /** Total frame rows across all clips (texture height). */
+    /**
+     * Total frames across all clips — the texture's height in rows, times
+     * {@link DeltaVAT.rowsPerFrame} under the vertex encoding. The unit every
+     * `startFrame` and `frames` in the clip table counts in.
+     */
     totalFrames: number;
 }
 /**
@@ -515,6 +523,16 @@ interface DeltaVAT extends VATBase {
      * a VAT is refused rather than lit by its rest pose.
      */
     normalTexture: DataTexture | null;
+    /**
+     * Texture rows one frame takes (ADR-0030). `1` wherever the vertex count
+     * fits the bake's `maxTextureSize`, and then both layers are `vertexCount`
+     * wide and `totalFrames` tall, as every bake before this field was. Past it,
+     * a frame's vertices continue onto the next row: the fewest rows that hold
+     * them, `ceil(vertexCount / rowsPerFrame)` texels wide, and vertex `v` of
+     * frame `f` at column `v mod width`, row `f × rowsPerFrame + floor(v /
+     * width)`. Both decode paths read it; neither adds a line where it is `1`.
+     */
+    rowsPerFrame: number;
     /**
      * Why the default encoding fell back to this one (ADR-0029): the message of
      * the rig encoding's refusal, naming what the rig could not store and where

package/dist/{chunk-BSAJL5PG.js → chunk-OEKKEHRQ.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;
@@ -246,4 +260,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, 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, vertexLayoutFor, vertexWidthOf };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { AnimationClip, AnimationAction, Object3D, DataTexture, FloatType, HalfFloatType } from 'three';
-import { D as DeltaVAT, R as RigVAT, V as VAT } from './carrier-D4pkftSk.js';
-export { E as EndMode, I as INFINITE_REPETITIONS, L as LoopMode, a as VATBase, b as VATCarrier, c as VATClip, d as VATClipDefaults, e as VATClock, f as VATCrowd, g as VATFrame, h as VATInstance, i as VATOutgoingFrame, j as VATPlaybackState, k as VATPlaybackTexture, l as VATPlaybackTextureOptions, m as createVATPlaybackTexture, n as endsAt, r as resolveVATFrame, s as setVATInstance } from './carrier-D4pkftSk.js';
+import { D as DeltaVAT, R as RigVAT, V as VAT } from './carrier-VLSJLgjX.js';
+export { E as EndMode, I as INFINITE_REPETITIONS, L as LoopMode, a as VATBase, b as VATCarrier, c as VATClip, d as VATClipDefaults, e as VATClock, f as VATCrowd, g as VATFrame, h as VATInstance, i as VATOutgoingFrame, j as VATPlaybackState, k as VATPlaybackTexture, l as VATPlaybackTextureOptions, m as createVATPlaybackTexture, n as endsAt, r as resolveVATFrame, s as setVATInstance } from './carrier-VLSJLgjX.js';
 
 /**
  * What {@link bakeVAT} takes for each animation: the clip itself, or an
@@ -15,10 +15,14 @@ interface BakeOptions {
     /** Sample rate in frames per second. Default `30`. */
     fps?: number;
     /**
-     * Largest texture dimension the target GPU accepts. Both VAT axes are checked
-     * against it: `vertexCount` (width) and `totalFrames` (height). Defaults to
+     * Largest texture dimension the target GPU accepts. Under the rig encoding
+     * both axes are checked against it: the rig's width and `totalFrames`. Under
+     * the vertex encoding a frame whose vertices outnumber it spans several rows
+     * instead of refusing (ADR-0030), so the height alone is checked: `totalFrames
+     * × rowsPerFrame`. Defaults to
      * {@link MAX_TEXTURE_SIZE}; pass the renderer's real limit to avoid baking a
-     * VAT that allocates on your desktop and fails on a phone.
+     * VAT that allocates on your desktop and fails on a phone, and so that a
+     * frame spans rows only where this GPU needs it to.
      */
     maxTextureSize?: number;
     /**
@@ -220,7 +224,8 @@ interface Vec3Out {
 }
 /**
  * Write a normal into two bytes of a VAT normal texture's buffer, at `offset`
- * and `offset + 1` — `(row * vertexCount + vertex) * 2` for the texel of one
+ * and `offset + 1` — `(row * vertexCount + vertex) * 2` in a one-row bake,
+ * `deltaTexel` in `src/test-utils.ts` in any, for the texel of one
  * vertex at one frame.
  *
  * Takes a direction, not a unit vector: the first step is a division by the L1

package/dist/index.js

@@ -1,6 +1,6 @@
-import { LoopMode, MAX_TEXTURE_SIZE, HALF_FLOAT_MAX, makeVATNormalTexture, makeVATTexture, RIG_TEXELS_PER_SLOT, RIG_TEXELS, LIBRARY_PLAYBACK_DEFAULTS, FORWARD_ONLY_REASON, INFINITE_REPETITIONS } from './chunk-BSAJL5PG.js';
-export { EndMode, INFINITE_REPETITIONS, LoopMode, MAX_TEXTURE_SIZE, createVATPlaybackTexture, endsAt, makeVATNormalTexture, makeVATTexture, resolveVATFrame, setVATInstance } from './chunk-BSAJL5PG.js';
-import { LoopRepeat, LoopOnce, LoopPingPong, DataUtils, Quaternion, Matrix4, AnimationMixer, Box3, Vector4, Vector3, Sphere, HalfFloatType, BufferGeometry, BufferAttribute, AdditiveAnimationBlendMode, PropertyBinding, InterleavedBufferAttribute, FloatType, Material, InterleavedBuffer, SkinnedMesh, Mesh, Bone, Object3D, Skeleton, AnimationClip, Color, VectorKeyframeTrack, StringKeyframeTrack, QuaternionKeyframeTrack, NumberKeyframeTrack, ColorKeyframeTrack, BooleanKeyframeTrack, Float16BufferAttribute, Interpolant } from 'three';
+import { LoopMode, MAX_TEXTURE_SIZE, vertexLayoutFor, makeVATNormalTexture, makeVATTexture, RIG_TEXELS_PER_SLOT, LIBRARY_PLAYBACK_DEFAULTS, FORWARD_ONLY_REASON, INFINITE_REPETITIONS, HALF_FLOAT_MAX, RIG_TEXELS } from './chunk-OEKKEHRQ.js';
+export { EndMode, INFINITE_REPETITIONS, LoopMode, MAX_TEXTURE_SIZE, createVATPlaybackTexture, endsAt, makeVATNormalTexture, makeVATTexture, resolveVATFrame, setVATInstance } from './chunk-OEKKEHRQ.js';
+import { LoopRepeat, LoopOnce, LoopPingPong, DataUtils, Quaternion, Matrix4, Box3, Vector4, Vector3, Sphere, HalfFloatType, BufferGeometry, BufferAttribute, AdditiveAnimationBlendMode, AnimationMixer, PropertyBinding, FloatType, Material, InterleavedBuffer, SkinnedMesh, Mesh, Bone, Object3D, Skeleton, AnimationClip, Color, InterleavedBufferAttribute, VectorKeyframeTrack, StringKeyframeTrack, QuaternionKeyframeTrack, NumberKeyframeTrack, ColorKeyframeTrack, BooleanKeyframeTrack, Float16BufferAttribute, Interpolant } from 'three';
 
 var IGNORED = ["uuid", "name", "color", "userData", "metadata"];
 function flatFacts(material) {
@@ -125,6 +125,32 @@ function morphCountOf({ mesh, morphPos, morphNrm }) {
   const influences = mesh.morphTargetInfluences;
   return influences ? Math.min(influences.length, Math.max(morphPos?.length ?? 0, morphNrm?.length ?? 0)) : 0;
 }
+var _mt = /* @__PURE__ */ new Vector3();
+var _mb = /* @__PURE__ */ new Vector3();
+var _mbn = /* @__PURE__ */ new Vector3();
+function morphVertex(part, v, weights, count, p, n) {
+  const { basePos, baseNrm, morphPos, morphNrm, morphRelative } = part;
+  if (!morphRelative) {
+    _mb.fromBufferAttribute(basePos, v);
+    if (n) _mbn.fromBufferAttribute(baseNrm, v);
+  }
+  for (let t = 0; t < count; t++) {
+    const w = weights[t];
+    if (w === 0) continue;
+    const targetPos = morphPos?.[t];
+    if (targetPos) {
+      _mt.fromBufferAttribute(targetPos, v);
+      if (!morphRelative) _mt.sub(_mb);
+      p.addScaledVector(_mt, w);
+    }
+    const targetNrm = n ? morphNrm?.[t] : void 0;
+    if (n && targetNrm) {
+      _mt.fromBufferAttribute(targetNrm, v);
+      if (!morphRelative) _mt.sub(_mbn);
+      n.addScaledVector(_mt, w);
+    }
+  }
+}
 function asAttribute(value, mesh, name) {
   if (!(value instanceof BufferAttribute)) {
     throw new Error(
@@ -201,39 +227,48 @@ function collectParts(root, hooks) {
 function mergeGeometry(parts, restMatrices, total) {
   const position = new Float32Array(total * 3);
   const normal = new Float32Array(total * 3);
-  const want = optionalAttributes(parts);
+  const _v = new Vector3();
+  const _n = new Vector3();
+  parts.forEach((part, pi) => {
+    const m = restMatrices[pi];
+    for (let v = 0; v < part.vertexCount; v++) {
+      _v.fromBufferAttribute(part.basePos, v).applyMatrix4(m);
+      _n.fromBufferAttribute(part.baseNrm, v).transformDirection(m);
+      _v.toArray(position, (part.vertexStart + v) * 3);
+      _n.toArray(normal, (part.vertexStart + v) * 3);
+    }
+  });
+  const merged = new BufferGeometry();
+  merged.setAttribute("position", new BufferAttribute(position, 3));
+  merged.setAttribute("normal", new BufferAttribute(normal, 3));
+  mergeSurface(merged, parts, total, restMatrices);
+  return merged;
+}
+function mergeSurface(merged, parts, total, restMatrices) {
+  const merging = parts.some((p) => p.tint);
+  const want = optionalAttributes(parts, merging);
   const uv = want.uv ? new Float32Array(total * 2) : null;
   const color = want.color ? new Float32Array(total * 3) : null;
-  const merging = parts.some((p) => p.tint);
   const tangent = want.tangent ? new Float32Array(total * 4) : null;
-  const _v = new Vector3();
-  const _n = new Vector3();
   const _t = new Vector3();
   parts.forEach((part, pi) => {
-    const m = restMatrices[pi];
     const geometry = part.mesh.geometry;
     const start = part.vertexStart;
     const srcUV = uv ? asAttribute(geometry.attributes.uv, part.mesh, "uv") : null;
-    const srcColor = colorSource(part, !!color, merging);
+    const srcColor = color ? colorSource(part, merging) : null;
     const srcTangent = tangent ? geometry.attributes.tangent : null;
+    const m = restMatrices?.[pi];
     for (let v = 0; v < part.vertexCount; v++) {
-      _v.fromBufferAttribute(part.basePos, v).applyMatrix4(m);
-      _n.fromBufferAttribute(part.baseNrm, v).transformDirection(m);
-      const o3 = (start + v) * 3;
-      position[o3] = _v.x;
-      position[o3 + 1] = _v.y;
-      position[o3 + 2] = _v.z;
-      normal[o3] = _n.x;
-      normal[o3 + 1] = _n.y;
-      normal[o3 + 2] = _n.z;
+      const vi = start + v;
       if (uv && srcUV) {
-        uv[(start + v) * 2] = srcUV.getX(v);
-        uv[(start + v) * 2 + 1] = srcUV.getY(v);
+        uv[vi * 2] = srcUV.getX(v);
+        uv[vi * 2 + 1] = srcUV.getY(v);
       }
-      if (color) writeColor(color, o3, part, srcColor, v);
+      if (color) writeColor(color, vi * 3, part, srcColor, v);
       if (tangent && srcTangent) {
-        _t.fromBufferAttribute(srcTangent, v).transformDirection(m);
-        const o4 = (start + v) * 4;
+        _t.fromBufferAttribute(srcTangent, v);
+        if (m) _t.transformDirection(m);
+        const o4 = vi * 4;
         tangent[o4] = _t.x;
         tangent[o4 + 1] = _t.y;
         tangent[o4 + 2] = _t.z;
@@ -241,18 +276,14 @@ function mergeGeometry(parts, restMatrices, total) {
       }
     }
   });
-  const merged = new BufferGeometry();
-  merged.setAttribute("position", new BufferAttribute(position, 3));
-  merged.setAttribute("normal", new BufferAttribute(normal, 3));
   if (uv) merged.setAttribute("uv", new BufferAttribute(uv, 2));
   if (color) merged.setAttribute("color", new BufferAttribute(color, 3));
   if (tangent) merged.setAttribute("tangent", new BufferAttribute(tangent, 4));
   indexParts(merged, parts);
-  return merged;
 }
-function colorSource(part, wanted, merging) {
+function colorSource(part, merging) {
   const source = part.mesh.geometry.attributes.color;
-  if (!wanted || part.tint || !source) return null;
+  if (part.tint || !source) return null;
   if (merging && source instanceof InterleavedBufferAttribute) return source;
   return asAttribute(source, part.mesh, "color");
 }
@@ -269,13 +300,13 @@ function writeColor(out, o3, part, source, v) {
     out[o3] = out[o3 + 1] = out[o3 + 2] = 1;
   }
 }
-function optionalAttributes(parts) {
+function optionalAttributes(parts, merging) {
   return {
     uv: parts.every((p) => !!p.mesh.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: parts.some((p) => p.tint) || parts.every((p) => !!p.mesh.geometry.attributes.color),
+    color: merging || parts.every((p) => !!p.mesh.geometry.attributes.color),
     tangent: parts.every((p) => {
       const t = p.mesh.geometry.attributes.tangent;
       return t instanceof BufferAttribute && t.itemSize === 4;
@@ -356,44 +387,13 @@ function bakeVATWith(root, animations, options, hooks) {
 function unprefixed(error) {
   return error.message.replace(/^three-vat: /, "");
 }
-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);
-  if (vertexCount > maxTextureSize) {
-    throw new Error(
-      `three-vat: vertexCount ${vertexCount} exceeds maxTextureSize ${maxTextureSize}; row wrapping is not implemented`
-    );
-  }
-  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)
-  );
-  const geometry = mergeGeometry(parts, restMatrices, vertexCount);
-  const mergedBase = geometry.attributes.position;
-  const posData = new Uint16Array(vertexCount * totalFrames * 4);
-  const nrmData = bakeNormals ? new Uint8Array(vertexCount * totalFrames * 2) : null;
-  const bakeNormal = nrmData !== null;
+function sampleClips(root, resolved, frameCounts, poses, writeFrame) {
   const mixer = new AnimationMixer(root);
-  const bounds = new Box3();
   const clipTable = [];
-  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 _mt = new Vector3();
-  const _mb = new Vector3();
-  const _mbn = new Vector3();
-  const poses = attachPoseBuffers(parts);
-  const influencers = bakeNormals ? parts.filter((p) => p.pose).map(influencedBones) : [];
-  let warnedNonUniformScale = false;
   let rowOffset = 0;
   try {
-    clips.forEach((clip, ci) => {
+    for (let ci = 0; ci < resolved.length; ci++) {
+      const { clip, defaults } = resolved[ci];
       const frames = frameCounts[ci];
       const action = mixer.clipAction(clip);
       action.play();
@@ -401,81 +401,8 @@ function bakeVertices(root, parts, resolved, { fps, maxTextureSize, bakeNormals
       for (let f = 0; f < frames; f++) {
         mixer.setTime(f / frames * clip.duration);
         root.updateMatrixWorld(true);
-        const row = rowOffset + f;
         poseSkeletons(poses);
-        if (!warnedNonUniformScale) {
-          warnedNonUniformScale = warnOnNonUniformBoneScale(influencers);
-        }
-        for (const part of parts) {
-          _partMatrix.multiplyMatrices(rootInverse, part.mesh.matrixWorld);
-          const influences = part.mesh.morphTargetInfluences;
-          const { morphPos, morphNrm, morphRelative, isSkinned, skinIndex, skinWeight } = part;
-          const boneMatrices = part.pose?.matrices;
-          const morphCount = morphCountOf(part);
-          for (let v = 0; v < part.vertexCount; v++) {
-            const vi = part.vertexStart + v;
-            _p.fromBufferAttribute(part.basePos, v);
-            if (bakeNormal) _n.fromBufferAttribute(part.baseNrm, v);
-            if (influences && morphCount > 0) {
-              if (!morphRelative) {
-                _mb.fromBufferAttribute(part.basePos, v);
-                if (bakeNormal) _mbn.fromBufferAttribute(part.baseNrm, v);
-              }
-              for (let t = 0; t < morphCount; t++) {
-                const w = influences[t];
-                if (w === 0) continue;
-                const targetPos = morphPos?.[t];
-                if (targetPos) {
-                  _mt.fromBufferAttribute(targetPos, v);
-                  if (!morphRelative) _mt.sub(_mb);
-                  _p.addScaledVector(_mt, w);
-                }
-                const targetNrm = bakeNormal ? morphNrm?.[t] : void 0;
-                if (targetNrm) {
-                  _mt.fromBufferAttribute(targetNrm, v);
-                  if (!morphRelative) _mt.sub(_mbn);
-                  _n.addScaledVector(_mt, w);
-                }
-              }
-            }
-            if (isSkinned && boneMatrices) {
-              const skinned = part.mesh;
-              _si.fromBufferAttribute(skinIndex, v);
-              _sw.fromBufferAttribute(skinWeight, v);
-              const ae = _acc.elements;
-              ae.fill(0);
-              for (let i = 0; i < 4; i++) {
-                const w = _sw.getComponent(i);
-                if (w === 0) continue;
-                const b = _si.getComponent(i) * BONE_STRIDE;
-                for (let e = 0; e < 16; e++) ae[e] += boneMatrices[b + e] * w;
-              }
-              _skin.multiplyMatrices(_acc, skinned.bindMatrix).premultiply(skinned.bindMatrixInverse);
-              _p.applyMatrix4(_skin);
-              if (bakeNormal) _n.transformDirection(_skin);
-            }
-            _p.applyMatrix4(_partMatrix);
-            if (bakeNormal) _n.transformDirection(_partMatrix);
-            bounds.expandByPoint(_p);
-            _bp.fromBufferAttribute(mergedBase, vi);
-            const o = (row * vertexCount + vi) * 4;
-            const dx = _p.x - _bp.x;
-            const dy = _p.y - _bp.y;
-            const dz = _p.z - _bp.z;
-            maxDeltaSq = Math.max(maxDeltaSq, dx * dx + dy * dy + dz * dz);
-            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, (row * vertexCount + vi) * 2);
-          }
-        }
+        maxDeltaSq = Math.max(maxDeltaSq, writeFrame(clip, f, rowOffset + f));
       }
       action.stop();
       clipTable.push({
@@ -487,26 +414,113 @@ function bakeVertices(root, parts, resolved, { fps, maxTextureSize, bakeNormals
         maxDelta: Math.sqrt(maxDeltaSq),
         // Declared once, here, rather than repeated at every instance that plays
         // this band. An instance overrides any of them, field by field.
-        ...resolved[ci].defaults
+        ...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, vertexCount, totalFrames, HalfFloatType),
-    normalTexture: nrmData ? makeVATNormalTexture(nrmData, vertexCount, totalFrames) : null,
+    positionTexture: makeVATTexture(posData, width, height, HalfFloatType),
+    normalTexture: nrmData ? makeVATNormalTexture(nrmData, width, height) : null,
     clips: clipTable,
     bounds,
     vertexCount,
     totalFrames,
+    rowsPerFrame,
     encoding: "delta",
     geometry,
     materials
@@ -713,34 +727,17 @@ ${clips.join("\n")}`;
   );
 }
 function foldMorphs(part, statics) {
-  const { vertexCount, basePos, baseNrm, morphPos, morphNrm, morphRelative } = part;
+  const { vertexCount, basePos, baseNrm } = part;
   const position = new Float32Array(vertexCount * 3);
   const normal = new Float32Array(vertexCount * 3);
   const active = statics.some((w) => w !== 0);
   const _p = new Vector3();
   const _n = new Vector3();
-  const _mt = new Vector3();
-  const _mb = new Vector3();
   for (let v = 0; v < vertexCount; v++) {
     _p.fromBufferAttribute(basePos, v);
     _n.fromBufferAttribute(baseNrm, v);
     if (active) {
-      for (let t = 0; t < statics.length; t++) {
-        const w = statics[t];
-        if (w === 0) continue;
-        const targetPos = morphPos?.[t];
-        if (targetPos) {
-          _mt.fromBufferAttribute(targetPos, v);
-          if (!morphRelative) _mt.sub(_mb.fromBufferAttribute(basePos, v));
-          _p.addScaledVector(_mt, w);
-        }
-        const targetNrm = morphNrm?.[t];
-        if (targetNrm) {
-          _mt.fromBufferAttribute(targetNrm, v);
-          if (!morphRelative) _mt.sub(_mb.fromBufferAttribute(baseNrm, v));
-          _n.addScaledVector(_mt, w);
-        }
-      }
+      morphVertex(part, v, statics, statics.length, _p, _n);
       _n.normalize();
     }
     _p.toArray(position, v * 3);
@@ -838,128 +835,101 @@ function bakeRig(root, parts, resolved, { fps, maxTextureSize }) {
   const data = new Float32Array(width * totalFrames * 4);
   const slotMatrices = new Float64Array(slotCount * BONE_STRIDE);
   const previous = new Float64Array(slotCount * 4);
-  const mixer = new AnimationMixer(root);
   const bounds = new Box3();
-  const clipTable = [];
   let minX = Infinity;
   let minY = Infinity;
   let minZ = Infinity;
   let maxX = -Infinity;
   let maxY = -Infinity;
   let maxZ = -Infinity;
-  let rowOffset = 0;
-  try {
-    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 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);
-            _q2.fromArray(previous, p4);
-            if (_q2.lengthSq() === 0) _q2.identity();
-            scale = 0;
-          } else {
-            if (det < 0) for (const e of MATRIX_BASIS) _slot.elements[e] = -_slot.elements[e];
-            _slot.decompose(_t, _q2, _s);
-            scale = det < 0 ? -_s.x : _s.x;
-          }
-          if (previous[p4] * _q2.x + previous[p4 + 1] * _q2.y + previous[p4 + 2] * _q2.z + previous[p4 + 3] * _q2.w < 0) {
-            _q2.set(-_q2.x, -_q2.y, -_q2.z, -_q2.w);
-          }
-          previous[p4] = _q2.x;
-          previous[p4 + 1] = _q2.y;
-          previous[p4 + 2] = _q2.z;
-          previous[p4 + 3] = _q2.w;
-          const o = (row * width + slot * RIG_TEXELS_PER_SLOT) * 4;
-          const rotation = o + RIG_TEXELS.rotation * 4;
-          data[rotation] = _q2.x;
-          data[rotation + 1] = _q2.y;
-          data[rotation + 2] = _q2.z;
-          data[rotation + 3] = _q2.w;
-          const placementTexel = o + RIG_TEXELS.placement * 4;
-          data[placementTexel] = _t.x;
-          data[placementTexel + 1] = _t.y;
-          data[placementTexel + 2] = _t.z;
-          data[placementTexel + 3] = scale;
-        }
-        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;
+  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}`
+          );
         }
       }
-      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;
-    });
-  } finally {
-    mixer.stopAllAction();
-    mixer.setTime(0);
-    root.updateMatrixWorld(true);
-  }
+      if (rig) {
+        _slot.fromArray(rig.pose.matrices, rig.bone * BONE_STRIDE).multiply(rig.bindMatrix).premultiply(placement);
+      } else {
+        _slot.copy(placement);
+      }
+      slotMatrices.set(_slot.elements, slot * BONE_STRIDE);
+      if (influenced[slot] && (hasNonUniformScale(slotMatrices, slot) || hasShear(slotMatrices, slot))) {
+        throw nonUniformScale(slotLabel(slots[slot]), clip);
+      }
+      const p4 = slot * 4;
+      const det = _slot.determinant();
+      let scale;
+      if (det === 0) {
+        _t.setFromMatrixPosition(_slot);
+        _q2.fromArray(previous, p4);
+        if (_q2.lengthSq() === 0) _q2.identity();
+        scale = 0;
+      } else {
+        if (det < 0) for (const e of MATRIX_BASIS) _slot.elements[e] = -_slot.elements[e];
+        _slot.decompose(_t, _q2, _s);
+        scale = det < 0 ? -_s.x : _s.x;
+      }
+      if (previous[p4] * _q2.x + previous[p4 + 1] * _q2.y + previous[p4 + 2] * _q2.z + previous[p4 + 3] * _q2.w < 0) {
+        _q2.set(-_q2.x, -_q2.y, -_q2.z, -_q2.w);
+      }
+      previous[p4] = _q2.x;
+      previous[p4 + 1] = _q2.y;
+      previous[p4 + 2] = _q2.z;
+      previous[p4 + 3] = _q2.w;
+      const o = (row * width + slot * RIG_TEXELS_PER_SLOT) * 4;
+      const rotation = o + RIG_TEXELS.rotation * 4;
+      data[rotation] = _q2.x;
+      data[rotation + 1] = _q2.y;
+      data[rotation + 2] = _q2.z;
+      data[rotation + 3] = _q2.w;
+      const placementTexel = o + RIG_TEXELS.placement * 4;
+      data[placementTexel] = _t.x;
+      data[placementTexel + 1] = _t.y;
+      data[placementTexel + 2] = _t.z;
+      data[placementTexel + 3] = scale;
+    }
+    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();
@@ -979,30 +949,18 @@ function bakeRig(root, parts, resolved, { fps, maxTextureSize }) {
   };
 }
 function mergeRigGeometry(rigParts, total) {
-  const parts = rigParts.map((r) => r.part);
   const position = new Float32Array(total * 3);
   const normal = new Float32Array(total * 3);
   const slotIndex = new Uint16Array(total * 4);
   const slotWeight = new Float32Array(total * 4);
-  const want = optionalAttributes(parts);
-  const uv = want.uv ? new Float32Array(total * 2) : null;
-  const color = want.color ? new Float32Array(total * 3) : null;
-  const merging = parts.some((p) => p.tint);
-  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 = colorSource(part, !!color, merging);
-    const srcTangent = tangent ? geometry.attributes.tangent : null;
     position.set(restPos, start * 3);
     normal.set(restNrm, start * 3);
     for (let v = 0; v < part.vertexCount; v++) {
-      const vi = start + v;
-      const o3 = vi * 3;
-      const o4 = vi * 4;
+      const o4 = (start + v) * 4;
       if (srcIndex && srcWeight) {
         for (let i = 0; i < 4; i++) {
           slotIndex[o4 + i] = slotOf[srcIndex.getComponent(v, i)];
@@ -1012,17 +970,6 @@ function mergeRigGeometry(rigParts, total) {
         slotIndex[o4] = slotOf[0];
         slotWeight[o4] = 1;
       }
-      if (uv && srcUV) {
-        uv[vi * 2] = srcUV.getX(v);
-        uv[vi * 2 + 1] = srcUV.getY(v);
-      }
-      if (color) writeColor(color, o3, part, srcColor, 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();
@@ -1030,10 +977,7 @@ function mergeRigGeometry(rigParts, total) {
   merged.setAttribute("normal", new BufferAttribute(normal, 3));
   merged.setAttribute("skinIndex", new BufferAttribute(slotIndex, 4));
   merged.setAttribute("skinWeight", new BufferAttribute(slotWeight, 4));
-  if (uv) merged.setAttribute("uv", new BufferAttribute(uv, 2));
-  if (color) merged.setAttribute("color", new BufferAttribute(color, 3));
-  if (tangent) merged.setAttribute("tangent", new BufferAttribute(tangent, 4));
-  indexParts(merged, parts);
+  mergeSurface(merged, rigParts.map((r) => r.part), total, null);
   return merged;
 }
 var REQUEST = "three-vat:bake";
@@ -1396,9 +1340,11 @@ function recordVAT(vat, stand) {
     encoding: vat.encoding,
     texels: transferable(texture.image.data, true, transfer),
     width: texture.image.width,
+    height: texture.image.height,
     normals: normals ? transferable(normals, true, transfer) : null,
     slotCount: vat.encoding === "rig" ? vat.slotCount : 0,
     fallback: vat.encoding === "delta" ? vat.fallback : null,
+    rowsPerFrame: vat.encoding === "delta" ? vat.rowsPerFrame : 1,
     geometry: recordGeometry(vat.geometry, true, transfer, /* @__PURE__ */ new Map(), []),
     materials: vat.materials.map((m) => stand.get(m)),
     clips: vat.clips,
@@ -1426,17 +1372,18 @@ function rebuildVAT(record, materials) {
   if (record.encoding === "rig") {
     const vat2 = {
       encoding: "rig",
-      rigTexture: makeVATTexture(record.texels, record.width, record.totalFrames, FloatType),
+      rigTexture: makeVATTexture(record.texels, record.width, record.height, FloatType),
       slotCount: record.slotCount,
       ...base
     };
     return vat2;
   }
   const vat = {
-    positionTexture: makeVATTexture(record.texels, record.width, record.totalFrames, HalfFloatType),
-    normalTexture: record.normals ? makeVATNormalTexture(record.normals, record.width, record.totalFrames) : null,
+    positionTexture: makeVATTexture(record.texels, record.width, record.height, HalfFloatType),
+    normalTexture: record.normals ? makeVATNormalTexture(record.normals, record.width, record.height) : null,
     encoding: "delta",
     fallback: record.fallback,
+    rowsPerFrame: record.rowsPerFrame,
     ...base
   };
   return vat;

package/dist/tsl.d.ts

@@ -1,5 +1,5 @@
 import { Node } from 'three/webgpu';
-import { e as VATClock, k as VATPlaybackTexture, b as VATCarrier, V as VAT, h as VATInstance, f as VATCrowd } from './carrier-D4pkftSk.js';
+import { e as VATClock, k as VATPlaybackTexture, b as VATCarrier, V as VAT, h as VATInstance, f as VATCrowd } from './carrier-VLSJLgjX.js';
 import 'three';
 
 /**

package/dist/tsl.js

@@ -1,5 +1,5 @@
 import { isBatchedCarrier, assertVATCarrier, assertBakedNormal } from './chunk-I4STYOD5.js';
-import { INFINITE_REPETITIONS, LoopMode, EndMode, createVATPlaybackTexture, PACK_TEXELS, RIG_TEXELS, RIG_TEXELS_PER_SLOT } from './chunk-BSAJL5PG.js';
+import { INFINITE_REPETITIONS, LoopMode, EndMode, createVATPlaybackTexture, PACK_TEXELS, RIG_TEXELS, vertexWidthOf, RIG_TEXELS_PER_SLOT } from './chunk-OEKKEHRQ.js';
 import { InstancedMesh } from 'three';
 import { uniform, Fn, positionLocal, normalLocal, tangentLocal, positionGeometry, batch, instancedMesh, float, bool, int, vertexIndex, attribute, mat3, tangentGeometry, normalGeometry, vec4, batchIndirectIndex, instanceIndex, hash, mix, textureLoad, ivec2, dot, mat4, vec3 } from 'three/tsl';
 
@@ -176,17 +176,34 @@ function octDecode(stored) {
   const back = (component) => component.sub(component.greaterThanEqual(0).select(overshoot, overshoot.negate()));
   return vec3(back(ex), back(ey), z).normalize();
 }
-function vertexDecode({ positionTexture, normalTexture }, rows) {
+function texelOf(vat, vertexRow) {
+  const { rowsPerFrame } = vat;
+  if (rowsPerFrame === 1) return { column: vertexRow, rowOf: (row) => row };
+  const width = int(vertexWidthOf(vat));
+  const line = vertexRow.div(width);
+  const spanned = /* @__PURE__ */ new Map();
+  return {
+    column: vertexRow.mod(width),
+    rowOf: (row) => {
+      let at = spanned.get(row);
+      if (!at) spanned.set(row, at = row.mul(int(rowsPerFrame)).add(line));
+      return at;
+    }
+  };
+}
+function vertexDecode(vat, rows) {
+  const { positionTexture, normalTexture } = vat;
   const vertexRow = int(vertexIndex);
+  const { column, rowOf } = texelOf(vat, vertexRow);
   const band = (tex, of) => {
-    const s0 = textureLoad(tex, ivec2(vertexRow, of.row0)).xyz;
-    const s1 = textureLoad(tex, ivec2(vertexRow, of.row1)).xyz;
+    const s0 = textureLoad(tex, ivec2(column, rowOf(of.row0))).xyz;
+    const s1 = textureLoad(tex, ivec2(column, rowOf(of.row1))).xyz;
     return mix(s0, s1, of.blend);
   };
   const sample = (tex) => mix(band(tex, rows.live), band(tex, rows.outgoing), rows.weight);
   const bandNormal = (tex, of) => {
-    const s0 = octDecode(textureLoad(tex, ivec2(vertexRow, of.row0)).xy);
-    const s1 = octDecode(textureLoad(tex, ivec2(vertexRow, of.row1)).xy);
+    const s0 = octDecode(textureLoad(tex, ivec2(column, rowOf(of.row0))).xy);
+    const s1 = octDecode(textureLoad(tex, ivec2(column, rowOf(of.row1))).xy);
     return mix(s0, s1, of.blend);
   };
   const sampleNormal = (tex) => mix(bandNormal(tex, rows.live), bandNormal(tex, rows.outgoing), rows.weight);

package/dist/webgl.d.ts

@@ -1,5 +1,5 @@
 import { IUniform, MeshDepthMaterial, WebGLRenderer, Material } from 'three';
-import { b as VATCarrier, V as VAT, k as VATPlaybackTexture, h as VATInstance, f as VATCrowd } from './carrier-D4pkftSk.js';
+import { b as VATCarrier, V as VAT, k as VATPlaybackTexture, h as VATInstance, f as VATCrowd } from './carrier-VLSJLgjX.js';
 
 /**
  * The real maximum texture dimension this GPU accepts, for

package/dist/webgl.js

@@ -1,5 +1,5 @@
 import { assertBakedNormal, assertVATCarrier, isBatchedCarrier } from './chunk-I4STYOD5.js';
-import { PACK_TEXELS, EndMode, LoopMode, RIG_TEXELS_PER_SLOT, RIG_TEXELS, INFINITE_REPETITIONS, createVATPlaybackTexture } from './chunk-BSAJL5PG.js';
+import { PACK_TEXELS, EndMode, LoopMode, RIG_TEXELS_PER_SLOT, RIG_TEXELS, INFINITE_REPETITIONS, createVATPlaybackTexture, vertexWidthOf } from './chunk-OEKKEHRQ.js';
 import { MeshDepthMaterial, RGBADepthPacking, InstancedMesh, MeshDistanceMaterial, Material } from 'three';
 
 function getMaxTextureSize(renderer) {
@@ -175,7 +175,13 @@ var ROW_PRELUDE = (
   }
 `
 );
-var VERTEX_PRELUDE = (
+function texelOf(vat) {
+  const { rowsPerFrame } = vat;
+  if (rowsPerFrame === 1) return (row) => `ivec2( gl_VertexID, ${row} )`;
+  const width = vertexWidthOf(vat);
+  return (row) => `ivec2( gl_VertexID % ${width}, ${row} * ${rowsPerFrame} + gl_VertexID / ${width} )`;
+}
+var vertexPrelude = (texel) => (
   /* glsl */
   `
   uniform highp sampler2D uVatPosTex;
@@ -184,8 +190,8 @@ var VERTEX_PRELUDE = (
   // mixed. The same function for the live band and the outgoing one, as
   // vatBand is the same function for both pairs.
   vec3 vatBandSample( const in sampler2D tex, const in VatBand band ) {
-    vec3 s0 = texelFetch( tex, ivec2( gl_VertexID, band.row0 ), 0 ).xyz;
-    vec3 s1 = texelFetch( tex, ivec2( gl_VertexID, band.row1 ), 0 ).xyz;
+    vec3 s0 = texelFetch( tex, ${texel("band.row0")}, 0 ).xyz;
+    vec3 s1 = texelFetch( tex, ${texel("band.row1")}, 0 ).xyz;
     return mix( s0, s1, band.blend );
   }
 
@@ -208,7 +214,7 @@ var VERTEX_PRELUDE = (
   }
 `
 );
-var NORMAL_PRELUDE = (
+var normalPrelude = (texel) => (
   /* glsl */
   `
   uniform highp sampler2D uVatNrmTex;
@@ -226,8 +232,8 @@ var NORMAL_PRELUDE = (
 
   // One band of the normal layer \u2014 vatBandSample, over decoded normals.
   vec3 vatBandSampleNormal( const in VatBand band ) {
-    vec3 s0 = vatOctDecode( texelFetch( uVatNrmTex, ivec2( gl_VertexID, band.row0 ), 0 ).xy );
-    vec3 s1 = vatOctDecode( texelFetch( uVatNrmTex, ivec2( gl_VertexID, band.row1 ), 0 ).xy );
+    vec3 s0 = vatOctDecode( texelFetch( uVatNrmTex, ${texel("band.row0")}, 0 ).xy );
+    vec3 s1 = vatOctDecode( texelFetch( uVatNrmTex, ${texel("band.row1")}, 0 ).xy );
     return mix( s0, s1, band.blend );
   }
 
@@ -379,9 +385,12 @@ var rigNormal = (id) => (
   #endif
 `
 );
-function vertexDecode({ positionTexture, normalTexture }, id) {
+function vertexDecode(vat, id) {
+  const { positionTexture, normalTexture, rowsPerFrame } = vat;
+  const texel = texelOf(vat);
+  const span = rowsPerFrame === 1 ? "" : `:rows${rowsPerFrame}x${vertexWidthOf(vat)}`;
   return {
-    prelude: (normalTexture ? NORMAL_PRELUDE : "") + VERTEX_PRELUDE,
+    prelude: (normalTexture ? normalPrelude(texel) : "") + vertexPrelude(texel),
     bind(uniforms) {
       uniforms.uVatPosTex = { value: positionTexture };
       if (normalTexture) uniforms.uVatNrmTex = { value: normalTexture };
@@ -394,7 +403,7 @@ function vertexDecode({ positionTexture, normalTexture }, id) {
     normal: normalTexture ? vertexNormal(id) : null,
     // A normal-less VAT injects a different vertex shader off the same material
     // parameters, so the variant is in the key (see `patchVATMaterial`).
-    key: `three-vat:${id}${normalTexture ? "" : ":no-normal"}`,
+    key: `three-vat:${id}${normalTexture ? "" : ":no-normal"}${span}`,
     instanceIndex: INSTANCE_ID[id]
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-vat",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "Bake glTF animation clips into vertex animation textures for zero-CPU instanced crowds in three.js.",
   "type": "module",
   "license": "MIT",