@zephyr3d/scene 0.9.4 → 0.9.6

package/dist/animation/animationset.js

@@ -4,7 +4,8 @@ import { NodeRotationTrack } from './rotationtrack.js';
 import { NodeEulerRotationTrack } from './eulerrotationtrack.js';
 import { NodeTranslationTrack } from './translationtrack.js';
 import { NodeScaleTrack } from './scaletrack.js';
-import { Skeleton, HumanoidBodyRig } from './skeleton.js';
+import { HumanoidBodyRig } from './skeleton.js';
+import { createSkeletalMaskedAnimationClip } from './animationmask.js';
 
 function cloneInterpolator(src) {
     return new Interpolator(src.mode, src.target, src.inputs instanceof Float32Array ? new Float32Array(src.inputs) : [
@@ -13,7 +14,7 @@ function cloneInterpolator(src) {
         ...src.outputs
     ]);
 }
-function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint, translationRotation) {
+function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint, translationRotation, translationScale, translationAxisLocks) {
     const si = srcSkeleton.joints.indexOf(srcJoint);
     const di = dstSkeleton.joints.indexOf(dstJoint);
     const srcBindPose = srcSkeleton.bindPose[si];
@@ -28,10 +29,94 @@ function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint,
         dstBindRot: dstBindPose.rotation.clone(),
         srcBindPos: srcBindPose.position.clone(),
         dstBindPos: dstBindPose.position.clone(),
-        translationScale: srcLen > 1e-6 ? dstLen / srcLen : 1,
-        translationRotation
+        translationScale: (srcLen > 1e-6 ? dstLen / srcLen : 1),
+        translationRotation,
+        translationAxisLocks
     };
 }
