@zephyr3d/scene 0.8.2 → 0.9.0

package/dist/animation/animationset.js

@@ -1,11 +1,297 @@
-import { Disposable, weightedAverage, Interpolator } from '@zephyr3d/base';
+import { Disposable, weightedAverage, Quaternion, Interpolator, Vector3 } from '@zephyr3d/base';
 import { AnimationClip } from './animation.js';
 import { NodeRotationTrack } from './rotationtrack.js';
 import { NodeEulerRotationTrack } from './eulerrotationtrack.js';
 import { NodeTranslationTrack } from './translationtrack.js';
 import { NodeScaleTrack } from './scaletrack.js';
-import { Skeleton } from './skeleton.js';
+import { Skeleton, HumanoidBodyRig } from './skeleton.js';
 
+function cloneInterpolator(src) {
+    return new Interpolator(src.mode, src.target, src.inputs instanceof Float32Array ? new Float32Array(src.inputs) : [
+        ...src.inputs
+    ], src.outputs instanceof Float32Array ? new Float32Array(src.outputs) : [
+        ...src.outputs
+    ]);
+}
+function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint, translationRotation) {
+    const si = srcSkeleton.joints.indexOf(srcJoint);
+    const di = dstSkeleton.joints.indexOf(dstJoint);
+    const srcBindPose = srcSkeleton.bindPose[si];
+    const dstBindPose = dstSkeleton.bindPose[di];
+    const srcLen = srcBindPose.position.magnitude;
+    const dstLen = dstBindPose.position.magnitude;
+    return {
+        dstNode: dstJoint,
+        dstJointIndex: di,
+        srcNode: srcJoint,
+        srcBindRotInv: Quaternion.inverse(srcBindPose.rotation),
+        dstBindRot: dstBindPose.rotation.clone(),
+        srcBindPos: srcBindPose.position.clone(),
+        dstBindPos: dstBindPose.position.clone(),
+        translationScale: srcLen > 1e-6 ? dstLen / srcLen : 1,
+        translationRotation
+    };
+}
+function retargetRotation(qSrcAnim, remap, out) {
+    Quaternion.multiply(remap.srcBindRotInv, qSrcAnim, out);
+    Quaternion.multiply(remap.dstBindRot, out, out);
+    return out.inplaceNormalize();
+}
+function retargetRotationTangent(qSrcTangent, remap, out) {
+    Quaternion.multiply(remap.srcBindRotInv, qSrcTangent, out);
+    Quaternion.multiply(remap.dstBindRot, out, out);
+    return out;
+}
+function retargetTranslationValue(srcValue, remap, out) {
+    out.setXYZ(srcValue.x, srcValue.y, srcValue.z);
+    out.subBy(remap.srcBindPos);
+    out.scaleBy(remap.translationScale);
+    if (remap.translationRotation) {
+        remap.translationRotation.transform(out, out);
+    }
+    out.addBy(remap.dstBindPos);
+    return out;
+}
+function retargetTranslationTangent(srcValue, remap, out) {
+    out.setXYZ(srcValue.x, srcValue.y, srcValue.z);
+    out.scaleBy(remap.translationScale);
+    if (remap.translationRotation) {
+        remap.translationRotation.transform(out, out);
+    }
+    return out;
+}
+function retargetRotationTrack(src, remap) {
+    const isCubic = src.interpolator.mode === 'cubicspline';
+    const frameStride = isCubic ? 12 : 4;
+    const numFrames = src.interpolator.inputs.length;
+    const srcOutputs = src.interpolator.outputs;
+    const newOutputs = new Float32Array(srcOutputs.length);
+    const t = isCubic ? 4 : 0;
+    const q = new Quaternion();
+    for(let f = 0; f < numFrames; f++){
+        const base = f * frameStride;
+        q.setXYZW(srcOutputs[base + t], srcOutputs[base + t + 1], srcOutputs[base + t + 2], srcOutputs[base + t + 3]);
+        retargetRotation(q, remap, q);
+        if (isCubic) {
+            // Cubic quaternion tangents live in the same component space, so apply the
+            // same constant bind-pose transform without normalizing them.
+            q.setXYZW(srcOutputs[base], srcOutputs[base + 1], srcOutputs[base + 2], srcOutputs[base + 3]);
+            newOutputs.set(retargetRotationTangent(q, remap, q), base);
+            newOutputs.set(retargetRotation(new Quaternion(srcOutputs.subarray(base + 4, base + 8)), remap, q), base + 4);
+            q.setXYZW(srcOutputs[base + 8], srcOutputs[base + 9], srcOutputs[base + 10], srcOutputs[base + 11]);
+            newOutputs.set(retargetRotationTangent(q, remap, q), base + 8);
+        } else {
+            newOutputs.set(q, base);
+        }
+    }
+    return new NodeRotationTrack(new Interpolator(src.interpolator.mode, 'quat', new Float32Array(src.interpolator.inputs), newOutputs));
+}
+function retargetEulerToRotationTrack(src, remap) {
+    const srcInputs = src.interpolator.inputs;
+    const srcOutputs = src.interpolator.outputs;
+    const isCubic = src.interpolator.mode === 'cubicspline';
+    const frameStride = isCubic ? 9 : 3;
+    const t = isCubic ? 3 : 0;
+    const numFrames = srcInputs.length;
+    const newOutputs = new Float32Array(numFrames * 4);
+    const q = new Quaternion();
+    for(let f = 0; f < numFrames; f++){
+        const base = f * frameStride + t;
+        q.fromEulerAngle(srcOutputs[base], srcOutputs[base + 1], srcOutputs[base + 2]);
+        retargetRotation(q, remap, q);
+        newOutputs.set(q, f * 4);
+    }
+    return new NodeRotationTrack(new Interpolator(src.interpolator.mode === 'step' ? 'step' : 'linear', 'quat', new Float32Array(srcInputs), newOutputs));
+}
+function retargetTranslationTrack(src, remap) {
+    const isCubic = src.interpolator.mode === 'cubicspline';
+    const frameStride = isCubic ? 9 : 3;
+    const numFrames = src.interpolator.inputs.length;
+    const srcOutputs = src.interpolator.outputs;
+    const newOutputs = new Float32Array(srcOutputs.length);
+    const t = isCubic ? 3 : 0;
+    const v = new Vector3();
+    for(let f = 0; f < numFrames; f++){
+        const base = f * frameStride;
+        v.setXYZ(srcOutputs[base + t], srcOutputs[base + t + 1], srcOutputs[base + t + 2]);
+        retargetTranslationValue(v, remap, v);
+        if (isCubic) {
+            v.setXYZ(srcOutputs[base], srcOutputs[base + 1], srcOutputs[base + 2]);
+            newOutputs.set(retargetTranslationTangent(v, remap, v), base);
+            v.setXYZ(srcOutputs[base + 3], srcOutputs[base + 4], srcOutputs[base + 5]);
+            newOutputs.set(retargetTranslationValue(v, remap, v), base + 3);
+            v.setXYZ(srcOutputs[base + 6], srcOutputs[base + 7], srcOutputs[base + 8]);
+            newOutputs.set(retargetTranslationTangent(v, remap, v), base + 6);
+        } else {
+            newOutputs.set(v, base);
+        }
+    }
+    return new NodeTranslationTrack(new Interpolator(src.interpolator.mode, 'vec3', new Float32Array(src.interpolator.inputs), newOutputs));
+}
+function findRotationTrack(tracks) {
+    return tracks?.find((track)=>track instanceof NodeRotationTrack || track instanceof NodeEulerRotationTrack) ?? null;
+}
+function collectTrackTimes(track, times) {
+    if (track instanceof NodeRotationTrack || track instanceof NodeEulerRotationTrack) {
+        for (const time of track.interpolator.inputs){
+            times.add(time);
+        }
+    }
+}
+function sampleRotationTrack(track, time, fallback, out) {
+    if (!track) {
+        out.set(fallback);
+        return out;
+    }
+    const state = track.calculateState({}, time);
+    out.set(state);
+    return out;
+}
+function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRootRotation, dstRootRotation, dstClip, remaps) {
+    const rotationTracksByRemap = new Map();
+    const times = new Set([
+        0,
+        sourceClip.timeDuration
+    ]);
+    const remapsByDstNode = new Map();
+    const srcJointSet = new Set(srcSkeleton.joints);
+    const dstJointSet = new Set(dstSkeleton.joints);
+    const srcBindRotByNode = new Map();
+    const dstBindRotByNode = new Map();
+    const srcRotationTrackByNode = new Map();
+    for(let i = 0; i < srcSkeleton.joints.length; i++){
+        const joint = srcSkeleton.joints[i];
+        srcBindRotByNode.set(joint, srcSkeleton.bindPose[i].rotation);
+        const track = findRotationTrack(sourceClip.tracks.get(joint));
+        srcRotationTrackByNode.set(joint, track);
+        collectTrackTimes(track, times);
+    }
+    for(let i = 0; i < dstSkeleton.joints.length; i++){
+        dstBindRotByNode.set(dstSkeleton.joints[i], dstSkeleton.bindPose[i].rotation);
+    }
+    for (const remap of remaps){
+        const track = findRotationTrack(sourceClip.tracks.get(remap.srcNode));
+        rotationTracksByRemap.set(remap, track);
+        remapsByDstNode.set(remap.dstNode, remap);
+    }
+    const inputs = new Float32Array([
+        ...times
+    ].sort((a, b)=>a - b));
+    const srcBindWorldRots = new Map();
+    const dstBindWorldRots = new Map();
+    const srcAnimWorldRots = new Map();
+    const dstAnimWorldRots = new Map();
+    const outputsByRemap = new Map();
+    const tmpLocalRot = new Quaternion();
+    const tmpWorldDelta = new Quaternion();
+    const tmpParentInv = new Quaternion();
+    for (const remap of remaps){
+        outputsByRemap.set(remap, new Float32Array(inputs.length * 4));
+    }
+    function getSrcBindWorldRot(node) {
+        let rot = srcBindWorldRots.get(node);
+        if (!rot) {
+            rot = (srcBindRotByNode.get(node) ?? Quaternion.identity()).clone();
+            const parent = node.parent;
+            if (parent && srcJointSet.has(parent)) {
+                Quaternion.multiply(getSrcBindWorldRot(parent), rot, rot);
+            } else {
+                Quaternion.multiply(srcRootRotation, rot, rot);
+            }
+            srcBindWorldRots.set(node, rot);
+        }
+        return rot;
+    }
+    function getDstBindWorldRot(node) {
+        let rot = dstBindWorldRots.get(node);
+        if (!rot) {
+            rot = (dstBindRotByNode.get(node) ?? Quaternion.identity()).clone();
+            const parent = node.parent;
+            if (parent && dstJointSet.has(parent)) {
+                Quaternion.multiply(getDstBindWorldRot(parent), rot, rot);
+            } else {
+                Quaternion.multiply(dstRootRotation, rot, rot);
+            }
+            dstBindWorldRots.set(node, rot);
+        }
+        return rot;
+    }
+    function getSrcAnimWorldRot(node, time) {
+        let rot = srcAnimWorldRots.get(node);
+        if (!rot) {
+            rot = new Quaternion();
+            srcAnimWorldRots.set(node, rot);
+        }
+        const parent = node.parent;
+        const parentWorldRot = parent && srcJointSet.has(parent) ? getSrcAnimWorldRot(parent, time) : null;
+        sampleRotationTrack(srcRotationTrackByNode.get(node) ?? null, time, srcBindRotByNode.get(node) ?? Quaternion.identity(), tmpLocalRot);
+        if (parentWorldRot) {
+            Quaternion.multiply(parentWorldRot, tmpLocalRot, rot);
+        } else {
+            Quaternion.multiply(srcRootRotation, tmpLocalRot, rot);
+        }
+        return rot;
+    }
+    function getDstAnimWorldRot(remap, time) {
+        let rot = dstAnimWorldRots.get(remap.dstNode);
+        if (!rot) {
+            rot = new Quaternion();
+            dstAnimWorldRots.set(remap.dstNode, rot);
+        }
+        const srcBindWorldRot = getSrcBindWorldRot(remap.srcNode);
+        const srcAnimWorldRot = getSrcAnimWorldRot(remap.srcNode, time);
+        Quaternion.multiply(srcAnimWorldRot, Quaternion.inverse(srcBindWorldRot, tmpWorldDelta), tmpWorldDelta);
+        Quaternion.multiply(tmpWorldDelta, getDstBindWorldRot(remap.dstNode), rot);
+        return rot;
+    }
+    function getDstParentAnimWorldRot(node, time) {
+        const parent = node.parent;
+        if (!parent || !dstJointSet.has(parent)) {
+            return dstRootRotation;
+        }
+        const mappedParent = remapsByDstNode.get(parent);
+        if (mappedParent) {
+            return getDstAnimWorldRot(mappedParent, time);
+        }
+        let rot = dstAnimWorldRots.get(parent);
+        if (!rot) {
+            rot = (dstBindRotByNode.get(parent) ?? Quaternion.identity()).clone();
+            const parentWorldRot = getDstParentAnimWorldRot(parent, time);
+            if (parentWorldRot) {
+                Quaternion.multiply(parentWorldRot, rot, rot);
+            }
+            dstAnimWorldRots.set(parent, rot);
+        }
+        return rot;
+    }
+    for(let i = 0; i < inputs.length; i++){
+        const time = inputs[i];
+        srcAnimWorldRots.clear();
+        dstAnimWorldRots.clear();
+        for (const remap of remaps){
+            const dstAnimWorldRot = getDstAnimWorldRot(remap, time);
+            const parentWorldRot = getDstParentAnimWorldRot(remap.dstNode, time);
+            if (parentWorldRot) {
+                Quaternion.multiply(Quaternion.inverse(parentWorldRot, tmpParentInv), dstAnimWorldRot, tmpLocalRot);
+            } else {
+                tmpLocalRot.set(dstAnimWorldRot);
+            }
+            tmpLocalRot.inplaceNormalize();
+            outputsByRemap.get(remap).set(tmpLocalRot, i * 4);
+        }
+    }
+    for (const remap of remaps){
+        if (!rotationTracksByRemap.get(remap)) {
+            continue;
+        }
+        const outputs = new Float32Array(outputsByRemap.get(remap));
+        const track = new NodeRotationTrack(new Interpolator('linear', 'quat', new Float32Array(inputs), outputs));
+        track.name = 'rotation';
+        track.target = remap.dstNode.persistentId;
+        track.jointIndex = remap.dstJointIndex;
+        dstClip.addTrack(remap.dstNode, track);
+    }
+}
 /**
  * Animation set
  *
@@ -332,6 +618,185 @@ import { Skeleton } from './skeleton.js';
         }
     }
     /**
+   * Copy a humanoid animation clip from another AnimationSet into this one via humanoid rig mapping.
+   *
+   * 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.
+   *
+   * @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;
+        const sourceClip = sourceSet.get(animationName);
+        if (!sourceClip) {
+            console.error(`copyHumanoidAnimationFrom: animation '${animationName}' not found in source set`);
+            return null;
+        }
+        if (this._animations[destName]) {
+            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);
+        if (!srcSkeleton) {
+            console.error(`copyHumanoidAnimationFrom: source skeleton '${srcSkeletonId}' not found`);
+            return null;
+        }
+        // Check that source skeleton has humanoid mapping
+        const srcHumanoidMapping = srcSkeleton.humanoidJointMapping;
+        if (!srcHumanoidMapping) {
+            console.error(`copyHumanoidAnimationFrom: source skeleton does not have a humanoid joint mapping`);
+            return null;
+        }
+        const nodeMap = new Map();
+        const jointRemapBySrcNode = new Map();
+        // 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)=>{
+            if (!sk) {
+                return false;
+            }
+            // Check that destination skeleton has humanoid mapping
+            const dstHumanoidMapping = sk.humanoidJointMapping;
+            if (!dstHumanoidMapping) {
+                return false;
+            }
+            // Collect matched (srcJoint, dstJoint) pairs via shared humanoid rig keys
+            const srcMatched = [];
+            const dstMatched = [];
+            // Match body rig joints
+            for (const key of Object.keys(srcHumanoidMapping.body)){
+                const srcJoint = srcHumanoidMapping.body[key];
+                const dstJoint = dstHumanoidMapping.body[key];
+                if (srcJoint && dstJoint) {
+                    srcMatched.push(srcJoint);
+                    dstMatched.push(dstJoint);
+                }
+            }
+            // Match left hand rig joints only when both sides define them; skip silently if either is absent
+            if (srcHumanoidMapping.leftHand && dstHumanoidMapping.leftHand) {
+                for (const key of Object.keys(srcHumanoidMapping.leftHand)){
+                    const srcJoint = srcHumanoidMapping.leftHand[key];
+                    const dstJoint = dstHumanoidMapping.leftHand[key];
+                    if (srcJoint && dstJoint) {
+                        srcMatched.push(srcJoint);
+                        dstMatched.push(dstJoint);
+                    }
+                }
+            }
+            // Match right hand rig joints only when both sides define them; skip silently if either is absent
+            if (srcHumanoidMapping.rightHand && dstHumanoidMapping.rightHand) {
+                for (const key of Object.keys(srcHumanoidMapping.rightHand)){
+                    const srcJoint = srcHumanoidMapping.rightHand[key];
+                    const dstJoint = dstHumanoidMapping.rightHand[key];
+                    if (srcJoint && dstJoint) {
+                        srcMatched.push(srcJoint);
+                        dstMatched.push(dstJoint);
+                    }
+                }
+            }
+            if (srcMatched.length === 0) {
+                return false;
+            }
+            srcJointsFiltered = srcMatched;
+            dstJointsFiltered = dstMatched;
+            return true;
+        });
+        if (!dstSkeleton) {
+            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,
+        // 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) {
+            const result = Quaternion.identity();
+            const jointSet = new Set(skeleton.joints);
+            let p = hipsNode.parent;
+            while(p && p !== modelRoot){
+                if (!jointSet.has(p)) {
+                    Quaternion.multiply(p.rotation, result, result);
+                }
+                p = p.parent;
+            }
+            return result;
+        }
+        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 jointRemaps = [];
+        const mappedSrcNodes = new Set();
+        const mappedDstNodes = new Set();
+        // Build remap for matched joint pairs
+        for(let fi = 0; fi < srcJointsFiltered.length; fi++){
+            const srcJoint = srcJointsFiltered[fi];
+            const dstJoint = dstJointsFiltered[fi];
+            if (mappedSrcNodes.has(srcJoint) || mappedDstNodes.has(dstJoint)) {
+                continue;
+            }
+            mappedSrcNodes.add(srcJoint);
+            mappedDstNodes.add(dstJoint);
+            const isHipsBone = srcJoint === srcHipsNode;
+            nodeMap.set(srcJoint, dstJoint);
+            const remap = createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint, isHipsBone ? hipsTranslationRotation : undefined);
+            jointRemaps.push(remap);
+            jointRemapBySrcNode.set(srcJoint, remap);
+        }
+        const dstClip = this.createAnimation(destName);
+        if (!dstClip) {
+            return null;
+        }
+        dstClip.timeDuration = sourceClip.timeDuration;
+        dstClip.weight = sourceClip.weight;
+        dstClip.autoPlay = sourceClip.autoPlay;
+        // Register destination skeleton
+        dstClip.addSkeleton(dstSkeleton.persistentId);
+        bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRootRot, dstRootRot, dstClip, jointRemaps);
+        for (const srcNode of srcJointsFiltered){
+            const srcTracks = sourceClip.tracks.get(srcNode);
+            if (!srcTracks) {
+                continue;
+            }
+            const dstNode = nodeMap.get(srcNode);
+            const remap = jointRemapBySrcNode.get(srcNode);
+            for (const srcTrack of srcTracks){
+                let dstTrack;
+                if (srcTrack instanceof NodeRotationTrack) {
+                    continue;
+                } else if (srcTrack instanceof NodeEulerRotationTrack) {
+                    continue;
+                } else if (srcTrack instanceof NodeTranslationTrack) {
+                    dstTrack = retargetTranslationTrack(srcTrack, remap);
+                } else if (srcTrack instanceof NodeScaleTrack) {
+                    dstTrack = new NodeScaleTrack(cloneInterpolator(srcTrack.interpolator));
+                } else {
+                    console.warn(`copyHumanoidAnimationFrom: unsupported track type '${srcTrack.constructor.name}', skipping`);
+                    continue;
+                }
+                dstTrack.name = srcTrack.name;
+                dstTrack.target = dstNode.persistentId;
+                dstTrack.jointIndex = remap.dstJointIndex;
+                dstClip.addTrack(dstNode, dstTrack);
+            }
+        }
+        return dstClip;
+    }
+    /**
    * Copy an animation clip from another AnimationSet into this one.
    *
    * Prerequisites:
@@ -409,18 +874,8 @@ import { Skeleton } from './skeleton.js';
         for(let fi = 0; fi < srcJointsFiltered.length; fi++){
             const srcJoint = srcJointsFiltered[fi];
             const dstJoint = dstJointsFiltered[fi];
-            const si = srcSkeleton.joints.indexOf(srcJoint);
-            const di = dstSkeleton.joints.indexOf(dstJoint);
-            const srcLen = srcSkeleton.bindPose[si].position.magnitude;
-            const dstLen = dstSkeleton.bindPose[di].position.magnitude;
-            const translationScale = srcLen > 1e-6 ? dstLen / srcLen : 1;
             nodeMap.set(srcJoint, dstJoint);
-            jointRemapBySrcNode.set(srcJoint, {
-                dstNode: dstJoint,
-                srcBindRot: srcSkeleton.bindPose[si].rotation,
-                dstBindRot: dstSkeleton.bindPose[di].rotation,
-                translationScale
-            });
+            jointRemapBySrcNode.set(srcJoint, createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint));
         }
         const dstClip = this.createAnimation(destName);
         if (!dstClip) {
@@ -438,13 +893,13 @@ import { Skeleton } from './skeleton.js';
                 return null;
             }
             const dstNode = nodeMap.get(srcNode);
-            const remap = jointRemapBySrcNode.get(srcNode) ?? null;
+            const remap = jointRemapBySrcNode.get(srcNode);
             for (const srcTrack of srcTracks){
                 let dstTrack;
                 if (srcTrack instanceof NodeRotationTrack) {
-                    dstTrack = retargetRotationTrack(srcTrack);
+                    dstTrack = retargetRotationTrack(srcTrack, remap);
                 } else if (srcTrack instanceof NodeEulerRotationTrack) {
-                    dstTrack = retargetEulerToRotationTrack(srcTrack);
+                    dstTrack = retargetEulerToRotationTrack(srcTrack, remap);
                 } else if (srcTrack instanceof NodeTranslationTrack) {
                     dstTrack = retargetTranslationTrack(srcTrack, remap);
                 } else if (srcTrack instanceof NodeScaleTrack) {
@@ -454,8 +909,8 @@ import { Skeleton } from './skeleton.js';
                     continue;
                 }
                 dstTrack.name = srcTrack.name;
-                dstTrack.target = srcTrack.target;
-                dstTrack.jointIndex = srcTrack.jointIndex;
+                dstTrack.target = dstNode.persistentId;
+                dstTrack.jointIndex = remap.dstJointIndex;
                 dstClip.addTrack(dstNode, dstTrack);
             }
         }
@@ -502,48 +957,6 @@ import { Skeleton } from './skeleton.js';
             }
             return ordered;
         }
-        function retargetTranslationTrack(src, remap) {
-            if (!remap || Math.abs(remap.translationScale - 1) < 1e-6) {
-                return new NodeTranslationTrack(cloneInterpolator(src.interpolator));
-            }
-            const scale = remap.translationScale;
-            const srcOutputs = src.interpolator.outputs;
-            const newOutputs = new Float32Array(srcOutputs.length);
-            for(let i = 0; i < newOutputs.length; i++){
-                newOutputs[i] = srcOutputs[i] * scale;
-            }
-            return new NodeTranslationTrack(new Interpolator(src.interpolator.mode, 'vec3', new Float32Array(src.interpolator.inputs), newOutputs));
-        }
-        function cloneInterpolator(src) {
-            return new Interpolator(src.mode, src.target, src.inputs instanceof Float32Array ? new Float32Array(src.inputs) : [
-                ...src.inputs
-            ], src.outputs instanceof Float32Array ? new Float32Array(src.outputs) : [
-                ...src.outputs
-            ]);
-        }
-        function retargetRotationTrack(src) {
-            const isCubic = src.interpolator.mode === 'cubicspline';
-            const frameStride = isCubic ? 12 : 4;
-            const numFrames = src.interpolator.inputs.length;
-            const srcOutputs = src.interpolator.outputs;
-            const newOutputs = new Float32Array(srcOutputs.length);
-            for(let f = 0; f < numFrames; f++){
-                const base = f * frameStride;
-                newOutputs.set(srcOutputs.subarray(base, base + (isCubic ? 12 : 4)), base);
-            }
-            return new NodeRotationTrack(new Interpolator(src.interpolator.mode, 'quat', new Float32Array(src.interpolator.inputs), newOutputs));
-        }
-        function retargetEulerToRotationTrack(src) {
-            const srcInputs = src.interpolator.inputs;
-            const srcOutputs = src.interpolator.outputs;
-            const numFrames = srcInputs.length;
-            const newOutputs = new Float32Array(numFrames * 3);
-            for(let f = 0; f < numFrames; f++){
-                const base = f * 3;
-                newOutputs.set(srcOutputs.subarray(base, base + 3), base);
-            }
-            return new NodeRotationTrack(new Interpolator('linear', 'quat', new Float32Array(srcInputs), newOutputs));
-        }
     }
     /**
    * Dispose the animation set and release owned resources.