@needle-tools/three-animation-pointer 1.0.7 → 1.1.1

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.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)
+
 ## [1.0.7] - 2025-10-20
 - Fix: missing "extensions" in KHR_node_visibility  
 

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 M, InterpolateLinear as F, AnimationClip as W, PropertyBinding as C, QuaternionKeyframeTrack as w, ColorKeyframeTrack as B, VectorKeyframeTrack as D, BooleanKeyframeTrack as E, NumberKeyframeTrack as O } from "three";
+import { InterpolateDiscrete as w, InterpolateLinear as F, AnimationClip as S, PropertyBinding as C, QuaternionKeyframeTrack as M, ColorKeyframeTrack as W, VectorKeyframeTrack as B, BooleanKeyframeTrack as D, NumberKeyframeTrack as E } from "three";
 const d = {
   node: "node",
   material: "material",
   camera: "camera",
   light: "light"
-}, R = "KHR_animation_pointer", U = {
+}, y = "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: M
+  STEP: w
 };
-class G {
+class z {
   /** @type {import("three/examples/jsm/loaders/GLTFLoader").GLTFParser} */
   constructor(a) {
-    this.name = R, this.parser = a, this.animationPointerResolver = null;
+    this.name = y, this.parser = a, this.animationPointerResolver = null;
   }
   /** 
    * @param {import("..").AnimationPointerResolver | null} animationPointerResolver
@@ -28,25 +28,25 @@ class G {
     return this.parser.getDependency("node", r);
   }
   loadAnimationTargetFromChannelWithAnimationPointer(a) {
-    var u;
-    j();
-    const t = a.target, r = t.extensions && t.extensions[R] && t.path && t.path === "pointer";
+    var m;
+    L();
+    const t = a.target, r = t.extensions && t.extensions[y] && t.path && t.path === "pointer";
     if (!r) return null;
-    let e, n = d.node, s;
+    let e, s = d.node, n;
     if (r) {
-      const h = t.extensions[R];
+      const h = t.extensions[y];
       let o = h.pointer;
       if (!o) {
         console.warn("Invalid path", h, t);
         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 (o.startsWith("/materials/") ? s = d.material : o.startsWith("/extensions/KHR_lights_punctual/lights/") ? s = d.light : o.startsWith("/cameras/") && (s = d.camera), n = this._tryResolveTargetId(o, s), n === null || isNaN(n)) {
+        console.warn("Failed resolving animation node id: " + n, o);
         return;
       }
-      switch (n) {
+      switch (s) {
         case d.material:
-          const T = ("/materials/" + s.toString() + "/").length, f = o.substring(0, T);
+          const T = ("/materials/" + n.toString() + "/").length, g = o.substring(0, T);
           switch (e = o.substring(T), e) {
             case "pbrMetallicRoughness/baseColorFactor":
               e = "color";
@@ -130,32 +130,36 @@ class G {
               e = "specularColor";
               break;
           }
-          o = f + e;
+          o = g + e;
           break;
         case d.node:
-          const k = ("/nodes/" + s.toString() + "/").length, l = o.substring(0, k);
-          switch (e = o.substring(k), e) {
-            case "translation":
-              e = "position";
-              break;
-            case "rotation":
-              e = "quaternion";
-              break;
-            case "scale":
-              e = "scale";
-              break;
-            case "weights":
-              e = "morphTargetInfluences";
-              break;
-            case "extensions/KHR_node_visibility/visible":
-              e = "visible";
-              break;
-          }
-          o = l + e;
+          const _ = ("/nodes/" + n.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);
+          } else
+            switch (e) {
+              case "translation":
+                e = "position";
+                break;
+              case "rotation":
+                e = "quaternion";
+                break;
+              case "scale":
+                e = "scale";
+                break;
+              case "weights":
+                e = "morphTargetInfluences";
+                break;
+              case "extensions/KHR_node_visibility/visible":
+                e = "visible";
+                break;
+            }
+          o = b + e;
           break;
         case d.light:
-          const c = ("/extensions/KHR_lights_punctual/lights/" + s.toString() + "/").length;
-          switch (e = o.substring(c), e) {
+          const u = ("/extensions/KHR_lights_punctual/lights/" + n.toString() + "/").length;
+          switch (e = o.substring(u), e) {
             case "color":
               break;
             case "intensity":
@@ -170,11 +174,11 @@ class G {
               e = "distance";
               break;
           }
-          o = "/lights/" + s.toString() + "/" + e;
+          o = "/lights/" + n.toString() + "/" + e;
           break;
         case d.camera:
-          const g = ("/cameras/" + s.toString() + "/").length, b = o.substring(0, g);
-          switch (e = o.substring(g), e) {
+          const l = ("/cameras/" + n.toString() + "/").length, k = o.substring(0, l);
+          switch (e = o.substring(l), e) {
             case "perspective/yfov":
               e = "fov";
               break;
@@ -196,83 +200,87 @@ class G {
               e = "zoom";
               break;
           }
-          o = b + e;
+          o = k + e;
           break;
       }
-      (u = this.animationPointerResolver) != null && u.resolvePath && (o = this.animationPointerResolver.resolvePath(o)), t.extensions[R].pointer = o;
+      (m = this.animationPointerResolver) != null && m.resolvePath && (o = this.animationPointerResolver.resolvePath(o)), t.extensions[y].pointer = o;
     }
-    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, t);
       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;
+    return s === d.node ? i = this.parser.getDependency("node", n) : s === d.material ? i = this.parser.getDependency("material", n) : s === d.light ? i = this.parser.getDependency("light", n) : s === d.camera ? i = this.parser.getDependency("camera", n) : console.error("Unhandled type", s), i;
   }
-  createAnimationTracksWithAnimationPointer(a, t, r, e, n) {
-    if (!(n.extensions && n.extensions[R] && n.path && n.path === "pointer")) return null;
-    let i = n.extensions[R].pointer;
+  createAnimationTracksWithAnimationPointer(a, t, r, e, s) {
+    var b;
+    if (!(s.extensions && s.extensions[y] && s.path && s.path === "pointer")) return null;
+    let i = s.extensions[y].pointer;
     if (!i) return null;
-    const u = [];
+    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, h[3] === "morphTargetInfluences" && a.type === "Group") {
-      for (const l of a.children)
-        l instanceof S && l.morphTargetInfluences && (h[3] = l.name, h[4] = "morphTargetInfluences", k(this.parser));
-      return u;
+    if (h[2] = T, (b = h[3]) != null && b.startsWith("morphTargetInfluences")) {
+      const u = h[3];
+      if (a.type === "Group") {
+        for (const l of a.children)
+          l.morphTargetInfluences && (h[3] = l.name, h[4] = u, _(this.parser));
+        return m;
+      }
     }
-    k(this.parser);
-    function f(l, c) {
+    _(this.parser);
+    function g(u, l) {
       try {
-        const g = c.split(".").filter(Boolean), m = g[g.length - 1].replace(/\[.*\]$/, "");
-        return m in l ? typeof l[m] == "boolean" : !1;
+        const k = l.split(".").filter(Boolean), c = k[k.length - 1].replace(/\[.*\]$/, "");
+        return c in u ? typeof u[c] == "boolean" : !1;
       } catch {
         return !1;
       }
     }
-    function k(l) {
+    function _(u) {
       i = h.join(".");
-      let c, g = !1;
+      let l, k = !1;
       switch (r.itemSize) {
         case 1:
           Object.prototype.toString.call(r.array) === "[object Uint8Array]" && // UNSIGNED_BYTE as a strong hint
-          f(a, i) ? (c = E, g = !0) : c = O;
+          g(a, i) ? (l = D, k = !0) : l = E;
           break;
         case 2:
         case 3:
-          c = D;
+          l = B;
           break;
         case 4:
-          i.endsWith(".quaternion") ? c = w : c = B;
+          i.endsWith(".quaternion") ? l = M : l = W;
           break;
       }
-      if (!c) {
+      if (!l) {
         console.warn("Unsupported output accessor format", r);
         return;
       }
-      const b = e.interpolation !== void 0 ? U[e.interpolation] : F;
-      let m = l._getArrayFromAccessor(r);
-      i.endsWith(".fov") && (m = m.map((_) => _ / Math.PI * 180)), g && (m = m.map((_) => _ > 0));
-      const p = new c(
+      const f = e.interpolation !== void 0 ? O[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,
-        m,
-        b
+        c,
+        f
       );
-      if (b === "CUBICSPLINE" && l._createCubicSplineTrackInterpolant(p), u.push(p), i && r.itemSize === 4 && i.startsWith(".materials.") && i.endsWith(".color")) {
-        const _ = new Float32Array(m.length / 4);
-        for (let y = 0, P = m.length / 4; y < P; y += 1)
-          _[y] = m[y * 4 + 3];
-        const x = new c(
+      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,
-          _,
-          b
+          p,
+          f
         );
-        b === "CUBICSPLINE" && l._createCubicSplineTrackInterpolant(p), u.push(x);
+        f === "CUBICSPLINE" && u._createCubicSplineTrackInterpolant(R), m.push(v);
       }
     }
-    return u;
+    return m;
   }
   _tryResolveTargetId(a, t) {
     let r = "";
@@ -285,72 +293,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 = [], u = [], h = [], o = [], T = [];
-    for (let f = 0, k = n.channels.length; f < k; f++) {
-      const l = n.channels[f], c = n.samplers[l.sampler], g = l.target, b = n.parameters !== void 0 ? n.parameters[c.input] : c.input, m = n.parameters !== void 0 ? n.parameters[c.output] : c.output;
-      let p = t.loadAnimationTargetFromChannelWithAnimationPointer(l);
-      p || (p = t.loadAnimationTargetFromChannel(l)), i.push(p), u.push(e.getDependency("accessor", b)), h.push(e.getDependency("accessor", m)), o.push(c), T.push(g);
+    const t = this, r = this.parser.json, e = this.parser, s = r.animations[a], n = s.name ? s.name : "animation_" + a, i = [], m = [], h = [], o = [], T = [];
+    for (let g = 0, _ = s.channels.length; g < _; g++) {
+      const b = s.channels[g], u = s.samplers[b.sampler], l = b.target, k = s.parameters !== void 0 ? s.parameters[u.input] : u.input, f = s.parameters !== void 0 ? s.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);
     }
     return Promise.all([
       Promise.all(i),
-      Promise.all(u),
+      Promise.all(m),
       Promise.all(h),
       Promise.all(o),
       Promise.all(T)
-    ]).then(function(f) {
-      const k = f[0], l = f[1], c = f[2], g = f[3], b = f[4], m = [];
-      for (let p = 0, _ = k.length; p < _; p++) {
-        const x = k[p], y = l[p], P = c[p], K = g[p], N = b[p];
-        if (x === void 0) continue;
-        x.updateMatrix && (x.updateMatrix(), x.matrixAutoUpdate = !0);
-        let v = t.createAnimationTracksWithAnimationPointer(x, y, P, K, N);
-        if (v || (v = e._createAnimationTracks(x, y, P, K, N)), v)
-          for (let A = 0; A < v.length; A++)
-            m.push(v[A]);
+    ]).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]);
       }
-      return new W(s, void 0, m);
+      return new S(n, void 0, f);
     });
   }
 }
-let H = !1, L = null;
-function j() {
+let H = !1, U = null;
+function L() {
   if (H) return;
   H = !0;
-  const I = L || (L = C.findNode);
+  const P = U || (U = C.findNode);
   C.findNode = function(a, t) {
-    if (!t) return I(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;
+      const r = t.substring(11).substring(t.indexOf(".")), e = r.indexOf("."), s = e < 0 ? r : r.substring(0, e);
+      let n = 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;
+        n !== null || i.type !== "Mesh" && i.type !== "SkinnedMesh" || i.material && (i.material.uuid === s || i.material.name === s) && (n = i.material, n !== null && (r.endsWith(".map") ? n = n.map : r.endsWith(".emissiveMap") && (n = n.emissiveMap)));
+      }), n;
     } else if (t.startsWith(".nodes.") || t.startsWith(".lights.") || t.startsWith(".cameras.")) {
       const r = t.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 u = Number.parseInt(s);
-          let h = s;
-          u >= 0 && (h = u), e = e[h];
+      for (let s = 1; s < r.length; s++) {
+        const n = r[s];
+        if (n.length == 36)
+          e = a.getObjectByProperty("uuid", n);
+        else if (e && e[n]) {
+          const m = Number.parseInt(n);
+          let h = n;
+          m >= 0 && (h = m), e = e[h];
         } else {
-          const u = a.getObjectByName(s);
-          u && (e = u);
+          const m = a.getObjectByName(n);
+          m && (e = m);
         }
       }
       if (!e) {
-        const n = I(a, r[2]);
-        return n || console.warn(R + ": Property binding not found", t, a, a.name, r), n;
+        const s = P(a, r[2]);
+        return s || console.warn(y + ": Property binding not found", t, a, a.name, r), s;
       }
       return e;
     }
-    return I(a, t);
+    return P(a, t);
   };
 }
 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.0.7",
+  "version": "1.1.1",
   "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';
 
@@ -247,23 +246,37 @@ export class GLTFAnimationPointerExtension {
 					const pathStartNode = path.substring( 0, pathIndexNode );
 					targetProperty = path.substring( pathIndexNode );
 
-					switch ( targetProperty ) {
+					if ( targetProperty.startsWith( 'weights/' ) ) {
+						// `/nodes/{}/weights/{}` - control individual morph weights
+						const weightIndex = targetProperty.substring( 'weights/'.length );
+						if ( /^\d+$/.test( weightIndex ) ) {
 
-						case 'translation':
-							targetProperty = 'position';
-							break;
-						case 'rotation':
-							targetProperty = 'quaternion';
-							break;
-						case 'scale':
-							targetProperty = 'scale';
-							break;
-						case 'weights':
-							targetProperty = 'morphTargetInfluences';
-							break;
-						case "extensions/KHR_node_visibility/visible":
-							targetProperty = 'visible';
-							break;
+							targetProperty = 'morphTargetInfluences[' + weightIndex + ']';
+
+						} else {
+
+							console.warn( KHR_ANIMATION_POINTER + ': invalid weight index', targetProperty, path );
+
+						}
+					} else {
+						switch ( targetProperty ) {
+
+							case 'translation':
+								targetProperty = 'position';
+								break;
+							case 'rotation':
+								targetProperty = 'quaternion';
+								break;
+							case 'scale':
+								targetProperty = 'scale';
+								break;
+							case 'weights':
+								targetProperty = 'morphTargetInfluences';
+								break;
+							case "extensions/KHR_node_visibility/visible":
+								targetProperty = 'visible';
+								break;
+						}
 					}
 
 					path = pathStartNode + targetProperty;
@@ -385,21 +398,25 @@ export class GLTFAnimationPointerExtension {
 
 		// specially handle the morphTargetInfluences property for multi-material meshes
 		// in which case the target object is a Group and the children are the actual targets
+		// Note that there is also morphTargetInfluences[i] for individual morph targets
 		// see NE-3311
-		if ( parts[ 3 ] === 'morphTargetInfluences' ) {
+		if ( parts[ 3 ]?.startsWith( 'morphTargetInfluences' ) ) {
+
+			const property = parts[ 3 ];
 
 			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 ] = 'morphTargetInfluences';
+						parts[ 4 ] = property;
 						__createTrack( this.parser );
 
 					}