+function createTranslationRetargetRemap(srcNode, dstNode, srcBindPos, dstBindPos, dstJointIndex, translationScale, translationRotation, translationAxisLocks) {
+    return {
+        dstNode,
+        dstJointIndex,
+        srcNode,
+        srcBindRotInv: Quaternion.identity(),
+        dstBindRot: Quaternion.identity(),
+        srcBindPos: srcBindPos.clone(),
+        dstBindPos: dstBindPos.clone(),
+        translationScale,
+        translationRotation,
+        translationAxisLocks
+    };
+}
+function getBindPosition(skeleton, joint) {
+    const index = skeleton.joints.indexOf(joint);
+    return index >= 0 ? skeleton.bindPose[index].position : null;
+}
+function getRigBindPoseForNode(skeleton, node) {
+    return skeleton.getBindPoseForJoint(node) ?? (node === skeleton.rootJoint ? skeleton.rootBindPose : {
+        position: node.position,
+        rotation: node.rotation,
+        scale: node.scale
+    });
+}
+function getBindDistanceToAncestor(skeleton, joint, ancestor) {
+    let distance = 0;
+    let node = joint;
+    while(node && node !== ancestor){
+        const bindPosition = getBindPosition(skeleton, node);
+        if (!bindPosition) {
+            return 0;
+        }
+        distance += bindPosition.magnitude;
+        node = node.parent;
+    }
+    return node === ancestor ? distance : 0;
+}
+function getHumanoidLegLength(skeleton, side) {
+    const mapping = skeleton.humanoidJointMapping;
+    if (!mapping) {
+        return 0;
+    }
+    const body = mapping.body;
+    const hips = body[HumanoidBodyRig.Hips];
+    const foot = side === 'left' ? body[HumanoidBodyRig.LeftFoot] : body[HumanoidBodyRig.RightFoot];
+    const toes = side === 'left' ? body[HumanoidBodyRig.LeftToes] : body[HumanoidBodyRig.RightToes];
+    return Math.max(getBindDistanceToAncestor(skeleton, foot, hips), getBindDistanceToAncestor(skeleton, toes, hips));
+}
+function getHumanoidRootMotionScale(srcSkeleton, dstSkeleton) {
+    const srcLeftLeg = getHumanoidLegLength(srcSkeleton, 'left');
+    const srcRightLeg = getHumanoidLegLength(srcSkeleton, 'right');
+    const dstLeftLeg = getHumanoidLegLength(dstSkeleton, 'left');
+    const dstRightLeg = getHumanoidLegLength(dstSkeleton, 'right');
+    const srcLegLength = Math.max(srcLeftLeg, srcRightLeg);
+    const dstLegLength = Math.max(dstLeftLeg, dstRightLeg);
+    return srcLegLength > 1e-6 && dstLegLength > 1e-6 ? dstLegLength / srcLegLength : 1;
+}
+function findTranslationTrack(tracks) {
+    return tracks?.find((track)=>track instanceof NodeTranslationTrack) ?? null;
+}
+function applyTranslationAxisLocks(value, bindValue, locks) {
+    if (locks?.x) {
+        value.x = bindValue.x;
+    }
+    if (locks?.y) {
+        value.y = bindValue.y;
+    }
+    if (locks?.z) {
+        value.z = bindValue.z;
+    }
+}
+function applyTranslationTangentAxisLocks(value, locks) {
+    if (locks?.x) {
+        value.x = 0;
+    }
+    if (locks?.y) {
+        value.y = 0;
+    }
+    if (locks?.z) {
+        value.z = 0;
+    }
+}
 function retargetRotation(qSrcAnim, remap, out) {
     Quaternion.multiply(remap.srcBindRotInv, qSrcAnim, out);
     Quaternion.multiply(remap.dstBindRot, out, out);
@@ -50,6 +135,7 @@ function retargetTranslationValue(srcValue, remap, out) {
         remap.translationRotation.transform(out, out);
     }
     out.addBy(remap.dstBindPos);
+    applyTranslationAxisLocks(out, remap.dstBindPos, remap.translationAxisLocks);
     return out;
 }
 function retargetTranslationTangent(srcValue, remap, out) {
@@ -58,6 +144,7 @@ function retargetTranslationTangent(srcValue, remap, out) {
     if (remap.translationRotation) {
         remap.translationRotation.transform(out, out);
     }
+    applyTranslationTangentAxisLocks(out, remap.translationAxisLocks);
     return out;
 }
 function retargetRotationTrack(src, remap) {
@@ -128,6 +215,15 @@ function retargetTranslationTrack(src, remap) {
     }
     return new NodeTranslationTrack(new Interpolator(src.interpolator.mode, 'vec3', new Float32Array(src.interpolator.inputs), newOutputs));
 }
+function createConstantTranslationTrack(value) {
+    return new NodeTranslationTrack(new Interpolator('step', 'vec3', new Float32Array([
+        0
+    ]), new Float32Array([
+        value.x,
+        value.y,
+        value.z
+    ])));
+}
 function findRotationTrack(tracks) {
     return tracks?.find((track)=>track instanceof NodeRotationTrack || track instanceof NodeEulerRotationTrack) ?? null;
 }
@@ -315,8 +411,10 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
     /** @internal */ _model;
     /** @internal */ _animations;
     /** @internal */ _skeletons;
+    /** @internal */ _rigs;
     /** @internal */ _activeTracks;
-    /** @internal */ _activeSkeletons;
+    /** @internal */ _activeSkinBindings;
+    /** @internal */ _activeRigs;
     /** @internal */ _activeAnimations;
     /**
    * Create an AnimationSet controlling the provided model.
@@ -327,9 +425,11 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         this._model = model;
         this._animations = {};
         this._activeTracks = new Map();
-        this._activeSkeletons = new Map();
+        this._activeSkinBindings = new Map();
+        this._activeRigs = new Map();
         this._activeAnimations = new Map();
         this._skeletons = [];
+        this._rigs = [];
     }
     /**
    * The model (SceneNode) controlled by this animation set.
@@ -347,6 +447,34 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         return this._skeletons;
     }
     /**
+   * The shared rigs used by animations in this set.
+   */ get rigs() {
+        return this._rigs;
+    }
+    /**
+   * Per-skin bindings used by skinned meshes in this set.
+   */ get skinBindings() {
+        return this._skeletons;
+    }
+    resolveRigByAnimationBindingId(id) {
+        return this._model.findSkeletonRigById(id) ?? this._model.findSkinBindingById(id)?.rig ?? null;
+    }
+    resolveClipRig(clip) {
+        let rig = null;
+        for (const id of clip.skeletons){
+            const nextRig = this.resolveRigByAnimationBindingId(id);
+            if (!nextRig) {
+                continue;
+            }
+            if (!rig) {
+                rig = nextRig;
+            } else if (rig !== nextRig) {
+                return null;
+            }
+        }
+        return rig;
+    }
+    /**
    * Retrieve an animation clip by name.
    *
    * @param name - Name of the animation.
@@ -400,7 +528,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
    * - Enforce repeat limits and apply fade-out termination if configured.
    * - For each animated target, blend active tracks (weighted by clip weight × fade-in × fade-out)
    *   and apply the resulting state to the target.
-   * - Apply all active skeletons to update skinning transforms.
+   * - Apply shared rig modifiers once, then update skin binding palettes.
    *
    * @param deltaInSeconds - Time step in seconds since last update.
    */ update(deltaInSeconds) {
@@ -415,12 +543,14 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                 const timeAdvance = deltaInSeconds * v.speedRatio;
                 v.currentTime += timeAdvance;
                 v.animateTime += timeAdvance;
-                if (v.currentTime > k.timeDuration) {
-                    v.repeatCounter++;
-                    v.currentTime = 0;
-                } else if (v.currentTime < 0) {
-                    v.repeatCounter++;
-                    v.currentTime = k.timeDuration;
+                if (k.timeDuration > 0) {
+                    if (v.currentTime > k.timeDuration) {
+                        v.repeatCounter += Math.max(1, Math.floor(v.currentTime / k.timeDuration));
+                        v.currentTime %= k.timeDuration;
+                    } else if (v.currentTime < 0) {
+                        v.repeatCounter += Math.max(1, Math.ceil(-v.currentTime / k.timeDuration));
+                        v.currentTime = (v.currentTime % k.timeDuration + k.timeDuration) % k.timeDuration;
+                    }
                 }
                 if (v.repeat !== 0 && v.repeatCounter >= v.repeat) {
                     this.stopAnimation(k.name);
@@ -459,10 +589,13 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                 }
             });
         });
