three-vat 2.0.0 → 2.1.0

package/dist/tsl.d.ts

@@ -1,5 +1,5 @@
 import { Node } from 'three/webgpu';
-import { d as VATClock, i as VATPlaybackTexture, a as VATCarrier, V as VAT, h as VATInstance, e as VATCrowd } from './carrier-BFCPmcQK.js';
+import { e as VATClock, j as VATPlaybackTexture, b as VATCarrier, V as VAT, i as VATInstance, f as VATCrowd } from './carrier-BXaLAPRO.js';
 import 'three';
 
 /**
@@ -48,14 +48,16 @@ interface VATNodeOptions {
      *
      * Required for a crowd, and for two reasons. First: three applies the
      * carrier's transform to `positionLocal` *before* it reads `positionNode`, so
-     * the decode has to displace in the geometry's own space and then re-apply
-     * that transform itself. Without this the delta is added in instance space —
-     * unrotated and unscaled — and every instance deforms according to its own
-     * matrix. Second: the carrier decides how this instance's *logical* index is
-     * spelled, which is the row of the playback texture the pack is read from —
-     * `instanceIndex` on an `InstancedMesh`, `batchIndirectIndex` on a
-     * `BatchedMesh`, whose drawn slot is a permutation that changes every frame
-     * (ADR-0016).
+     * the decode has to pose in the geometry's own space and then re-apply that
+     * transform itself. Without this the vertex encoding adds its delta in
+     * instance space — unrotated and unscaled — and every instance deforms
+     * according to its own matrix; the rig encoding, which skins the rest pose
+     * outright, never applies the instance matrix at all and draws the whole
+     * crowd at the origin. Second: the carrier decides how this instance's
+     * *logical* index is spelled, which is the row of the playback texture the
+     * pack is read from — `instanceIndex` on an `InstancedMesh`,
+     * `batchIndirectIndex` on a `BatchedMesh`, whose drawn slot is a permutation
+     * that changes every frame (ADR-0016).
      *
      * One option rather than one per carrier, because those two answers have to
      * come from the same object: a decode that re-applied one mesh's transform
@@ -82,17 +84,19 @@ interface VATNodeOptions {
 interface VATNodes {
     /**
      * Assign to `material.positionNode`. It carries the whole decode — the normal
-     * with it.
+     * with it, and the tangent under the rig encoding.
      *
-     * There is deliberately no `normalNode`. A material's `normalNode` is built in
-     * the *fragment* stage (three reaches it from `normalView` through
-     * `builder.context.setupNormal()`) and is expected in **view** space, whereas a
-     * VAT's baked normals are per-vertex and in the geometry's own space. Handing
-     * an object-space normal to a fragment-stage node skipped both the instance
-     * matrix and the normal matrix, and took `vertexIndex` into the fragment stage
-     * with it — where `IndexNode` does not give you the vertex index at all, but
-     * quietly turns itself into a varying, so every fragment read a linearly
-     * *interpolated* index that addresses neither of the vertices it lies between.
+     * There is deliberately no `normalNode`, under either encoding. A material's
+     * `normalNode` is built in the *fragment* stage (three reaches it from
+     * `normalView` through `builder.context.setupNormal()`) and is expected in
+     * **view** space, whereas a VAT's normals are per-vertex and in the geometry's
+     * own space — read from the normal texture, or skinned from the rig one.
+     * Handing an object-space normal to a fragment-stage node skipped both the
+     * instance matrix and the normal matrix, and took `vertexIndex` into the
+     * fragment stage with it — where `IndexNode` does not give you the vertex
+     * index at all, but quietly turns itself into a varying, so every fragment
+     * read a linearly *interpolated* index that addresses neither of the vertices
+     * it lies between.
      *
      * Writing `normalLocal` inside the vertex-stage decode instead is what the
      * GLSL path does when it sets `objectNormal` in `beginnormal_vertex`: three
@@ -118,9 +122,31 @@ interface VATNodes {
  */
 declare function vatNodes(vat: VAT, options?: VATNodeOptions): VATNodes;
 /**
- * The decode's arithmetic: the position delta and the normal this instance reads
- * at this moment, as nodes — before the vertex-stage writes that place them.
- * `normal` is `null` when the VAT was baked without a normal texture.
+ * What a decode hands the vertex stage, discriminated on the encoding it read
+ * (ADR-0018) — because the two encodings answer a different question. The
+ * vertex encoding reads where this vertex *moved to*: `position` is the delta
+ * to add to the rest position, `normal` the baked normal or `null` when the
+ * bake skipped it. The rig encoding *skins* the rest pose: `position` is the
+ * posed position itself, `normal` always exists because it comes out of the
+ * skin matrix, and so does `tangent` when the geometry carries one.
+ *
+ * @internal The return type of {@link vatDecode}, exported for the same
+ * structural tests and for nothing else.
+ */
+type VATDecoded = {
+    encoding: 'delta';
+    position: Vec3Node;
+    normal: Vec3Node | null;
+} | {
+    encoding: 'rig';
+    position: Vec3Node;
+    normal: Vec3Node;
+    tangent: Vec3Node | null;
+};
+/**
+ * The decode's arithmetic: what this instance reads at this moment, as nodes —
+ * before the vertex-stage writes that place it. See {@link VATDecoded} for what
+ * `position` means under each encoding.
  *
  * @internal Split out and exported for the structural tests. A `Fn` body is
  * opaque to graph traversal (its statements are not built until the shader is),
@@ -128,10 +154,7 @@ declare function vatNodes(vat: VAT, options?: VATNodeOptions): VATNodes;
  * so the arithmetic that matters stays reachable as a graph. Not re-exported
  * from `three-vat`; nothing outside this package should build against it.
  */
