@zephyr3d/editor 0.3.7 → 0.3.8

package/dist/vendor/zephyr3d/loaders/dist/index.d.ts

@@ -44,10 +44,18 @@ declare class GLTFImporter extends AbstractModelImporter {
     private _numberKey;
     private _toJointDynamicsCollider;
     private _toJointDynamicsFlatPlane;
+    private _loadVRMHumanoidSkeletonMappings;
+    private _getVRMC1HumanoidMapping;
+    private _getVRMC0HumanoidMapping;
     private _setAssetSkeletonHumanoidMapping;
     private _getVRMAHumanoidMapping;
+    private _getVRMC0HumanoidMappingFromBones;
+    private _filterHumanoidMappingToSkeleton;
     private _getVRMAHumanBoneNode;
     private _getVRMAHumanoidNodes;
+    private _getVRMAExpressionMapping;
+    private _addVRMAExpressionMapping;
+    private _createVRMAExpressionInterpolator;
     private _findCommonRoot;
     private _sortSkeletonJoints;
     private _shouldGenerateMToonOutlineNormals;

package/dist/vendor/zephyr3d/scene/dist/animation/animationset.js

@@ -4,6 +4,7 @@ import { NodeRotationTrack } from './rotationtrack.js';
 import { NodeEulerRotationTrack } from './eulerrotationtrack.js';
 import { NodeTranslationTrack } from './translationtrack.js';
 import { NodeScaleTrack } from './scaletrack.js';
+import { MorphTargetGroupTrack } from './morphtargetgrouptrack.js';
 import { HumanoidBodyRig } from './skeleton.js';
 import { createSkeletalMaskedAnimationClip } from './animationmask.js';
 
@@ -232,7 +233,7 @@ function cloneInterpolator(src) {
         ...src.outputs
     ]);
 }
-function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint, translationRotation, translationScale, translationAxisLocks) {
+function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint, translationRotation, translationScale, translationCorrection, translationAxisLocks, rotationCorrection) {
     const si = srcSkeleton.joints.indexOf(srcJoint);
     const di = dstSkeleton.joints.indexOf(dstJoint);
     const srcBindPose = srcSkeleton.bindPose[si];
@@ -245,24 +246,28 @@ function createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint,
         srcNode: srcJoint,
         srcBindRotInv: Quaternion.inverse(srcBindPose.rotation),
         dstBindRot: dstBindPose.rotation.clone(),
+        rotationCorrection,
         srcBindPos: srcBindPose.position.clone(),
         dstBindPos: dstBindPose.position.clone(),
-        translationScale: (srcLen > 1e-6 ? dstLen / srcLen : 1),
+        translationScale: translationScale ?? (srcLen > 1e-6 ? dstLen / srcLen : 1),
         translationRotation,
+        translationCorrection,
         translationAxisLocks
     };
 }
