three-vat 2.0.0 → 3.0.0

package/dist/webgl.js

@@ -1,6 +1,6 @@
-import { assertBakedNormal, assertVATCarrier, isBatchedCarrier } from './chunk-W2ZAFMPB.js';
-import { PACK_TEXELS, EndMode, LoopMode, INFINITE_REPETITIONS, createVATPlaybackTexture } from './chunk-2PGZ44TP.js';
-import { MeshDepthMaterial, RGBADepthPacking, InstancedMesh, MeshDistanceMaterial } from 'three';
+import { assertBakedNormal, assertVATCarrier, isBatchedCarrier } from './chunk-I4STYOD5.js';
+import { PACK_TEXELS, EndMode, LoopMode, RIG_TEXELS_PER_SLOT, RIG_TEXELS, INFINITE_REPETITIONS, createVATPlaybackTexture } from './chunk-J5IEUGSB.js';
+import { MeshDepthMaterial, RGBADepthPacking, InstancedMesh, MeshDistanceMaterial, Material } from 'three';
 
 function getMaxTextureSize(renderer) {
   return renderer.capabilities.maxTextureSize;
@@ -9,35 +9,45 @@ 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 ) {
-    // 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
-    // arithmetic below is untouched by where they came from, because the pack
-    // was already three vec4s.
-    //
-    // The index arrives as a parameter rather than being read here, because
-    // where it comes from is the carrier's business and not the decode's:
-    // gl_InstanceID on an InstancedMesh, getIndirectIndex( gl_DrawID ) on a
-    // BatchedMesh \u2014 see INSTANCE_ID in src/webgl.ts. It also has to be a
-    // parameter: getIndirectIndex is declared by batching_pars_vertex, which
-    // three expands *after* this prelude, so naming it up here would not
-    // compile.
-    //
-    // Fetched inside the function, so each injection point stays
-    // self-contained (ADR-0006) \u2014 which costs a second set of fetches in the
-    // normal decode. Every vertex of an instance reads the same three texels,
-    // so the texture cache absorbs them; the 5% demo bench is what says so.
-    vec4 vatClip     = texelFetch( uVatPlaybackTex, ivec2( ${PACK_TEXELS.clip}, vatInstance ), 0 );
-    vec4 vatPlayback = texelFetch( uVatPlaybackTex, ivec2( ${PACK_TEXELS.playback}, vatInstance ), 0 );
-    vec4 vatFade     = texelFetch( uVatPlaybackTex, ivec2( ${PACK_TEXELS.fade}, vatInstance ), 0 );
 
+  // One band resolved: the two rows an instance sits between and the blend
+  // toward the second, plus the two facts those rows cannot be read back out
+  // of \u2014 whether the sampling wrapped past the band's last row into its first,
+  // and whether the repetitions have run out.
+  struct VatBand {
+    int row0;
+    int row1;
+    float blend;
+    bool wraps;
+    bool finished;
+  };
+
+  // Where an instance is reading: the band it is playing, and how much of the
+  // band it is leaving still shows \u2014 a weight of zero being "not
+  // transitioning".
+  //
+  // The outgoing band is *not* a field here. Each sampler resolves it for
+  // itself, because what it costs to resolve is not the same on the two
+  // encodings and #72 measured the difference: see vatOutgoingBand below.
+  struct VatRows {
+    VatBand live;
+    float weight;
+  };
+
+  // resolveVATFrame for one (clip texel, playback texel) pair, branch for
+  // branch: not started, finished, ping-pong, repeat \u2014 the resolver's own
+  // order, each case falling out into the shared phase-to-row arithmetic below
+  // rather than returning early, so all of them land on the same two rows.
+  //
+  // A function of the pair rather than of the instance, because the pair is
+  // what there are two of: a crossfading instance resolves its outgoing band
+  // by calling this a second time, not by transcribing it a second time.
+  VatBand vatBand( const in vec4 vatClip, const in vec4 vatPlayback ) {
     float frames = vatClip.y;
     float last = frames - 1.0;
     float duration = frames / vatClip.z;
@@ -72,22 +82,120 @@ 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 );
-
-    // 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.
-    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;
-      sampled = mix( sampled, frozen, weight );
+
+    VatBand band;
+    band.row0 = int( vatClip.x + f0 );
+    band.row1 = int( vatClip.x + f1 );
+    band.blend = f - f0;
+    band.wraps = wraps;
+    band.finished = finished;
+    return band;
+  }
+
+  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
+    // arithmetic above is untouched by where they came from, because the pack
+    // was already three vec4s.
+    //
+    // The index arrives as a parameter rather than being read here, because
+    // where it comes from is the carrier's business and not the decode's:
+    // gl_InstanceID on an InstancedMesh, getIndirectIndex( gl_DrawID ) on a
+    // BatchedMesh \u2014 see INSTANCE_ID in src/webgl.ts. It also has to be a
+    // parameter: getIndirectIndex is declared by batching_pars_vertex, which
+    // three expands *after* this prelude, so naming it up here would not
+    // compile.
+    //
+    // Fetched inside the function, so each injection point stays
+    // self-contained (ADR-0006) \u2014 which costs a second set of fetches in the
+    // normal decode. Every vertex of an instance reads the same texels of the
+    // same row, whichever branch it takes, so the texture cache absorbs them;
+    // the demo bench under ADR-0016's 5% bound is what said so for three of
+    // them, and ADR-0025's is what says so for a transitioning instance's five.
+    //
+    // Three texels, always \u2014 the crossfade one sits third exactly so that an
+    // instance that is not transitioning reads what it has always read.
+    vec4 vatClip      = texelFetch( uVatPlaybackTex, ivec2( ${PACK_TEXELS.clip}, vatInstance ), 0 );
+    vec4 vatPlayback  = texelFetch( uVatPlaybackTex, ivec2( ${PACK_TEXELS.playback}, vatInstance ), 0 );
+    vec4 vatCrossfade = texelFetch( uVatPlaybackTex, ivec2( ${PACK_TEXELS.crossfade}, vatInstance ), 0 );
+
+    VatRows rows;
+    // The live band: the one clip this instance is playing, resolved from its
+    // own pair of texels.
+    rows.live = vatBand( vatClip, vatPlayback );
+
+    // The crossfade's weight, transcribed from the resolver: wall clock, not
+    // clip time \u2014 the incoming clip's speed does not stretch a transition \u2014 and
+    // a duration of zero is what a cut is, which is what the pack writes when
+    // there is no band to blend away.
+    rows.weight = 0.0;
+    if ( vatCrossfade.x > 0.0 ) {
+      rows.weight = 1.0 - clamp( ( uVatTime - vatPlayback.x ) / vatCrossfade.x, 0.0, 1.0 );
     }