-declare function vatDecode(vat: VAT, options?: VATNodeOptions): {
-    position: Vec3Node;
-    normal: Vec3Node | null;
-};
+declare function vatDecode(vat: VAT, options?: VATNodeOptions): VATDecoded;
 /** Options for {@link createVATMesh}. */
 interface CreateVATMeshOptions {
     /**
@@ -173,4 +196,4 @@ interface CreateVATMeshOptions {
  */
 declare function createVATMesh(vat: VAT, instances: VATInstance[], options?: CreateVATMeshOptions): VATCrowd;
 
-export { type CreateVATMeshOptions, type VATNodeOptions, type VATNodes, type VATTimeUniform, createVATMesh, getMaxTextureSize, vatDecode, vatNodes };
+export { type CreateVATMeshOptions, type VATDecoded, type VATNodeOptions, type VATNodes, type VATTimeUniform, createVATMesh, getMaxTextureSize, vatDecode, vatNodes };

package/dist/tsl.js

@@ -1,7 +1,7 @@
-import { isBatchedCarrier, assertVATCarrier, assertBakedNormal } from './chunk-W2ZAFMPB.js';
-import { INFINITE_REPETITIONS, LoopMode, EndMode, createVATPlaybackTexture, PACK_TEXELS } from './chunk-2PGZ44TP.js';
+import { isBatchedCarrier, assertVATCarrier, assertBakedNormal } from './chunk-I4STYOD5.js';
+import { INFINITE_REPETITIONS, LoopMode, EndMode, createVATPlaybackTexture, PACK_TEXELS, RIG_TEXELS, RIG_TEXELS_PER_SLOT } from './chunk-3PWAY6MD.js';
 import { InstancedMesh } from 'three';
-import { uniform, Fn, positionLocal, positionGeometry, normalLocal, batch, instancedMesh, int, vertexIndex, float, bool, textureLoad, ivec2, mix, batchIndirectIndex, instanceIndex, hash } from 'three/tsl';
+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 } from 'three/tsl';
 
 function getMaxTextureSize(renderer) {
   const backend = renderer.backend;
@@ -65,10 +65,16 @@ function hashedPlayback(clip, desync, instance) {
 }
 function vatNodes(vat, options = {}) {
   const { time = uniform(0), carrier } = options;
-  const { position, normal } = vatDecode(vat, options);
+  const decoded = vatDecode(vat, options);
   const decode = Fn(() => {
-    positionLocal.assign((carrier ? positionGeometry : positionLocal).add(position));
-    if (normal) normalLocal.assign(normal);
+    if (decoded.encoding === "rig") {
+      positionLocal.assign(decoded.position);
+      normalLocal.assign(decoded.normal);
+      if (decoded.tangent) tangentLocal.assign(decoded.tangent);
+    } else {
+      positionLocal.assign((carrier ? positionGeometry : positionLocal).add(decoded.position));
+      if (decoded.normal) normalLocal.assign(decoded.normal);
+    }
     if (carrier) {
       if (isBatchedCarrier(carrier)) batch(carrier);
       else instancedMesh(carrier);
@@ -82,7 +88,6 @@ function vatDecode(vat, options = {}) {
   if (carrier) assertVATCarrier(carrier, vat);
   const instance = instanceIdOf(carrier);
   const playback = playbackTexture ? texturePlayback(playbackTexture.texture, instance) : hashedPlayback(clipAt(vat, clipIndex), desync, instance);
-  const vertexRow = int(vertexIndex);
   const frames = playback.frames;
   const last = frames.sub(1);
   const elapsed = time.sub(playback.startTime);
@@ -105,7 +110,7 @@ function vatDecode(vat, options = {}) {
   const f = phase.mul(wraps.select(frames, last));
   const f0 = f.floor().min(last);
   const f1 = wraps.select(f0.add(1).mod(frames), f0.add(1).min(last));
-  const frameMix = f.sub(f0);
+  const blend = f.sub(f0);
   const bandRow = (offset) => int(offset).add(playback.startFrame);
   const row0 = bandRow(f0);
   const row1 = bandRow(f1);
@@ -114,21 +119,96 @@ function vatDecode(vat, options = {}) {
     float(1).sub(elapsed.div(fade.duration).clamp(0, 1)),
     float(0)
   );
-  const frozenRow = int(fade.phase.mul(fade.frames).floor().min(fade.frames.sub(1)).max(0)).add(
+  const fadeRow = int(fade.phase.mul(fade.frames).floor().min(fade.frames.sub(1)).max(0)).add(
     int(fade.startFrame)
   );
+  const rows = { row0, row1, blend, fadeRow, fadeWeight };
+  switch (vat.encoding) {
+    case "delta":
+      return vertexDecode(vat, rows);
+    case "rig":
+      return rigDecode(vat, rows);
+    default: {
+      const unhandled = vat;
+      throw new Error(
+        `three-vat: vatDecode has no decode for encoding "${String(unhandled.encoding)}"`
+      );
+    }
+  }
+}
+function vertexDecode({ positionTexture, normalTexture }, rows) {
+  const vertexRow = int(vertexIndex);
   const sample = (tex) => {
-    const s0 = textureLoad(tex, ivec2(vertexRow, row0)).xyz;
-    const s1 = textureLoad(tex, ivec2(vertexRow, row1)).xyz;
-    const frozen = textureLoad(tex, ivec2(vertexRow, frozenRow)).xyz;
-    return mix(mix(s0, s1, frameMix), frozen, fadeWeight);
+    const s0 = textureLoad(tex, ivec2(vertexRow, rows.row0)).xyz;
+    const s1 = textureLoad(tex, ivec2(vertexRow, rows.row1)).xyz;
+    const frozen = textureLoad(tex, ivec2(vertexRow, rows.fadeRow)).xyz;
+    return mix(mix(s0, s1, rows.blend), frozen, rows.fadeWeight);
   };
-  const normalTexture = vat.normalTexture;
   return {
-    position: sample(vat.positionTexture),
+    encoding: "delta",
+    position: sample(positionTexture),
     normal: normalTexture ? sample(normalTexture).normalize() : null
   };
 }
+function compose(q, ts) {
+  const x = q.x;
+  const y = q.y;
+  const z = q.z;
+  const w = q.w;
+  const x2 = x.add(x);
+  const y2 = y.add(y);
+  const z2 = z.add(z);
+  const xx = x.mul(x2);
+  const xy = x.mul(y2);
+  const xz = x.mul(z2);
+  const yy = y.mul(y2);
+  const yz = y.mul(z2);
+  const zz = z.mul(z2);
+  const wx = w.mul(x2);
+  const wy = w.mul(y2);
+  const wz = w.mul(z2);
+  const s = ts.w;
+  const one = float(1);
+  return mat4(
+    vec4(one.sub(yy.add(zz)).mul(s), xy.add(wz).mul(s), xz.sub(wy).mul(s), 0),
+    vec4(xy.sub(wz).mul(s), one.sub(xx.add(zz)).mul(s), yz.add(wx).mul(s), 0),
+    vec4(xz.add(wy).mul(s), yz.sub(wx).mul(s), one.sub(xx.add(yy)).mul(s), 0),
+    vec4(ts.xyz, 1)
+  );
+}
+var hemisphereOf = (reference, q) => dot(reference, q).lessThan(0).select(q.negate(), q);
+function rigDecode({ rigTexture, geometry }, rows) {
+  const skinIndex = attribute("skinIndex", "uvec4");
+  const skinWeight = attribute("skinWeight", "vec4");
+  const fetch = (column, row) => textureLoad(rigTexture, ivec2(column, row));
+  const slot = (index, weight) => {
+    const column = (texel) => int(index).mul(RIG_TEXELS_PER_SLOT).add(texel);
+    const rotation = column(RIG_TEXELS.rotation);
+    const placement = column(RIG_TEXELS.placement);
+    const q0 = fetch(rotation, rows.row0);
+    const ts0 = fetch(placement, rows.row0);
+    const q1 = hemisphereOf(q0, fetch(rotation, rows.row1));
+    const ts1 = fetch(placement, rows.row1);
+    const q = mix(q0, q1, rows.blend).normalize();
+    const ts = mix(ts0, ts1, rows.blend);
+    const qf = hemisphereOf(q, fetch(rotation, rows.fadeRow));
+    const tsf = fetch(placement, rows.fadeRow);
+    const qFaded = mix(q, qf, rows.fadeWeight).normalize();
+    const tsFaded = mix(ts, tsf, rows.fadeWeight);
+    return compose(qFaded, tsFaded).mul(weight);
+  };
+  const skin = slot(skinIndex.x, skinWeight.x).add(slot(skinIndex.y, skinWeight.y)).add(slot(skinIndex.z, skinWeight.z)).add(slot(skinIndex.w, skinWeight.w));
+  const skin3 = mat3(skin);
+  return {
+    encoding: "rig",
+    position: skin.mul(vec4(positionGeometry, 1)).xyz,
+    normal: skin3.mul(normalGeometry).normalize(),
+    // Gated on the geometry rather than read and ignored: `tangentGeometry`
+    // is an attribute read, and three computes tangents onto a geometry that
+    // has none the moment a graph asks for them.
+    tangent: geometry.hasAttribute("tangent") ? skin3.mul(tangentGeometry.xyz).normalize() : null
+  };
+}
 function createVATMesh(vat, instances, options = {}) {
   const time = options.time ?? uniform(0);
   const playback = createVATPlaybackTexture(instances);

package/dist/webgl.d.ts

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

package/dist/webgl.js

@@ -1,5 +1,5 @@
-import { assertBakedNormal, assertVATCarrier, isBatchedCarrier } from './chunk-W2ZAFMPB.js';
-import { PACK_TEXELS, EndMode, LoopMode, INFINITE_REPETITIONS, createVATPlaybackTexture } from './chunk-2PGZ44TP.js';
+import { assertBakedNormal, assertVATCarrier, isBatchedCarrier } from './chunk-I4STYOD5.js';
+import { PACK_TEXELS, EndMode, LoopMode, RIG_TEXELS_PER_SLOT, RIG_TEXELS, INFINITE_REPETITIONS, createVATPlaybackTexture } from './chunk-3PWAY6MD.js';
 import { MeshDepthMaterial, RGBADepthPacking, InstancedMesh, MeshDistanceMaterial } from 'three';
 
 function getMaxTextureSize(renderer) {
@@ -9,13 +9,24 @@ function createVATUniforms(time = 0) {
   return { uVatTime: { value: time } };
 }
 var glslFloat = (n) => n.toFixed(1);
-var DECODE_PRELUDE = (
+var ROW_PRELUDE = (
   /* glsl */
   `
-  uniform highp sampler2D uVatPosTex;
   uniform highp sampler2D uVatPlaybackTex;
   uniform float uVatTime;
-  vec3 vatSample( const in sampler2D tex, const in int vatInstance ) {
+
+  // Where an instance is reading: the two rows of its band it sits between and
+  // the blend toward the second; and the pose-freeze fade's frozen row and
+  // weight, a weight of zero being "not fading".
+  struct VatRows {
+    int row0;
+    int row1;
+    float blend;
+    int fadeRow;
+    float fadeWeight;
+  };
+
+  VatRows vatRows( const in int vatInstance ) {
     // The pack, fetched by this instance's *logical* index rather than read
     // off an attribute indexed by the drawn slot (ADR-0016). Three texels of
     // one row, in the order src/instance-playback.ts lays them out; the
@@ -72,19 +83,42 @@ var DECODE_PRELUDE = (
     float f = phase * ( wraps ? frames : last );
     float f0 = min( floor( f ), last );
     float f1 = wraps ? mod( f0 + 1.0, frames ) : min( f0 + 1.0, last );
-    vec3 s0 = texelFetch( tex, ivec2( gl_VertexID, int( vatClip.x + f0 ) ), 0 ).xyz;
-    vec3 s1 = texelFetch( tex, ivec2( gl_VertexID, int( vatClip.x + f1 ) ), 0 ).xyz;
-    vec3 sampled = mix( s0, s1, f - f0 );
+
+    VatRows rows;
+    rows.row0 = int( vatClip.x + f0 );
+    rows.row1 = int( vatClip.x + f1 );
+    rows.blend = f - f0;
 
     // The pose-freeze fade, transcribed from the same resolver: one frozen row
     // of the clip this instance was playing when it changed, blended away over
     // vatFade.w. Wall clock, not clip time \u2014 the incoming clip's speed does
     // not stretch a fade. A duration of zero is what "not fading" is, and the
     // pack never writes one without a band to go with it.
+    rows.fadeRow = 0;
+    rows.fadeWeight = 0.0;
     if ( vatFade.w > 0.0 ) {
       float weight = 1.0 - clamp( ( uVatTime - vatPlayback.x ) / vatFade.w, 0.0, 1.0 );
       float fromRow = max( min( floor( vatFade.z * vatFade.y ), vatFade.y - 1.0 ), 0.0 );
-      vec3 frozen = texelFetch( tex, ivec2( gl_VertexID, int( vatFade.x + fromRow ) ), 0 ).xyz;
+      rows.fadeRow = int( vatFade.x + fromRow );
+      rows.fadeWeight = weight;
+    }
+    return rows;
+  }
+`
+);
+var VERTEX_PRELUDE = (
+  /* glsl */
+  `
+  uniform highp sampler2D uVatPosTex;
+  vec3 vatSample( const in sampler2D tex, const in int vatInstance ) {
+    VatRows rows = vatRows( vatInstance );
+    vec3 s0 = texelFetch( tex, ivec2( gl_VertexID, rows.row0 ), 0 ).xyz;
+    vec3 s1 = texelFetch( tex, ivec2( gl_VertexID, rows.row1 ), 0 ).xyz;
+    vec3 sampled = mix( s0, s1, rows.blend );
+    // The frozen row, blended in by the weight the rows resolved.
+    float weight = rows.fadeWeight;
+    if ( weight > 0.0 ) {
+      vec3 frozen = texelFetch( tex, ivec2( gl_VertexID, rows.fadeRow ), 0 ).xyz;
       sampled = mix( sampled, frozen, weight );
     }
     return sampled;
@@ -97,17 +131,88 @@ var NORMAL_PRELUDE = (
   uniform highp sampler2D uVatNrmTex;
 `
 );
+var RIG_PRELUDE = (
+  /* glsl */
+  `
+  uniform highp sampler2D uVatRigTex;
+  attribute vec4 skinIndex;
+  attribute vec4 skinWeight;
+
+  // Matrix4.compose, component for component: a rotation, a translation and
+  // one scale back to the matrix the skinning wants \u2014 so both encodings feed
+  // the same linear blend, and a rig crowd deforms as its vertex bake does.
+  mat4 vatCompose( const in vec4 q, const in vec4 ts ) {
+    float x2 = q.x + q.x, y2 = q.y + q.y, z2 = q.z + q.z;
+    float xx = q.x * x2, xy = q.x * y2, xz = q.x * z2;
+    float yy = q.y * y2, yz = q.y * z2, zz = q.z * z2;
+    float wx = q.w * x2, wy = q.w * y2, wz = q.w * z2;
+    float s = ts.w;
+    return mat4(
+      vec4( ( 1.0 - ( yy + zz ) ) * s, ( xy + wz ) * s, ( xz - wy ) * s, 0.0 ),
+      vec4( ( xy - wz ) * s, ( 1.0 - ( xx + zz ) ) * s, ( yz + wx ) * s, 0.0 ),
+      vec4( ( xz + wy ) * s, ( yz - wx ) * s, ( 1.0 - ( xx + yy ) ) * s, 0.0 ),
+      vec4( ts.xyz, 1.0 )
+    );
+  }
+
+  // One slot's matrix between the two rows the instance sits between \u2014 and
+  // through the fade, blended before it is composed.
+  mat4 vatSlot( const in int slot, const in VatRows rows ) {
+    int rotation = slot * ${RIG_TEXELS_PER_SLOT} + ${RIG_TEXELS.rotation};
+    int placement = slot * ${RIG_TEXELS_PER_SLOT} + ${RIG_TEXELS.placement};
+    vec4 q0 = texelFetch( uVatRigTex, ivec2( rotation, rows.row0 ), 0 );
+    vec4 ts0 = texelFetch( uVatRigTex, ivec2( placement, rows.row0 ), 0 );
+    vec4 q1 = texelFetch( uVatRigTex, ivec2( rotation, rows.row1 ), 0 );
+    vec4 ts1 = texelFetch( uVatRigTex, ivec2( placement, rows.row1 ), 0 );
+    // The bake keeps consecutive rows on one hemisphere, but a looping clip
+    // blends its band's last row into its first, and a bone that turned a full
+    // circle over the clip arrives there on the far side: one dot product per
+    // slot, or the blend passes through zero on the wrap frame.
+    if ( dot( q0, q1 ) < 0.0 ) q1 = -q1;
+    // A normalised lerp, not a slerp: at a bake's frame step the angular error
+    // against a true slerp is far below anything visible. It is still a
+    // *rotation* at every blend, which is what a componentwise matrix lerp is
+    // not \u2014 that one shortens a limb as it turns (ADR-0018).
+    vec4 q = normalize( mix( q0, q1, rows.blend ) );
+    vec4 ts = mix( ts0, ts1, rows.blend );
+    if ( rows.fadeWeight > 0.0 ) {
+      vec4 qf = texelFetch( uVatRigTex, ivec2( rotation, rows.fadeRow ), 0 );
+      vec4 tsf = texelFetch( uVatRigTex, ivec2( placement, rows.fadeRow ), 0 );
+      // The frozen row is any row of the bake, not this row's neighbour, so
+      // the same check.
+      if ( dot( q, qf ) < 0.0 ) qf = -qf;
+      q = normalize( mix( q, qf, rows.fadeWeight ) );
+      ts = mix( ts, tsf, rows.fadeWeight );
+    }
+    return vatCompose( q, ts );
+  }
+
+  // Linear blend skinning: the weighted sum of slot matrices, which is the
+  // blend the bake did on the CPU for the bounds and three's own
+  // skinning_vertex does on the GPU. A zero weight skips its four fetches.
+  mat4 vatSkinMatrix( const in int vatInstance ) {
+    VatRows rows = vatRows( vatInstance );
+    mat4 skin = mat4( 0.0 );
+    for ( int i = 0; i < 4; i ++ ) {
+      float w = skinWeight[ i ];
+      if ( w == 0.0 ) continue;
+      skin += w * vatSlot( int( skinIndex[ i ] ), rows );
+    }
+    return skin;
+  }
+`
+);
 var INSTANCE_ID = {
   instance: "gl_InstanceID",
   batch: "int( getIndirectIndex( gl_DrawID ) )"
 };
-var decodePosition = (id) => (
+var vertexPosition = (id) => (
   /* glsl */
   `
   vec3 transformed = position + vatSample( uVatPosTex, ${INSTANCE_ID[id]} );
 `
 );
-var decodeNormal = (id) => (
+var vertexNormal = (id) => (
   /* glsl */
   `
   vec3 objectNormal = normalize( vatSample( uVatNrmTex, ${INSTANCE_ID[id]} ) );
@@ -116,24 +221,77 @@ var decodeNormal = (id) => (
   #endif
 `
 );
+var rigPosition = (id) => (
+  /* glsl */
+  `
+  mat4 vatSkin = vatSkinMatrix( ${INSTANCE_ID[id]} );
+  vec3 transformed = ( vatSkin * vec4( position, 1.0 ) ).xyz;
+`
+);
+var rigNormal = (id) => (
+  /* glsl */
+  `
+  mat4 vatSkinN = vatSkinMatrix( ${INSTANCE_ID[id]} );
+  vec3 objectNormal = normalize( mat3( vatSkinN ) * normal );
+  #ifdef USE_TANGENT
+    vec3 objectTangent = normalize( mat3( vatSkinN ) * tangent.xyz );
+  #endif
+`
+);
+function vertexDecode({ positionTexture, normalTexture }, id) {
+  return {
+    prelude: (normalTexture ? NORMAL_PRELUDE : "") + VERTEX_PRELUDE,
+    bind(uniforms) {
+      uniforms.uVatPosTex = { value: positionTexture };
+      if (normalTexture) uniforms.uVatNrmTex = { value: normalTexture };
+    },
+    inject(vertexShader) {
+      const positioned = vertexShader.replace("#include <begin_vertex>", vertexPosition(id));
+      return normalTexture ? positioned.replace("#include <beginnormal_vertex>", vertexNormal(id)) : positioned;
+    },
+    // 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"}`
+  };
+}
+function rigDecode({ rigTexture }, id) {
+  return {
+    prelude: RIG_PRELUDE,
+    bind(uniforms) {
+      uniforms.uVatRigTex = { value: rigTexture };
+    },
+    inject(vertexShader) {
+      return vertexShader.replace("#include <begin_vertex>", rigPosition(id)).replace("#include <beginnormal_vertex>", rigNormal(id));
+    },
+    key: `three-vat:rig:${id}`
+  };
+}
+function decodeFor(vat, id) {
+  switch (vat.encoding) {
+    case "delta":
+      return vertexDecode(vat, id);
+    case "rig":
+      return rigDecode(vat, id);
+    default: {
+      const unhandled = vat;
+      throw new Error(
+        `three-vat: patchVATMaterial has no decode for encoding "${String(unhandled.encoding)}"`
+      );
+    }
+  }
+}
 function patchVATMaterial(material, vat, uniforms, playback, carrier) {
   assertBakedNormal(vat, material);
   if (carrier) assertVATCarrier(carrier, vat);
-  const normalTexture = vat.normalTexture;
   const id = isBatchedCarrier(carrier) ? "batch" : "instance";
+  const decode = decodeFor(vat, id);
   material.onBeforeCompile = (shader) => {
-    shader.uniforms.uVatPosTex = { value: vat.positionTexture };
     shader.uniforms.uVatPlaybackTex = { value: playback.texture };
     shader.uniforms.uVatTime = uniforms.uVatTime;
-    let vertexShader = shader.vertexShader.replace("#include <begin_vertex>", decodePosition(id));
-    if (normalTexture) {
-      shader.uniforms.uVatNrmTex = { value: normalTexture };
-      vertexShader = vertexShader.replace("#include <beginnormal_vertex>", decodeNormal(id));
-    }
-    shader.vertexShader = (normalTexture ? NORMAL_PRELUDE : "") + DECODE_PRELUDE + vertexShader;
+    decode.bind(shader.uniforms);
+    shader.vertexShader = ROW_PRELUDE + decode.prelude + decode.inject(shader.vertexShader);
   };
-  const key = `three-vat:${id}${normalTexture ? "" : ":no-normal"}`;
-  material.customProgramCacheKey = () => key;
+  material.customProgramCacheKey = () => decode.key;
   guardCarrierMismatch(material, id);
   return material;
 }

package/package.json

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