@needle-tools/three-animation-pointer 1.1.0 → 1.1.2

package/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [1.1.2] - 2026-06-17
+- Fix: don't mutate the `KHR_animation_pointer.pointer` value in `parser.json`. The resolved three.js property path is now kept in plugin-local state, so other plugins / app code can still read the original spec-defined pointer after load — by @0b5vr in [#2](https://github.com/needle-tools/three-animation-pointer/pull/2)
+
+## [1.1.1] - 2026-06-12
+- Fix: morph target (blend shape) weight animation was silently dropped for multi-material meshes without skin/bones. The multi-material morph branch only bound children that were `SkinnedMesh`; such meshes load as a `Group` of plain `Mesh` children, so no track was created (and the empty-but-truthy result skipped the fallback). Now any child with `morphTargetInfluences` is bound.
+
 ## [1.1.0] - 2026-06-01
 - Add: support for `/nodes/{}/weights/{}` to animate individual morph target weights (works with multi-material meshes / primitives) — by @0b5vr in [#1](https://github.com/needle-tools/three-animation-pointer/pull/1)
 

package/README.md

@@ -6,6 +6,7 @@ This package adds a [three.js](https://github.com/mrdoob/three.js) GLTFLoader pl
 - all material properties 💎 (including texture transforms) 
 - cameras 🎥
 - lights 💡
+- morph target weights 😀 (all weights or individual ones via `/nodes/{}/weights/{}`)
 - custom code/scripts 📄
 
 

package/dist/three-animation-pointer.js

@@ -1,20 +1,20 @@
-import { SkinnedMesh as S, InterpolateDiscrete as w, InterpolateLinear as F, AnimationClip as M, PropertyBinding as C, QuaternionKeyframeTrack as W, ColorKeyframeTrack as B, VectorKeyframeTrack as D, BooleanKeyframeTrack as E, NumberKeyframeTrack as O } from "three";
-const d = {
+import { InterpolateDiscrete as M, InterpolateLinear as F, AnimationClip as w, PropertyBinding as C, QuaternionKeyframeTrack as S, ColorKeyframeTrack as W, VectorKeyframeTrack as B, BooleanKeyframeTrack as D, NumberKeyframeTrack as E } from "three";
+const k = {
   node: "node",
   material: "material",
   camera: "camera",
   light: "light"
-}, y = "KHR_animation_pointer", U = {
+}, R = "KHR_animation_pointer", O = {
   // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
   // keyframe track will be initialized with a default interpolation type, then modified.
   CUBICSPLINE: void 0,
   LINEAR: F,
-  STEP: w
+  STEP: M
 };
-class G {
+class z {
   /** @type {import("three/examples/jsm/loaders/GLTFLoader").GLTFParser} */
   constructor(a) {
-    this.name = y, this.parser = a, this.animationPointerResolver = null;
+    this.name = R, this.parser = a, this.animationPointerResolver = null, this.pointerPathMap = /* @__PURE__ */ new Map();
   }
   /** 
    * @param {import("..").AnimationPointerResolver | null} animationPointerResolver
@@ -24,30 +24,30 @@ class G {
   }
   /* DUPLICATE of functionality in GLTFLoader */
   loadAnimationTargetFromChannel(a) {
-    const t = a.target, r = t.node !== void 0 ? t.node : t.id;
+    const s = a.target, r = s.node !== void 0 ? s.node : s.id;
     return this.parser.getDependency("node", r);
   }
   loadAnimationTargetFromChannelWithAnimationPointer(a) {
-    var m;
-    j();
-    const t = a.target, r = t.extensions && t.extensions[y] && t.path && t.path === "pointer";
+    var o;
+    L();
+    const s = a.target, r = s.extensions && s.extensions[R] && s.path && s.path === "pointer";
     if (!r) return null;
-    let e, n = d.node, s;
+    let e, t = k.node, n;
     if (r) {
-      const h = t.extensions[y];
-      let o = h.pointer;
-      if (!o) {
-        console.warn("Invalid path", h, t);
+      const m = s.extensions[R];
+      let i = m.pointer;
+      if (!i) {
+        console.warn("Invalid path", m, s);
         return;
       }
-      if (o.startsWith("/materials/") ? n = d.material : o.startsWith("/extensions/KHR_lights_punctual/lights/") ? n = d.light : o.startsWith("/cameras/") && (n = d.camera), s = this._tryResolveTargetId(o, n), s === null || isNaN(s)) {
-        console.warn("Failed resolving animation node id: " + s, o);
+      if (i.startsWith("/materials/") ? t = k.material : i.startsWith("/extensions/KHR_lights_punctual/lights/") ? t = k.light : i.startsWith("/cameras/") && (t = k.camera), n = this._tryResolveTargetId(i, t), n === null || isNaN(n)) {
+        console.warn("Failed resolving animation node id: " + n, i);
         return;
       }
-      switch (n) {
-        case d.material:
-          const T = ("/materials/" + s.toString() + "/").length, g = o.substring(0, T);
-          switch (e = o.substring(T), e) {
+      switch (t) {
+        case k.material:
+          const h = ("/materials/" + n.toString() + "/").length, y = i.substring(0, h);
+          switch (e = i.substring(h), e) {
             case "pbrMetallicRoughness/baseColorFactor":
               e = "color";
               break;
@@ -130,13 +130,13 @@ class G {
               e = "specularColor";
               break;
           }
-          o = g + e;
+          i = y + e;
           break;
-        case d.node:
-          const _ = ("/nodes/" + s.toString() + "/").length, b = o.substring(0, _);
-          if (e = o.substring(_), e.startsWith("weights/")) {
-            const f = e.substring(8);
-            /^\d+$/.test(f) ? e = "morphTargetInfluences[" + f + "]" : console.warn(y + ": invalid weight index", e, o);
+        case k.node:
+          const f = ("/nodes/" + n.toString() + "/").length, d = i.substring(0, f);
+          if (e = i.substring(f), e.startsWith("weights/")) {
+            const l = e.substring(8);
+            /^\d+$/.test(l) ? e = "morphTargetInfluences[" + l + "]" : console.warn(R + ": invalid weight index", e, i);
           } else
             switch (e) {
               case "translation":
@@ -155,11 +155,11 @@ class G {
                 e = "visible";
                 break;
             }
-          o = b + e;
+          i = d + e;
           break;
-        case d.light:
-          const u = ("/extensions/KHR_lights_punctual/lights/" + s.toString() + "/").length;
-          switch (e = o.substring(u), e) {
+        case k.light:
+          const p = ("/extensions/KHR_lights_punctual/lights/" + n.toString() + "/").length;
+          switch (e = i.substring(p), e) {
             case "color":
               break;
             case "intensity":
@@ -174,11 +174,11 @@ class G {
               e = "distance";
               break;
           }
-          o = "/lights/" + s.toString() + "/" + e;
+          i = "/lights/" + n.toString() + "/" + e;
           break;
-        case d.camera:
-          const l = ("/cameras/" + s.toString() + "/").length, k = o.substring(0, l);
-          switch (e = o.substring(l), e) {
+        case k.camera:
+          const c = ("/cameras/" + n.toString() + "/").length, b = i.substring(0, c);
+          switch (e = i.substring(c), e) {
             case "perspective/yfov":
               e = "fov";
               break;
@@ -200,91 +200,94 @@ class G {
               e = "zoom";
               break;
           }
-          o = k + e;
+          i = b + e;
           break;
       }
-      (m = this.animationPointerResolver) != null && m.resolvePath && (o = this.animationPointerResolver.resolvePath(o)), t.extensions[y].pointer = o;
+      (o = this.animationPointerResolver) != null && o.resolvePath && (i = this.animationPointerResolver.resolvePath(i));
+      const v = m.pointer;
+      this.pointerPathMap.set(v, i);
     }
-    if (s == null || isNaN(s)) {
-      console.warn("Failed resolving animation node id: " + s, t);
+    if (n == null || isNaN(n)) {
+      console.warn("Failed resolving animation node id: " + n, s);
       return;
     }
-    let i;
-    return n === d.node ? i = this.parser.getDependency("node", s) : n === d.material ? i = this.parser.getDependency("material", s) : n === d.light ? i = this.parser.getDependency("light", s) : n === d.camera ? i = this.parser.getDependency("camera", s) : console.error("Unhandled type", n), i;
+    let u;
+    return t === k.node ? u = this.parser.getDependency("node", n) : t === k.material ? u = this.parser.getDependency("material", n) : t === k.light ? u = this.parser.getDependency("light", n) : t === k.camera ? u = this.parser.getDependency("camera", n) : console.error("Unhandled type", t), u;
   }
-  createAnimationTracksWithAnimationPointer(a, t, r, e, n) {
-    var b;
-    if (!(n.extensions && n.extensions[y] && n.path && n.path === "pointer")) return null;
-    let i = n.extensions[y].pointer;
-    if (!i) return null;
+  createAnimationTracksWithAnimationPointer(a, s, r, e, t) {
+    var d;
+    if (!(t.extensions && t.extensions[R] && t.path && t.path === "pointer")) return null;
+    const u = t.extensions[R].pointer;
+    let o = this.pointerPathMap.get(u);
+    if (!o) return null;
     const m = [];
-    i = i.replaceAll("/", ".");
-    const h = i.split(".");
-    var T = a.name !== void 0 && a.name !== null ? a.name : a.uuid;
-    if (h[2] = T, (b = h[3]) != null && b.startsWith("morphTargetInfluences")) {
-      const u = h[3];
+    o = o.replaceAll("/", ".");
+    const i = o.split(".");
+    var h = a.name !== void 0 && a.name !== null ? a.name : a.uuid;
+    if (i[2] = h, (d = i[3]) != null && d.startsWith("morphTargetInfluences")) {
+      const p = i[3];
       if (a.type === "Group") {
-        for (const l of a.children)
-          l instanceof S && l.morphTargetInfluences && (h[3] = l.name, h[4] = u, _(this.parser));
+        for (const c of a.children)
+          c.morphTargetInfluences && (i[3] = c.name, i[4] = p, f(this.parser));
         return m;
       }
     }
-    _(this.parser);
-    function g(u, l) {
+    f(this.parser);
+    function y(p, c) {
       try {
-        const k = l.split(".").filter(Boolean), c = k[k.length - 1].replace(/\[.*\]$/, "");
-        return c in u ? typeof u[c] == "boolean" : !1;
+        const b = c.split(".").filter(Boolean), g = b[b.length - 1].replace(/\[.*\]$/, "");
+        return g in p ? typeof p[g] == "boolean" : !1;
       } catch {
         return !1;
       }
     }
-    function _(u) {
-      i = h.join(".");
-      let l, k = !1;
+    function f(p) {
+      o = i.join(".");
+      let c, b = !1;
       switch (r.itemSize) {
         case 1:
           Object.prototype.toString.call(r.array) === "[object Uint8Array]" && // UNSIGNED_BYTE as a strong hint
-          g(a, i) ? (l = E, k = !0) : l = O;
+          y(a, o) ? (c = D, b = !0) : c = E;
           break;
         case 2:
         case 3:
-          l = D;
+          c = B;
           break;
         case 4:
-          i.endsWith(".quaternion") ? l = W : l = B;
+          o.endsWith(".quaternion") ? c = S : c = W;
           break;
       }
-      if (!l) {
+      if (!c) {
         console.warn("Unsupported output accessor format", r);
         return;
       }
-      const f = e.interpolation !== void 0 ? U[e.interpolation] : F;
-      let c = u._getArrayFromAccessor(r);
-      i.endsWith(".fov") && (c = c.map((p) => p / Math.PI * 180)), k && (c = c.map((p) => p > 0));
-      const R = new l(
-        i,
-        t.array,
-        c,
-        f
+      const l = e.interpolation !== void 0 ? O[e.interpolation] : F;
+      let g = p._getArrayFromAccessor(r);
+      o.endsWith(".fov") && (g = g.map((x) => x / Math.PI * 180)), b && (g = g.map((x) => x > 0));
+      const _ = new c(
+        o,
+        s.array,
+        g,
+        l
       );
-      if (f === "CUBICSPLINE" && u._createCubicSplineTrackInterpolant(R), m.push(R), i && r.itemSize === 4 && i.startsWith(".materials.") && i.endsWith(".color")) {
-        const p = new Float32Array(c.length / 4);
-        for (let x = 0, A = c.length / 4; x < A; x += 1)
-          p[x] = c[x * 4 + 3];
-        const v = new l(
-          i.replace(".color", ".opacity"),
-          t.array,
-          p,
-          f
+      if (l === "CUBICSPLINE" && p._createCubicSplineTrackInterpolant(_), m.push(_), o && r.itemSize === 4 && o.startsWith(".materials.") && o.endsWith(".color")) {
+        const x = new Float32Array(g.length / 4);
+        for (let T = 0, K = g.length / 4; T < K; T += 1)
+          x[T] = g[T * 4 + 3];
+        const I = new c(
+          o.replace(".color", ".opacity"),
+          s.array,
+          x,
+          l
         );
-        f === "CUBICSPLINE" && u._createCubicSplineTrackInterpolant(R), m.push(v);
+        l === "CUBICSPLINE" && p._createCubicSplineTrackInterpolant(_), m.push(I);
       }
     }
     return m;
   }
-  _tryResolveTargetId(a, t) {
+  _tryResolveTargetId(a, s) {
     let r = "";
-    return t === "node" ? r = a.substring(7) : t === "material" ? r = a.substring(11) : t === "light" ? r = a.substring(39) : t === "camera" && (r = a.substring(9)), r = r.substring(0, r.indexOf("/")), Number.parseInt(r);
+    return s === "node" ? r = a.substring(7) : s === "material" ? r = a.substring(11) : s === "light" ? r = a.substring(39) : s === "camera" && (r = a.substring(9)), r = r.substring(0, r.indexOf("/")), Number.parseInt(r);
   }
   /* MOSTLY DUPLICATE of GLTFLoader.loadAnimation, but also tries to resolve KHR_animation_pointer. */
   /**
@@ -293,72 +296,72 @@ class G {
    * @return {Promise<AnimationClip>}
    */
   loadAnimation(a) {
-    const t = this, r = this.parser.json, e = this.parser, n = r.animations[a], s = n.name ? n.name : "animation_" + a, i = [], m = [], h = [], o = [], T = [];
-    for (let g = 0, _ = n.channels.length; g < _; g++) {
-      const b = n.channels[g], u = n.samplers[b.sampler], l = b.target, k = n.parameters !== void 0 ? n.parameters[u.input] : u.input, f = n.parameters !== void 0 ? n.parameters[u.output] : u.output;
-      let c = t.loadAnimationTargetFromChannelWithAnimationPointer(b);
-      c || (c = t.loadAnimationTargetFromChannel(b)), i.push(c), m.push(e.getDependency("accessor", k)), h.push(e.getDependency("accessor", f)), o.push(u), T.push(l);
+    const s = this, r = this.parser.json, e = this.parser, t = r.animations[a], n = t.name ? t.name : "animation_" + a, u = [], o = [], m = [], i = [], v = [];
+    for (let h = 0, y = t.channels.length; h < y; h++) {
+      const f = t.channels[h], d = t.samplers[f.sampler], p = f.target, c = t.parameters !== void 0 ? t.parameters[d.input] : d.input, b = t.parameters !== void 0 ? t.parameters[d.output] : d.output;
+      let l = s.loadAnimationTargetFromChannelWithAnimationPointer(f);
+      l || (l = s.loadAnimationTargetFromChannel(f)), u.push(l), o.push(e.getDependency("accessor", c)), m.push(e.getDependency("accessor", b)), i.push(d), v.push(p);
     }
     return Promise.all([
-      Promise.all(i),
-      Promise.all(m),
-      Promise.all(h),
+      Promise.all(u),
       Promise.all(o),
-      Promise.all(T)
-    ]).then(function(g) {
-      const _ = g[0], b = g[1], u = g[2], l = g[3], k = g[4], f = [];
-      for (let c = 0, R = _.length; c < R; c++) {
-        const p = _[c], v = b[c], x = u[c], A = l[c], N = k[c];
-        if (p === void 0) continue;
-        p.updateMatrix && (p.updateMatrix(), p.matrixAutoUpdate = !0);
-        let I = t.createAnimationTracksWithAnimationPointer(p, v, x, A, N);
-        if (I || (I = e._createAnimationTracks(p, v, x, A, N)), I)
-          for (let K = 0; K < I.length; K++)
-            f.push(I[K]);
+      Promise.all(m),
+      Promise.all(i),
+      Promise.all(v)
+    ]).then(function(h) {
+      const y = h[0], f = h[1], d = h[2], p = h[3], c = h[4], b = [];
+      for (let l = 0, g = y.length; l < g; l++) {
+        const _ = y[l], x = f[l], I = d[l], T = p[l], K = c[l];
+        if (_ === void 0) continue;
+        _.updateMatrix && (_.updateMatrix(), _.matrixAutoUpdate = !0);
+        let P = s.createAnimationTracksWithAnimationPointer(_, x, I, T, K);
+        if (P || (P = e._createAnimationTracks(_, x, I, T, K)), P)
+          for (let N = 0; N < P.length; N++)
+            b.push(P[N]);
       }
-      return new M(s, void 0, f);
+      return new w(n, void 0, b);
     });
   }
 }
-let H = !1, L = null;
-function j() {
+let H = !1, U = null;
+function L() {
   if (H) return;
   H = !0;
-  const P = L || (L = C.findNode);
-  C.findNode = function(a, t) {
-    if (!t) return P(a, t);
-    if (t.startsWith(".materials.")) {
-      const r = t.substring(11).substring(t.indexOf(".")), e = r.indexOf("."), n = e < 0 ? r : r.substring(0, e);
-      let s = null;
-      return a.traverse((i) => {
-        s !== null || i.type !== "Mesh" && i.type !== "SkinnedMesh" || i.material && (i.material.uuid === n || i.material.name === n) && (s = i.material, s !== null && (r.endsWith(".map") ? s = s.map : r.endsWith(".emissiveMap") && (s = s.emissiveMap)));
-      }), s;
-    } else if (t.startsWith(".nodes.") || t.startsWith(".lights.") || t.startsWith(".cameras.")) {
-      const r = t.split(".");
+  const A = U || (U = C.findNode);
+  C.findNode = function(a, s) {
+    if (!s) return A(a, s);
+    if (s.startsWith(".materials.")) {
+      const r = s.substring(11).substring(s.indexOf(".")), e = r.indexOf("."), t = e < 0 ? r : r.substring(0, e);
+      let n = null;
+      return a.traverse((u) => {
+        n !== null || u.type !== "Mesh" && u.type !== "SkinnedMesh" || u.material && (u.material.uuid === t || u.material.name === t) && (n = u.material, n !== null && (r.endsWith(".map") ? n = n.map : r.endsWith(".emissiveMap") && (n = n.emissiveMap)));
+      }), n;
+    } else if (s.startsWith(".nodes.") || s.startsWith(".lights.") || s.startsWith(".cameras.")) {
+      const r = s.split(".");
       let e;
-      for (let n = 1; n < r.length; n++) {
-        const s = r[n];
-        if (s.length == 36)
-          e = a.getObjectByProperty("uuid", s);
-        else if (e && e[s]) {
-          const m = Number.parseInt(s);
-          let h = s;
-          m >= 0 && (h = m), e = e[h];
+      for (let t = 1; t < r.length; t++) {
+        const n = r[t];
+        if (n.length == 36)
+          e = a.getObjectByProperty("uuid", n);
+        else if (e && e[n]) {
+          const o = Number.parseInt(n);
+          let m = n;
+          o >= 0 && (m = o), e = e[m];
         } else {
-          const m = a.getObjectByName(s);
-          m && (e = m);
+          const o = a.getObjectByName(n);
+          o && (e = o);
         }
       }
       if (!e) {
-        const n = P(a, r[2]);
-        return n || console.warn(y + ": Property binding not found", t, a, a.name, r), n;
+        const t = A(a, r[2]);
+        return t || console.warn(R + ": Property binding not found", s, a, a.name, r), t;
       }
       return e;
     }
-    return P(a, t);
+    return A(a, s);
   };
 }
 export {
-  G as GLTFAnimationPointerExtension,
-  G as default
+  z as GLTFAnimationPointerExtension,
+  z as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@needle-tools/three-animation-pointer",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "KHR_animation_pointer support for three.js",
   "type": "module",
   "main": "dist/three-animation-pointer.js",
@@ -46,4 +46,4 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   }
-}
+}

package/src/GLTFLoaderAnimationPointer.js

@@ -7,7 +7,6 @@ import {
 	PropertyBinding,
 	QuaternionKeyframeTrack,
 	VectorKeyframeTrack,
-	SkinnedMesh,
 	BooleanKeyframeTrack
 } from 'three';
 
@@ -55,6 +54,12 @@ export class GLTFAnimationPointerExtension {
 		/** @type {import("..").AnimationPointerResolver | null} */
 		this.animationPointerResolver = null;
 
+		/**
+		 * @type {Map<string, string>}
+		 * Maps from original pointer paths to resolved three.js property paths.
+		 */
+		this.pointerPathMap = new Map();
+
 	}
 
 	/** 
@@ -352,7 +357,8 @@ export class GLTFAnimationPointerExtension {
 
 			}
 
-			target.extensions[ KHR_ANIMATION_POINTER ].pointer = path;
+			const pointer = ext.pointer;
+			this.pointerPathMap.set( pointer, path );
 
 		}
 
@@ -385,7 +391,8 @@ export class GLTFAnimationPointerExtension {
 		const useExtension = target.extensions && target.extensions[ KHR_ANIMATION_POINTER ] && target.path && target.path === 'pointer';
 		if ( ! useExtension ) return null;
 
-		let animationPointerPropertyPath = target.extensions[ KHR_ANIMATION_POINTER ].pointer;
+		const pointer = target.extensions[ KHR_ANIMATION_POINTER ].pointer;
+		let animationPointerPropertyPath = this.pointerPathMap.get( pointer );
 		if ( ! animationPointerPropertyPath ) return null;
 
 		const tracks = [];
@@ -408,12 +415,13 @@ export class GLTFAnimationPointerExtension {
 			if ( node.type === 'Group' ) {
 
 				if ( _animationPointerDebug )
-					console.log( 'Detected multi-material skinnedMesh export', animationPointerPropertyPath, node );
+					console.log( 'Detected multi-material mesh export', animationPointerPropertyPath, node );
 
-				// We assume the children are skinned meshes
+				// Bind any child that has morph influences. The children may be plain
+				// Mesh (no skin/bones) or SkinnedMesh, so we must not require SkinnedMesh.
 				for ( const ch of node.children ) {
 
-					if ( ch instanceof SkinnedMesh && ch.morphTargetInfluences ) {
+					if ( ch.morphTargetInfluences ) {
 
 						parts[ 3 ] = ch.name;
 						parts[ 4 ] = property;
@@ -810,4 +818,4 @@ function _ensurePropertyBindingPatch() {
 
 	};
 
-}
+}