-    return sampled;
+
+    return rows;
+  }
+
+  // The band the instance is leaving: two more texels and a second call of the
+  // very same resolver, so the clip it is leaving keeps playing \u2014 keeping its
+  // own speed and its own end policy \u2014 rather than standing still (ADR-0025).
+  //
+  // While the weight is zero the pair selected *is* the live pair, so the two
+  // fetches land on texels this vertex has already read and the band resolves
+  // to the one it is playing. That is what lets a caller resolve it without a
+  // branch, and blending a pose into itself is what a weight of zero means.
+  //
+  // Selecting the live pair is also why this needs no counterpart to the TSL
+  // path's max-of-one on the outgoing frames and fps (src/tsl.ts): that path
+  // resolves a band from the zeroes "not transitioning" is written as, which is
+  // a 0/0 duration and a NaN row. The pair selected here is always real.
+  //
+  // Whether the instance is transitioning is the parameter, not the weight, so
+  // the caller is the one that says so \u2014 and the two encodings say it from
+  // different places (#72): the vertex sampler calls this unconditionally,
+  // because guarding two texel fetches cost an idle crowd 10%; the rig sampler
+  // calls it unconditionally too but guards what it *does* with the band, where
+  // what a guard skips is sixteen dependent fetches per vertex.
+  VatBand vatOutgoingBand( const in int vatInstance, const in bool transitioning ) {
+    int clipX     = transitioning ? ${PACK_TEXELS.outgoingClip} : ${PACK_TEXELS.clip};
+    int playbackX = transitioning ? ${PACK_TEXELS.outgoingPlayback} : ${PACK_TEXELS.playback};
+    vec4 vatOutClip     = texelFetch( uVatPlaybackTex, ivec2( clipX, vatInstance ), 0 );
+    vec4 vatOutPlayback = texelFetch( uVatPlaybackTex, ivec2( playbackX, vatInstance ), 0 );
+    return vatBand( vatOutClip, vatOutPlayback );
+  }
+`
+);
+var VERTEX_PRELUDE = (
+  /* glsl */
+  `
+  uniform highp sampler2D uVatPosTex;
+
+  // One band of one layer: the two rows this band sits between, 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;
+    return mix( s0, s1, band.blend );
+  }
+
+  vec3 vatSample( const in sampler2D tex, const in int vatInstance ) {
+    VatRows rows = vatRows( vatInstance );
+    // The outgoing band \u2014 still playing, two rows of its own \u2014 mixed in by the
+    // weight the rows resolved, and mixed in *unconditionally*: at a weight of
+    // zero the band resolved is the live one, so this blends a pose into
+    // itself. The normal layer is renormalised by the caller after the mix, as
+    // it is for a single band.
+    //
+    // No branch, and that is measured rather than reasoned (#72): here the
+    // outgoing band is two more fetches of one layer, and guarding them cost an
+    // idle crowd 10% where paying them costs nothing measurable \u2014 0.283 ms
+    // against the 0.282 ms it cost before the crossfade existed. A branch is
+    // not free because it is not taken: the compiler still holds registers for
+    // the side it skips, and that is what an idle crowd was paying for.
+    VatBand outgoing = vatOutgoingBand( vatInstance, rows.weight > 0.0 );
+    return mix( vatBandSample( tex, rows.live ), vatBandSample( tex, outgoing ), rows.weight );
   }
 `
 );
@@ -97,17 +205,119 @@ 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 of the posed rig, at one band: a rotation and a placement, each
+  // between the two rows that band sits between. The same function for the live
+  // band and the outgoing one, as vatBand is the same function for both pairs.
+  struct VatPose {
+    vec4 q;
+    vec4 ts;
+  };
+
+  VatPose vatSlotPose( const in int rotation, const in int placement, const in VatBand band ) {
+    vec4 q0 = texelFetch( uVatRigTex, ivec2( rotation, band.row0 ), 0 );
+    vec4 ts0 = texelFetch( uVatRigTex, ivec2( placement, band.row0 ), 0 );
+    vec4 q1 = texelFetch( uVatRigTex, ivec2( rotation, band.row1 ), 0 );
+    vec4 ts1 = texelFetch( uVatRigTex, ivec2( placement, band.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;
+    VatPose pose;
+    // 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).
+    pose.q = normalize( mix( q0, q1, band.blend ) );
+    pose.ts = mix( ts0, ts1, band.blend );
+    return pose;
+  }
+
+  // One slot's matrix: its pose in the band the instance is playing and, while
+  // it is transitioning, its pose in the band it is leaving \u2014 blended per slot
+  // before the matrix is composed, so the crowd skins from one rig rather than
+  // from the average of two matrices.
+  //
+  // The guard stays here, where the vertex sampler dropped its own. What it
+  // skips is four dependent fetches of the rig texture per slot, sixteen per
+  // vertex, against the two of one layer the vertex encoding skips \u2014 and #72
+  // measured it worth keeping: this encoding did not get slower when the
+  // crossfade landed, and the vertex encoding did.
+  mat4 vatSlot( const in int slot, const in VatRows rows, const in VatBand outgoing ) {
+    int rotation = slot * ${RIG_TEXELS_PER_SLOT} + ${RIG_TEXELS.rotation};
+    int placement = slot * ${RIG_TEXELS_PER_SLOT} + ${RIG_TEXELS.placement};
+    VatPose pose = vatSlotPose( rotation, placement, rows.live );
+    vec4 q = pose.q;
+    vec4 ts = pose.ts;
+    if ( rows.weight > 0.0 ) {
+      VatPose leaving = vatSlotPose( rotation, placement, outgoing );
+      vec4 qo = leaving.q;
+      // The outgoing band is any row of the bake, not this row's neighbour, so
+      // the same check.
+      if ( dot( q, qo ) < 0.0 ) qo = -qo;
+      q = normalize( mix( q, qo, rows.weight ) );
+      ts = mix( ts, leaving.ts, rows.weight );
+    }
+    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.
+  //
+  // The band being left is resolved once for the vertex rather than once per
+  // slot, and unconditionally \u2014 two pack texels this encoding's old guard
+  // skipped, against the sixteen rig fetches per vertex the guard inside
+  // vatSlot still skips. At a weight of zero those two land on texels already
+  // read, and every slot below skips the pose.
+  mat4 vatSkinMatrix( const in int vatInstance ) {
+    VatRows rows = vatRows( vatInstance );
+    VatBand outgoing = vatOutgoingBand( vatInstance, rows.weight > 0.0 );
+    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, outgoing );
+    }
+    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,23 +326,122 @@ var decodeNormal = (id) => (
   #endif
 `
 );