-        // Update skeletons
-        this._skeletons.forEach((v)=>{
+        // Update rigs once before computing per-skin palettes.
+        this._rigs.forEach((v)=>{
             v.get()?.apply(deltaInSeconds);
         });
+        this._skeletons.forEach((v)=>{
+            v.get()?.apply();
+        });
     }
     /**
    * Check whether an animation is currently playing.
@@ -558,15 +691,21 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                 }
             });
             ani.skeletons?.forEach((v, k)=>{
-                const skeleton = this.model.findSkeletonById(k);
-                if (skeleton) {
-                    const refcount = this._activeSkeletons.get(skeleton);
-                    if (refcount) {
-                        this._activeSkeletons.set(skeleton, refcount + 1);
-                    } else {
-                        this._activeSkeletons.set(skeleton, 1);
-                    }
-                    skeleton.playing = true;
+                const rig = this.model.findSkeletonRigById(k);
+                if (rig) {
+                    const refcount = this._activeRigs.get(rig);
+                    this._activeRigs.set(rig, refcount ? refcount + 1 : 1);
+                    rig.playing = true;
+                    return;
+                }
+                const binding = this.model.findSkinBindingById(k);
+                if (binding) {
+                    const refcount = this._activeSkinBindings.get(binding);
+                    this._activeSkinBindings.set(binding, refcount ? refcount + 1 : 1);
+                    binding.playing = true;
+                    const rigRefcount = this._activeRigs.get(binding.rig);
+                    this._activeRigs.set(binding.rig, rigRefcount ? rigRefcount + 1 : 1);
+                    binding.rig.playing = true;
                 }
             });
         }
@@ -603,14 +742,32 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                     });
                 });
                 ani.skeletons?.forEach((v, k)=>{
-                    const skeleton = this.model.findSkeletonById(k);
-                    if (skeleton) {
-                        const refcount = this._activeSkeletons.get(skeleton);
+                    const rig = this.model.findSkeletonRigById(k);
+                    if (rig) {
+                        const refcount = this._activeRigs.get(rig);
                         if (refcount === 1) {
-                            skeleton.reset();
-                            this._activeSkeletons.delete(skeleton);
+                            rig.reset();
+                            this._activeRigs.delete(rig);
                         } else {
-                            this._activeSkeletons.set(skeleton, refcount - 1);
+                            this._activeRigs.set(rig, refcount - 1);
+                        }
+                        return;
+                    }
+                    const binding = this.model.findSkinBindingById(k);
+                    if (binding) {
+                        const refcount = this._activeSkinBindings.get(binding);
+                        if (refcount === 1) {
+                            binding.reset();
+                            this._activeSkinBindings.delete(binding);
+                        } else {
+                            this._activeSkinBindings.set(binding, refcount - 1);
+                        }
+                        const rigRefcount = this._activeRigs.get(binding.rig);
+                        if (rigRefcount === 1) {
+                            binding.rig.reset();
+                            this._activeRigs.delete(binding.rig);
+                        } else {
+                            this._activeRigs.set(binding.rig, rigRefcount - 1);
                         }
                     }
                 });
@@ -618,19 +775,34 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         }
     }
     /**
-   * Copy a humanoid animation clip from another AnimationSet into this one via humanoid rig mapping.
+   * Create a skeletal-only masked clip from an existing clip in this set.
    *
-   * Prerequisites:
-   * - Both source and destination skeletons must have a non-null `humanoidJointMapping`.
-   * - Joints are matched by shared `HumanoidBodyRig` / `HumanoidHandRig` keys instead of joint names.
-   * - The source clip must exist in `sourceSet` and must be driven by exactly one skeleton.
+   * The generated clip is a regular `AnimationClip`: it contains cloned node transform tracks
+   * for the selected rig joints and can be played/blended through the normal animation system.
+   * Non-skeletal tracks are skipped by default.
    *
-   * @param sourceSet - The AnimationSet to copy from.
-   * @param animationName - Name of the clip to copy.
-   * @param targetName - Name for the new clip in this set. Defaults to `animationName`.
-   * @returns The newly created AnimationClip, or null on failure.
-   */ copyHumanoidAnimationFrom(sourceSet, animationName, targetName) {
-        const destName = targetName ?? animationName;
+   * @param sourceName - Name of the source clip.
+   * @param targetName - Name of the generated clip.
+   * @param options - Humanoid semantic or joint-name based mask options.
+   * @returns The generated clip, or null on failure.
+   */ createSkeletalMaskedAnimation(sourceName, targetName, options) {
+        const sourceClip = this.get(sourceName);
+        if (!sourceClip) {
+            console.error(`createSkeletalMaskedAnimation: animation '${sourceName}' not found`);
+            return null;
+        }
+        const rig = this.resolveClipRig(sourceClip);
+        if (!rig) {
+            console.error(`createSkeletalMaskedAnimation: source animation must resolve to exactly one rig`);
+            return null;
+        }
+        return createSkeletalMaskedAnimationClip(this, sourceClip, targetName, rig, options);
+    }
+    copyHumanoidAnimationFrom(sourceSet, animationName, targetNameOrOptions, copyOptions) {
+        const options = typeof targetNameOrOptions === 'string' ? copyOptions ?? {} : targetNameOrOptions ?? {};
+        const destName = typeof targetNameOrOptions === 'string' ? targetNameOrOptions : options.targetName ?? animationName;
+        const rootMotion = options.rootMotion ?? 'scaled';
+        const jointTranslations = options.jointTranslations ?? 'skip';
         const sourceClip = sourceSet.get(animationName);
         if (!sourceClip) {
             console.error(`copyHumanoidAnimationFrom: animation '${animationName}' not found in source set`);
@@ -640,16 +812,12 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             console.error(`copyHumanoidAnimationFrom: animation '${destName}' already exists in target set`);
             return null;
         }
-        if (sourceClip.skeletons.size !== 1) {
-            console.error(`copyHumanoidAnimationFrom: source animation clip must be affected by exactly one skeleton`);
-            return null;
-        }
         const srcSkeletonId = [
             ...sourceClip.skeletons
-        ][0];
-        const srcSkeleton = Skeleton.findSkeletonById(srcSkeletonId);
+        ][0] ?? '';
+        const srcSkeleton = sourceSet.resolveClipRig(sourceClip);
         if (!srcSkeleton) {
-            console.error(`copyHumanoidAnimationFrom: source skeleton '${srcSkeletonId}' not found`);
+            console.error(`copyHumanoidAnimationFrom: source animation clip must resolve to exactly one humanoid rig`);
             return null;
         }
         // Check that source skeleton has humanoid mapping
@@ -663,7 +831,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         // Find a destination skeleton that has a humanoid mapping and share at least the body rig keys
         let srcJointsFiltered = [];
         let dstJointsFiltered = [];
-        const dstSkeleton = this._skeletons.map((ref)=>ref.get()).find((sk)=>{
+        const dstSkeleton = this._rigs.map((ref)=>ref.get()).find((sk)=>{
             if (!sk) {
                 return false;
             }
@@ -717,15 +885,15 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             console.error(`copyHumanoidAnimationFrom: no matching humanoid skeleton in target set for '${srcSkeletonId}'`);
             return null;
         }
-        // Compute the world-space rotation of the parent chain above the Hips joint,
+        // Compute the world-space rotation of the parent chain above a motion node,
         // walking ALL ancestor nodes up to (but not including) the model root.
         // This must include non-joint nodes such as "Armature" in Mixamo rigs, which
         // carry a 90° X rotation that is NOT captured by humanoidRootRotation (which
         // only traverses nodes inside the skeleton joints list).
-        function computeHipsParentChainRotation(hipsNode, modelRoot, skeleton) {
+        function computeParentChainRotation(node, modelRoot, skeleton) {
             const result = Quaternion.identity();
             const jointSet = new Set(skeleton.joints);
-            let p = hipsNode.parent;
+            let p = node.parent;
             while(p && p !== modelRoot){
                 if (!jointSet.has(p)) {
                     Quaternion.multiply(p.rotation, result, result);
@@ -736,9 +904,17 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         }
         const srcHipsNode = srcSkeleton.humanoidJointMapping.body[HumanoidBodyRig.Hips];
         const dstHipsNode = dstSkeleton.humanoidJointMapping.body[HumanoidBodyRig.Hips];
-        const srcRootRot = computeHipsParentChainRotation(srcHipsNode, sourceSet.model, srcSkeleton);
-        const dstRootRot = computeHipsParentChainRotation(dstHipsNode, this._model, dstSkeleton);
-        const hipsTranslationRotation = Quaternion.multiply(Quaternion.inverse(dstRootRot), srcRootRot);
+        const srcRootNode = srcSkeleton.rootJoint ?? srcHipsNode;
+        const dstRootNode = dstSkeleton.rootJoint ?? dstHipsNode;
+        const srcRootRot = computeParentChainRotation(srcRootNode, sourceSet.model, srcSkeleton);
+        const dstRootRot = computeParentChainRotation(dstRootNode, this._model, dstSkeleton);
+        const srcRootTranslationTrack = findTranslationTrack(sourceClip.tracks.get(srcRootNode));
+        const srcFallbackHipsTranslationTrack = !srcRootTranslationTrack && srcRootNode !== srcHipsNode ? findTranslationTrack(sourceClip.tracks.get(srcHipsNode)) : null;
+        const srcMotionTrack = srcRootTranslationTrack ?? srcFallbackHipsTranslationTrack;
+        const srcMotionNode = srcRootTranslationTrack ? srcRootNode : srcFallbackHipsTranslationTrack ? srcHipsNode : null;
+        const srcMotionParentRot = srcMotionNode ? computeParentChainRotation(srcMotionNode, sourceSet.model, srcSkeleton) : srcRootRot;
+        const rootTranslationRotation = Quaternion.multiply(Quaternion.inverse(dstRootRot), srcMotionParentRot);
+        const rootTranslationScale = rootMotion === 'scaled' ? typeof options.rootMotionScale === 'number' ? options.rootMotionScale : options.rootMotionScale === 'none' ? 1 : getHumanoidRootMotionScale(srcSkeleton, dstSkeleton) : 1;
         const jointRemaps = [];
         const mappedSrcNodes = new Set();
         const mappedDstNodes = new Set();
@@ -751,9 +927,8 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             }
             mappedSrcNodes.add(srcJoint);
             mappedDstNodes.add(dstJoint);
-            const isHipsBone = srcJoint === srcHipsNode;
             nodeMap.set(srcJoint, dstJoint);
-            const remap = createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint, isHipsBone ? hipsTranslationRotation : undefined);
+            const remap = createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint);
             jointRemaps.push(remap);
             jointRemapBySrcNode.set(srcJoint, remap);
         }
@@ -767,6 +942,23 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         // Register destination skeleton
         dstClip.addSkeleton(dstSkeleton.persistentId);
         bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRootRot, dstRootRot, dstClip, jointRemaps);
+        if (rootMotion !== 'none') {
+            const dstRootBindPose = getRigBindPoseForNode(dstSkeleton, dstRootNode);
+            let dstRootTrack = null;
+            if (rootMotion === 'locked') {
+                dstRootTrack = createConstantTranslationTrack(dstRootBindPose.position);
+            } else if (srcMotionTrack && srcMotionNode) {
+                const srcMotionBindPose = getRigBindPoseForNode(srcSkeleton, srcMotionNode);
+                const rootRemap = createTranslationRetargetRemap(srcMotionNode, dstRootNode, srcMotionBindPose.position, dstRootBindPose.position, dstSkeleton.joints.indexOf(dstRootNode), rootTranslationScale, rootTranslationRotation, options.lockRootMotionAxes);
+                dstRootTrack = retargetTranslationTrack(srcMotionTrack, rootRemap);
+            }
+            if (dstRootTrack) {
+                dstRootTrack.name = srcMotionTrack?.name ?? 'translation';
+                dstRootTrack.target = dstRootNode.persistentId;
+                dstRootTrack.jointIndex = dstSkeleton.joints.indexOf(dstRootNode);
+                dstClip.addTrack(dstRootNode, dstRootTrack);
+            }
+        }
         for (const srcNode of srcJointsFiltered){
             const srcTracks = sourceClip.tracks.get(srcNode);
             if (!srcTracks) {
@@ -781,6 +973,9 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                 } else if (srcTrack instanceof NodeEulerRotationTrack) {
                     continue;
                 } else if (srcTrack instanceof NodeTranslationTrack) {
+                    if (srcNode === srcRootNode || srcTrack === srcMotionTrack || jointTranslations !== 'preserve') {
+                        continue;
+                    }
                     dstTrack = retargetTranslationTrack(srcTrack, remap);
                 } else if (srcTrack instanceof NodeScaleTrack) {
                     dstTrack = new NodeScaleTrack(cloneInterpolator(srcTrack.interpolator));
@@ -810,7 +1005,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
    *   skeleton structure matching.
    * @returns The newly created AnimationClip, or null on failure.
    *
-   * @deprecated Use the new {@link AnimationSet.copyHumanoidAnimationFrom} method instead.
+   * @deprecated Use AnimationSet.copyHumanoidAnimationFrom instead.
    */ copyAnimationFrom(sourceSet, animationName, targetName, excludeJoint) {
         const destName = targetName ?? animationName;
         const sourceClip = sourceSet.get(animationName);
@@ -822,16 +1017,12 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             console.error(`copyAnimationFrom: animation '${destName}' already exists in target set`);
             return null;
         }
-        if (sourceClip.skeletons.size !== 1) {
-            console.error(`copyAnimationFrom: source animation clip must be affected by exactly one skeleton`);
-            return null;
-        }
         const srcSkeletonId = [
             ...sourceClip.skeletons
-        ][0];
-        const srcSkeleton = Skeleton.findSkeletonById(srcSkeletonId);
+        ][0] ?? '';
+        const srcSkeleton = sourceSet.resolveClipRig(sourceClip);
         if (!srcSkeleton) {
-            console.error(`copyAnimationFrom: source skeleton '${srcSkeletonId}' not found`);
+            console.error(`copyAnimationFrom: source animation clip must resolve to exactly one rig`);
             return null;
         }
         const nodeMap = new Map();
@@ -849,7 +1040,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             return null;
         }
         let dstJointsFiltered = [];
-        const dstSkeleton = this._skeletons.map((ref)=>ref.get()).find((sk)=>{
+        const dstSkeleton = this._rigs.map((ref)=>ref.get()).find((sk)=>{
             if (!sk) {
                 return false;
             }
@@ -961,6 +1152,15 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         }
     }
     /**
+   * Reset all skeleton modifiers
+   */ resetSkeletonModifiers() {
+        for (const sk of this._skeletons){
+            for (const modifier of sk.get().modifiers){
+                modifier.reset();
+            }
+        }
+    }
+    /**
    * Dispose the animation set and release owned resources.
    *
    * - Disposes the weak reference to the model.
@@ -973,7 +1173,8 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         }
         this._animations = {};
         this._activeAnimations.clear();
-        this._activeSkeletons.clear();
+        this._activeSkinBindings.clear();
+        this._activeRigs.clear();
         this._activeTracks.clear();
     }
 }