-function createTranslationRetargetRemap(srcNode, dstNode, srcBindPos, dstBindPos, dstJointIndex, translationScale, translationRotation, translationAxisLocks) {
+function createTranslationRetargetRemap(srcNode, dstNode, srcBindPos, dstBindPos, dstJointIndex, translationScale, translationRotation, translationCorrection, translationAxisLocks, rotationCorrection) {
     return {
         dstNode,
         dstJointIndex,
         srcNode,
         srcBindRotInv: Quaternion.identity(),
         dstBindRot: Quaternion.identity(),
+        rotationCorrection,
         srcBindPos: srcBindPos.clone(),
         dstBindPos: dstBindPos.clone(),
         translationScale,
         translationRotation,
+        translationCorrection,
         translationAxisLocks
     };
 }
@@ -270,6 +275,151 @@ function getBindPosition(skeleton, joint) {
     const index = skeleton.joints.indexOf(joint);
     return index >= 0 ? skeleton.bindPose[index].position : null;
 }
+function getSkeletonLocalBindTransform(skeleton, node, jointSet, cache) {
+    let transform = cache.get(node);
+    if (!transform) {
+        const bindPose = getRigBindPoseForNode(skeleton, node);
+        const position = bindPose.position.clone();
+        const rotation = bindPose.rotation.clone();
+        const parent = node.parent;
+        if (parent && jointSet.has(parent)) {
+            const parentTransform = getSkeletonLocalBindTransform(skeleton, parent, jointSet, cache);
+            parentTransform.rotation.transform(position, position);
+            position.addBy(parentTransform.position);
+            Quaternion.multiply(parentTransform.rotation, rotation, rotation);
+        }
+        transform = {
+            position,
+            rotation
+        };
+        cache.set(node, transform);
+    }
+    return transform;
+}
+function getHumanoidLateralXSign(skeleton) {
+    const mapping = skeleton.humanoidJointMapping;
+    if (!mapping) {
+        return 0;
+    }
+    const pairs = [
+        [
+            HumanoidBodyRig.LeftShoulder,
+            HumanoidBodyRig.RightShoulder
+        ],
+        [
+            HumanoidBodyRig.LeftUpperArm,
+            HumanoidBodyRig.RightUpperArm
+        ],
+        [
+            HumanoidBodyRig.LeftLowerArm,
+            HumanoidBodyRig.RightLowerArm
+        ],
+        [
+            HumanoidBodyRig.LeftHand,
+            HumanoidBodyRig.RightHand
+        ],
+        [
+            HumanoidBodyRig.LeftUpperLeg,
+            HumanoidBodyRig.RightUpperLeg
+        ],
+        [
+            HumanoidBodyRig.LeftLowerLeg,
+            HumanoidBodyRig.RightLowerLeg
+        ],
+        [
+            HumanoidBodyRig.LeftFoot,
+            HumanoidBodyRig.RightFoot
+        ],
+        [
+            HumanoidBodyRig.LeftToes,
+            HumanoidBodyRig.RightToes
+        ]
+    ];
+    const jointSet = new Set(skeleton.joints);
+    const cache = new Map();
+    let score = 0;
+    let weight = 0;
+    for (const [leftKey, rightKey] of pairs){
+        const left = mapping.body[leftKey];
+        const right = mapping.body[rightKey];
+        if (!left || !right || !jointSet.has(left) || !jointSet.has(right)) {
+            continue;
+        }
+        const dx = getSkeletonLocalBindTransform(skeleton, left, jointSet, cache).position.x - getSkeletonLocalBindTransform(skeleton, right, jointSet, cache).position.x;
+        if (Math.abs(dx) > 1e-5) {
+            score += dx;
+            weight++;
+        }
+    }
+    if (weight === 0 || Math.abs(score) < 1e-5) {
+        return 0;
+    }
+    return score > 0 ? 1 : -1;
+}
+function getHumanoidForwardZSign(skeleton) {
+    const mapping = skeleton.humanoidJointMapping;
+    if (!mapping) {
+        return 0;
+    }
+    const pairs = [
+        [
+            HumanoidBodyRig.LeftFoot,
+            HumanoidBodyRig.LeftToes
+        ],
+        [
+            HumanoidBodyRig.RightFoot,
+            HumanoidBodyRig.RightToes
+        ]
+    ];
+    const jointSet = new Set(skeleton.joints);
+    const cache = new Map();
+    let score = 0;
+    let weight = 0;
+    for (const [footKey, toesKey] of pairs){
+        const foot = mapping.body[footKey];
+        const toes = mapping.body[toesKey];
+        if (!foot || !toes || !jointSet.has(foot) || !jointSet.has(toes)) {
+            continue;
+        }
+        const dz = getSkeletonLocalBindTransform(skeleton, toes, jointSet, cache).position.z - getSkeletonLocalBindTransform(skeleton, foot, jointSet, cache).position.z;
+        if (Math.abs(dz) > 1e-5) {
+            score += dz;
+            weight++;
+        }
+    }
+    if (weight === 0 || Math.abs(score) < 1e-5) {
+        return 0;
+    }
+    return score > 0 ? 1 : -1;
+}
+function getHumanoidSignFromSkeletons(skeletons, getSign) {
+    let score = 0;
+    for (const skeleton of skeletons){
+        score += getSign(skeleton);
+    }
+    return score > 0 ? 1 : score < 0 ? -1 : 0;
+}
+function getHumanoidRotationCorrection(srcSkeleton, dstSkeleton, srcSignSkeletons = [
+    srcSkeleton
+], dstSignSkeletons = [
+    dstSkeleton
+]) {
+    const srcLateralXSign = getHumanoidLateralXSign(srcSkeleton) || getHumanoidSignFromSkeletons(srcSignSkeletons, getHumanoidLateralXSign);
+    const dstLateralXSign = getHumanoidLateralXSign(dstSkeleton) || getHumanoidSignFromSkeletons(dstSignSkeletons, getHumanoidLateralXSign);
+    const srcForwardZSign = getHumanoidForwardZSign(srcSkeleton) || getHumanoidSignFromSkeletons(srcSignSkeletons, getHumanoidForwardZSign);
+    const dstForwardZSign = getHumanoidForwardZSign(dstSkeleton) || getHumanoidSignFromSkeletons(dstSignSkeletons, getHumanoidForwardZSign);
+    const axisXSign = srcLateralXSign && dstLateralXSign && srcLateralXSign !== dstLateralXSign ? -1 : 1;
+    const axisZSign = srcForwardZSign && dstForwardZSign && srcForwardZSign !== dstForwardZSign ? -1 : 1;
+    if (axisXSign === 1 && axisZSign === 1) {
+        return null;
+    }
+    const determinant = axisXSign * axisZSign;
+    return {
+        x: determinant * axisXSign,
+        y: determinant,
+        z: determinant * axisZSign
+    };
+}
 function getRigBindPoseForNode(skeleton, node) {
     return skeleton.getBindPoseForJoint(node) ?? (node === skeleton.rootJoint ? skeleton.rootBindPose : {
         position: node.position,
@@ -313,6 +463,35 @@ function getHumanoidRootMotionScale(srcSkeleton, dstSkeleton) {
 function findTranslationTrack(tracks) {
     return tracks?.find((track)=>track instanceof NodeTranslationTrack) ?? null;
 }
+function findAncestorTranslationTrack(clip, node, modelRoot) {
+    let current = node.parent;
+    while(current){
+        const track = findTranslationTrack(clip.tracks.get(current));
+        if (track) {
+            return {
+                node: current,
+                track
+            };
+        }
+        if (current === modelRoot) {
+            break;
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function copyMorphTargetGroupTracks(sourceClip, targetClip, target) {
+    for (const tracks of sourceClip.tracks.values()){
+        for (const track of tracks){
+            if (track instanceof MorphTargetGroupTrack) {
+                const cloned = track.clone();
+                cloned.name = track.name;
+                cloned.target = target.persistentId;
+                targetClip.addTrack(target, cloned);
+            }
+        }
+    }
+}
 function applyTranslationAxisLocks(value, bindValue, locks) {
     if (locks?.x) {
         value.x = bindValue.x;
@@ -338,13 +517,25 @@ function applyTranslationTangentAxisLocks(value, locks) {
 function retargetRotation(qSrcAnim, remap, out) {
     Quaternion.multiply(remap.srcBindRotInv, qSrcAnim, out);
     Quaternion.multiply(remap.dstBindRot, out, out);
+    if (remap.rotationCorrection) {
+        applyHumanoidRotationCorrection(out, remap.rotationCorrection, out);
+    }
     return out.inplaceNormalize();
 }
 function retargetRotationTangent(qSrcTangent, remap, out) {
     Quaternion.multiply(remap.srcBindRotInv, qSrcTangent, out);
     Quaternion.multiply(remap.dstBindRot, out, out);
+    if (remap.rotationCorrection) {
+        applyHumanoidRotationCorrection(out, remap.rotationCorrection, out);
+    }
     return out;
 }
+function applyHumanoidRotationCorrection(q, correction, out) {
+    return out.setXYZW(q.x * correction.x, q.y * correction.y, q.z * correction.z, q.w);
+}
+function applyHumanoidTranslationCorrection(value, correction, out) {
+    return out.setXYZ(value.x * correction.x, value.y * correction.y, value.z * correction.z);
+}
 function retargetTranslationValue(srcValue, remap, out) {
     out.setXYZ(srcValue.x, srcValue.y, srcValue.z);
     out.subBy(remap.srcBindPos);
@@ -352,6 +543,9 @@ function retargetTranslationValue(srcValue, remap, out) {
     if (remap.translationRotation) {
         remap.translationRotation.transform(out, out);
     }
+    if (remap.translationCorrection) {
+        applyHumanoidTranslationCorrection(out, remap.translationCorrection, out);
+    }
     out.addBy(remap.dstBindPos);
     applyTranslationAxisLocks(out, remap.dstBindPos, remap.translationAxisLocks);
     return out;
@@ -362,6 +556,9 @@ function retargetTranslationTangent(srcValue, remap, out) {
     if (remap.translationRotation) {
         remap.translationRotation.transform(out, out);
     }
+    if (remap.translationCorrection) {
+        applyHumanoidTranslationCorrection(out, remap.translationCorrection, out);
+    }
     applyTranslationTangentAxisLocks(out, remap.translationAxisLocks);
     return out;
 }
@@ -461,7 +658,7 @@ function sampleRotationTrack(track, time, fallback, out) {
     out.set(state);
     return out;
 }
-function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRootRotation, dstRootRotation, dstClip, remaps) {
+function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRootRotation, dstRootRotation, dstClip, remaps, rotationCorrection) {
     const rotationTracksByRemap = new Map();
     const times = new Set([
         0,
@@ -498,7 +695,10 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
     const outputsByRemap = new Map();
     const tmpLocalRot = new Quaternion();
     const tmpWorldDelta = new Quaternion();
+    const tmpRootDelta = new Quaternion();
     const tmpParentInv = new Quaternion();
+    const srcRootRotationInv = Quaternion.inverse(srcRootRotation);
+    const dstRootRotationInv = Quaternion.inverse(dstRootRotation);
     for (const remap of remaps){
         outputsByRemap.set(remap, new Float32Array(inputs.length * 4));
     }
@@ -555,6 +755,13 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         const srcBindWorldRot = getSrcBindWorldRot(remap.srcNode);
         const srcAnimWorldRot = getSrcAnimWorldRot(remap.srcNode, time);
         Quaternion.multiply(srcAnimWorldRot, Quaternion.inverse(srcBindWorldRot, tmpWorldDelta), tmpWorldDelta);
+        if (rotationCorrection) {
+            Quaternion.multiply(srcRootRotationInv, tmpWorldDelta, tmpRootDelta);
+            Quaternion.multiply(tmpRootDelta, srcRootRotation, tmpRootDelta);
+            applyHumanoidRotationCorrection(tmpRootDelta, rotationCorrection, tmpRootDelta);
+            Quaternion.multiply(dstRootRotation, tmpRootDelta, tmpWorldDelta);
+            Quaternion.multiply(tmpWorldDelta, dstRootRotationInv, tmpWorldDelta);
+        }
         Quaternion.multiply(tmpWorldDelta, getDstBindWorldRot(remap.dstNode), rot);
         return rot;
     }
@@ -1449,8 +1656,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             console.error(`copyHumanoidAnimationFrom: source skeleton does not have a humanoid joint mapping`);
             return null;
         }
-        const nodeMap = new Map();
-        const jointRemapBySrcNode = new Map();
+        const jointRemapsBySrcNode = new Map();
         // Find a destination skeleton that has a humanoid mapping and share at least the body rig keys
         let srcJointsFiltered = [];
         let dstJointsFiltered = [];
@@ -1463,38 +1669,34 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
             if (!dstHumanoidMapping) {
                 return false;
             }
+            const srcHips = srcHumanoidMapping.body[HumanoidBodyRig.Hips];
+            const dstHips = dstHumanoidMapping.body[HumanoidBodyRig.Hips];
+            if (!srcHips || !dstHips || !srcSkeleton.joints.includes(srcHips) || !sk.joints.includes(dstHips)) {
+                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) {
+            const addMatch = (srcJoint, dstJoint)=>{
+                if (srcJoint && dstJoint && srcSkeleton.joints.includes(srcJoint) && sk.joints.includes(dstJoint)) {
                     srcMatched.push(srcJoint);
                     dstMatched.push(dstJoint);
                 }
+            };
+            // Match body rig joints
+            for (const key of Object.keys(srcHumanoidMapping.body)){
+                addMatch(srcHumanoidMapping.body[key], dstHumanoidMapping.body[key]);
             }
             // 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);
-                    }
+                    addMatch(srcHumanoidMapping.leftHand[key], dstHumanoidMapping.leftHand[key]);
                 }
             }
             // 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);
-                    }
+                    addMatch(srcHumanoidMapping.rightHand[key], dstHumanoidMapping.rightHand[key]);
                 }
             }
             if (srcMatched.length === 0) {
@@ -1532,28 +1734,69 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         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 srcAncestorTranslationTrackInfo = !srcRootTranslationTrack ? findAncestorTranslationTrack(sourceClip, srcRootNode, sourceSet.model) : null;
+        const srcFallbackHipsTranslationTrack = !srcRootTranslationTrack && !srcAncestorTranslationTrackInfo && srcRootNode !== srcHipsNode ? findTranslationTrack(sourceClip.tracks.get(srcHipsNode)) : null;
+        const srcMotionTrack = srcRootTranslationTrack ?? srcAncestorTranslationTrackInfo?.track ?? srcFallbackHipsTranslationTrack;
+        const srcMotionNode = srcRootTranslationTrack ? srcRootNode : srcAncestorTranslationTrackInfo ? srcAncestorTranslationTrackInfo.node : 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();
+        const jointRemapsByDstSkeleton = new Map([
+            [
+                dstSkeleton,
+                jointRemaps
+            ]
+        ]);
+        const srcSignSkeletons = sourceSet._rigs.map((ref)=>ref.get()).filter((sk)=>!!sk);
+        const dstSignSkeletons = this._rigs.map((ref)=>ref.get()).filter((sk)=>!!sk);
+        const humanoidRotationCorrection = getHumanoidRotationCorrection(srcSkeleton, dstSkeleton, srcSignSkeletons, dstSignSkeletons);
+        const addJointRemap = (targetSkeleton, srcJoint, dstJoint, applyRotationCorrection = true)=>{
+            if (!srcJoint || !dstJoint || !srcSkeleton.joints.includes(srcJoint) || !targetSkeleton.joints.includes(dstJoint)) {
+                return;
+            }
+            const remap = createJointRetargetRemap(srcSkeleton, targetSkeleton, srcJoint, dstJoint, undefined, undefined, humanoidRotationCorrection ?? undefined, undefined, applyRotationCorrection ? humanoidRotationCorrection ?? undefined : undefined);
+            let targetRemaps = jointRemapsByDstSkeleton.get(targetSkeleton);
+            if (!targetRemaps) {
+                targetRemaps = [];
+                jointRemapsByDstSkeleton.set(targetSkeleton, targetRemaps);
+            }
+            targetRemaps.push(remap);
+            let srcRemaps = jointRemapsBySrcNode.get(srcJoint);
+            if (!srcRemaps) {
+                srcRemaps = [];
+                jointRemapsBySrcNode.set(srcJoint, srcRemaps);
+            }
+            srcRemaps.push(remap);
+        };
+        const addHumanoidMappingRemaps = (targetSkeleton)=>{
+            const targetMapping = targetSkeleton.humanoidJointMapping;
+            if (!targetMapping) {
+                return;
+            }
+            const applyRotationCorrection = targetSkeleton === dstSkeleton;
+            for (const key of Object.keys(srcHumanoidMapping.body)){
+                addJointRemap(targetSkeleton, srcHumanoidMapping.body[key], targetMapping.body[key], applyRotationCorrection);
+            }
+            if (srcHumanoidMapping.leftHand && targetMapping.leftHand) {
+                for (const key of Object.keys(srcHumanoidMapping.leftHand)){
+                    addJointRemap(targetSkeleton, srcHumanoidMapping.leftHand[key], targetMapping.leftHand[key], applyRotationCorrection);
+                }
+            }
+            if (srcHumanoidMapping.rightHand && targetMapping.rightHand) {
+                for (const key of Object.keys(srcHumanoidMapping.rightHand)){
+                    addJointRemap(targetSkeleton, srcHumanoidMapping.rightHand[key], targetMapping.rightHand[key], applyRotationCorrection);
+                }
+            }
+        };
         // 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;
+            addJointRemap(dstSkeleton, srcJointsFiltered[fi], dstJointsFiltered[fi], true);
+        }
+        for (const targetSkeleton of dstSignSkeletons){
+            if (targetSkeleton !== dstSkeleton) {
+                addHumanoidMappingRemaps(targetSkeleton);
             }
-            mappedSrcNodes.add(srcJoint);
-            mappedDstNodes.add(dstJoint);
-            nodeMap.set(srcJoint, dstJoint);
-            const remap = createJointRetargetRemap(srcSkeleton, dstSkeleton, srcJoint, dstJoint);
-            jointRemaps.push(remap);
-            jointRemapBySrcNode.set(srcJoint, remap);
         }
         const dstClip = this.createAnimation(destName);
         if (!dstClip) {
@@ -1562,9 +1805,37 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         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);
+        copyMorphTargetGroupTracks(sourceClip, dstClip, this._model);
+        for (const [targetSkeleton, targetRemaps] of jointRemapsByDstSkeleton){
+            if (targetRemaps.length === 0) {
+                continue;
+            }
+            const hasCopyableTrack = targetSkeleton === dstSkeleton || targetRemaps.some((remap)=>{
+                const srcTracks = sourceClip.tracks.get(remap.srcNode);
+                if (!srcTracks) {
+                    return false;
+                }
+                for (const srcTrack of srcTracks){
+                    if (srcTrack instanceof NodeRotationTrack || srcTrack instanceof NodeEulerRotationTrack) {
+                        return true;
+                    }
+                    if (srcTrack instanceof NodeTranslationTrack && remap.srcNode !== srcRootNode && srcTrack !== srcMotionTrack && jointTranslations === 'preserve') {
+                        return true;
+                    }
+                    if (srcTrack instanceof NodeScaleTrack) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+            if (!hasCopyableTrack) {
+                continue;
+            }
+            dstClip.addSkeleton(targetSkeleton.persistentId);
+            const targetRootNode = targetSkeleton.rootJoint ?? targetSkeleton.humanoidJointMapping?.body[HumanoidBodyRig.Hips] ?? targetRemaps[0].dstNode;
+            const targetRootRot = targetRootNode === dstRootNode ? dstRootRot : computeParentChainRotation(targetRootNode, this._model, targetSkeleton);
+            bakeHumanoidRotationTracks(sourceClip, srcSkeleton, targetSkeleton, srcRootRot, targetRootRot, dstClip, targetRemaps, humanoidRotationCorrection);
+        }
         if (rootMotion !== 'none') {
             const dstRootBindPose = getRigBindPoseForNode(dstSkeleton, dstRootNode);
             let dstRootTrack = null;
@@ -1572,7 +1843,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                 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);
+                const rootRemap = createTranslationRetargetRemap(srcMotionNode, dstRootNode, srcMotionBindPose.position, dstRootBindPose.position, dstSkeleton.joints.indexOf(dstRootNode), rootTranslationScale, rootTranslationRotation, humanoidRotationCorrection ?? undefined, options.lockRootMotionAxes, humanoidRotationCorrection ?? undefined);
                 dstRootTrack = retargetTranslationTrack(srcMotionTrack, rootRemap);
             }
             if (dstRootTrack) {
@@ -1582,34 +1853,33 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
                 dstClip.addTrack(dstRootNode, dstRootTrack);
             }
         }
-        for (const srcNode of srcJointsFiltered){
+        for (const [srcNode, srcRemaps] of jointRemapsBySrcNode){
             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) {
-                    if (srcNode === srcRootNode || srcTrack === srcMotionTrack || jointTranslations !== 'preserve') {
+            for (const remap of srcRemaps){
+                const dstNode = remap.dstNode;
+                for (const srcTrack of srcTracks){
+                    let dstTrack;
+                    if (srcTrack instanceof NodeRotationTrack || 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));
+                    } else {
+                        console.warn(`copyHumanoidAnimationFrom: unsupported track type '${srcTrack.constructor.name}', skipping`);
                         continue;
                     }
-                    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);
                 }
-                dstTrack.name = srcTrack.name;
-                dstTrack.target = dstNode.persistentId;
-                dstTrack.jointIndex = remap.dstJointIndex;
-                dstClip.addTrack(dstNode, dstTrack);
             }
         }
         return dstClip;
@@ -1702,6 +1972,7 @@ function bakeHumanoidRotationTracks(sourceClip, srcSkeleton, dstSkeleton, srcRoo
         dstClip.autoPlay = sourceClip.autoPlay;
         // Register destination skeleton
         dstClip.addSkeleton(dstSkeleton.persistentId);
+        copyMorphTargetGroupTracks(sourceClip, dstClip, this._model);
         for (const srcNode of srcJointsFiltered){
             const srcTracks = sourceClip.tracks.get(srcNode);
             if (!srcTracks) {