-function patchVATMaterial(material, vat, uniforms, playback, carrier) {
+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 };
+    },
+    position: vertexPosition(id),
+    // No normal texture, no normal decode, and no uniform bound for one: the
+    // material either does not read a normal or derives it from the deformed
+    // position itself (`flatShading`), so three's own `beginnormal_vertex` is
+    // left exactly where it is.
+    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"}`,
+    instanceIndex: INSTANCE_ID[id]
+  };
+}
+function rigDecode({ rigTexture }, id) {
+  return {
+    prelude: RIG_PRELUDE,
+    bind(uniforms) {
+      uniforms.uVatRigTex = { value: rigTexture };
+    },
+    position: rigPosition(id),
+    normal: rigNormal(id),
+    key: `three-vat:rig:${id}`,
+    instanceIndex: INSTANCE_ID[id]
+  };
+}
+function patchOptionsOf(fifth) {
+  if (!fifth) return {};
+  return fifth.isObject3D ? { carrier: fifth } : fifth;
+}
+function assertHook(hook) {
+  if (!hook.key.trim()) {
+    throw new Error(
+      "three-vat: a post-decode hook needs a non-empty `key`. It is folded into the library\u2019s own program cache key, and two hooks that fold in nothing share a compiled program \u2014 so one crowd renders the other\u2019s GLSL."
+    );
+  }
+  if (!hook.position && !hook.normal) {
+    throw new Error(
+      "three-vat: a post-decode hook with neither `position` nor `normal` injects nothing. Give it the chunk you meant \u2014 `position` deforms the posed vertex, `normal` repairs the normal that was taken before it, and a deformation wants both."
+    );
+  }
+}
+var hookChunk = (chunk, instanceIndex) => chunk ? (
+  /* glsl */
+  `
+  {
+    int vatInstanceIndex = ${instanceIndex};
+${chunk}
+  }
+`
+) : "";
+function injectVAT(vertexShader, decode, hook) {
+  const position = decode.position + hookChunk(hook?.position, decode.instanceIndex);
+  const normal = (decode.normal ?? "#include <beginnormal_vertex>") + hookChunk(hook?.normal, decode.instanceIndex);
+  return vertexShader.replace("#include <begin_vertex>", () => position).replace("#include <beginnormal_vertex>", () => normal);
+}
+var VAT_PATCHES = /* @__PURE__ */ new WeakSet();
+var ours = (onBeforeCompile) => onBeforeCompile === Material.prototype.onBeforeCompile || VAT_PATCHES.has(onBeforeCompile);
+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, options) {
+  const { carrier, hook } = patchOptionsOf(options);
   assertBakedNormal(vat, material);
   if (carrier) assertVATCarrier(carrier, vat);
-  const normalTexture = vat.normalTexture;
+  if (hook) assertHook(hook);
   const id = isBatchedCarrier(carrier) ? "batch" : "instance";
-  material.onBeforeCompile = (shader) => {
-    shader.uniforms.uVatPosTex = { value: vat.positionTexture };
+  const decode = decodeFor(vat, id);
+  const previous = ours(material.onBeforeCompile) ? null : material.onBeforeCompile.bind(material);
+  const patch = (shader, renderer) => {
+    previous?.(shader, renderer);
+    if (hook?.uniforms) Object.assign(shader.uniforms, hook.uniforms);
     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 + // Ahead of three's shader, where a declaration is safe from a dead block.
+    (hook?.prelude ? `
+${hook.prelude}
+` : "") + injectVAT(shader.vertexShader, decode, hook);
   };
-  const key = `three-vat:${id}${normalTexture ? "" : ":no-normal"}`;
+  material.onBeforeCompile = patch;
+  VAT_PATCHES.add(patch);
+  const key = hook ? `${decode.key}+${hook.key}` : decode.key;
   material.customProgramCacheKey = () => key;
   guardCarrierMismatch(material, id);
   return material;
@@ -157,18 +466,19 @@ var CARRIER_NAME = {
   instance: "an InstancedMesh",
   batch: "a BatchedMesh"
 };
-function createVATDepthMaterial(vat, uniforms, playback, carrier) {
+function createVATDepthMaterial(vat, uniforms, playback, options) {
   const depth = new MeshDepthMaterial({ depthPacking: RGBADepthPacking });
-  patchVATMaterial(depth, vat, uniforms, playback, carrier);
+  patchVATMaterial(depth, vat, uniforms, playback, options);
   return depth;
 }
 function createVATMesh(vat, instances, options = {}) {
   const uniforms = options.time ? { uVatTime: options.time } : createVATUniforms();
   const playback = createVATPlaybackTexture(instances);
-  const materials = vat.materials.map((source) => patchVATMaterial(source.clone(), vat, uniforms, playback));
+  const patch = { hook: options.hook };
+  const materials = vat.materials.map((source) => patchVATMaterial(source.clone(), vat, uniforms, playback, patch));
   const mesh = new InstancedMesh(vat.geometry, materials, instances.length);
-  mesh.customDepthMaterial = createVATDepthMaterial(vat, uniforms, playback);
-  mesh.customDistanceMaterial = patchVATMaterial(new MeshDistanceMaterial(), vat, uniforms, playback);
+  mesh.customDepthMaterial = createVATDepthMaterial(vat, uniforms, playback, patch);
+  mesh.customDistanceMaterial = patchVATMaterial(new MeshDistanceMaterial(), vat, uniforms, playback, patch);
   return { mesh, time: uniforms.uVatTime, playback };
 }
 

package/package.json

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