@babylonjs/serializers 6.6.1 → 6.7.0

package/glTF/2.0/glTFAnimation.js

@@ -44,32 +44,30 @@ export class _GLTFAnimation {
      * @param babylonTransformNode - BabylonJS mesh.
      * @param animation - animation.
      * @param animationChannelTargetPath - The target animation channel.
-     * @param convertToRightHandedSystem - Specifies if the values should be converted to right-handed.
      * @param useQuaternion - Specifies if quaternions are used.
      * @returns nullable IAnimationData
      */
-    static _CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate) {
+    static _CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, useQuaternion, animationSampleRate) {
         if (this._IsTransformable(babylonTransformNode)) {
             const inputs = [];
             const outputs = [];
             const keyFrames = animation.getKeys();
             const minMaxKeyFrames = _GLTFAnimation._CalculateMinMaxKeyFrames(keyFrames);
             const interpolationOrBake = _GLTFAnimation._DeduceInterpolation(keyFrames, animationChannelTargetPath, useQuaternion);
-            const frameDelta = minMaxKeyFrames.max - minMaxKeyFrames.min;
             const interpolation = interpolationOrBake.interpolationType;
             const shouldBakeAnimation = interpolationOrBake.shouldBakeAnimation;
             if (shouldBakeAnimation) {
-                _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
+                _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, useQuaternion);
             }
             else {
                 if (interpolation === "LINEAR" /* AnimationSamplerInterpolation.LINEAR */ || interpolation === "STEP" /* AnimationSamplerInterpolation.STEP */) {
-                    _GLTFAnimation._CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+                    _GLTFAnimation._CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion);
                 }
                 else if (interpolation === "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */) {
-                    _GLTFAnimation._CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+                    _GLTFAnimation._CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion);
                 }
                 else {
-                    _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
+                    _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, useQuaternion);
                 }
             }
             if (inputs.length && outputs.length) {
@@ -138,10 +136,9 @@ export class _GLTFAnimation {
      * @param binaryWriter
      * @param bufferViews
      * @param accessors
-     * @param convertToRightHandedSystem
      * @param animationSampleRate
      */
-    static _CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate, shouldExportAnimation) {
+    static _CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, animationSampleRate, shouldExportAnimation) {
         let glTFAnimation;
         if (_GLTFAnimation._IsTransformable(babylonNode)) {
             if (babylonNode.animations) {
@@ -156,7 +153,7 @@ export class _GLTFAnimation {
                             samplers: [],
                             channels: [],
                         };
-                        _GLTFAnimation._AddAnimation(`${animation.name}`, animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate);
+                        _GLTFAnimation._AddAnimation(`${animation.name}`, animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate);
                         if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
                             idleGLTFAnimations.push(glTFAnimation);
                         }
@@ -176,10 +173,9 @@ export class _GLTFAnimation {
      * @param binaryWriter
      * @param bufferViews
      * @param accessors
-     * @param convertToRightHandedSystem
      * @param animationSampleRate
      */
-    static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate, shouldExportAnimation) {
+    static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, animationSampleRate, shouldExportAnimation) {
         let glTFAnimation;
         if (babylonNode instanceof Mesh) {
             const morphTargetManager = babylonNode.morphTargetManager;
@@ -212,7 +208,7 @@ export class _GLTFAnimation {
                                 samplers: [],
                                 channels: [],
                             };
-                            _GLTFAnimation._AddAnimation(animation.name, animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, combinedAnimation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate, morphTargetManager.numTargets);
+                            _GLTFAnimation._AddAnimation(animation.name, animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, combinedAnimation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate, morphTargetManager.numTargets);
                             if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
                                 idleGLTFAnimations.push(glTFAnimation);
                             }
@@ -232,10 +228,9 @@ export class _GLTFAnimation {
      * @param binaryWriter
      * @param bufferViews
      * @param accessors
-     * @param convertToRightHandedSystemMap
      * @param animationSampleRate
      */
-    static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene, glTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystemMap, animationSampleRate, shouldExportAnimation) {
+    static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene, glTFAnimations, nodeMap, binaryWriter, bufferViews, accessors, animationSampleRate, shouldExportAnimation) {
         var _a;
         let glTFAnimation;
         if (babylonScene.animationGroups) {
@@ -262,8 +257,7 @@ export class _GLTFAnimation {
                         if (animationInfo) {
                             const babylonTransformNode = this._IsTransformable(target) ? target : this._IsTransformable(target[0]) ? target[0] : null;
                             if (babylonTransformNode) {
-                                const convertToRightHandedSystem = convertToRightHandedSystemMap[babylonTransformNode.uniqueId];
-                                _GLTFAnimation._AddAnimation(`${animation.name}`, glTFAnimation, babylonTransformNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate);
+                                _GLTFAnimation._AddAnimation(`${animation.name}`, glTFAnimation, babylonTransformNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate);
                             }
                         }
                     }
@@ -342,7 +336,7 @@ export class _GLTFAnimation {
                     combinedAnimationGroup.setKeys(animationKeys);
                     const animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimationGroup);
                     if (animationInfo) {
-                        _GLTFAnimation._AddAnimation(`${animationGroup.name}_${mesh.name}_MorphWeightAnimation`, glTFAnimation, mesh, combinedAnimationGroup, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, false, animationInfo.useQuaternion, animationSampleRate, morphTargetManager === null || morphTargetManager === void 0 ? void 0 : morphTargetManager.numTargets);
+                        _GLTFAnimation._AddAnimation(`${animationGroup.name}_${mesh.name}_MorphWeightAnimation`, glTFAnimation, mesh, combinedAnimationGroup, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, animationInfo.useQuaternion, animationSampleRate, morphTargetManager === null || morphTargetManager === void 0 ? void 0 : morphTargetManager.numTargets);
                     }
                 });
                 if (glTFAnimation.channels.length && glTFAnimation.samplers.length) {
@@ -351,8 +345,8 @@ export class _GLTFAnimation {
             }
         }
     }
-    static _AddAnimation(name, glTFAnimation, babylonTransformNode, animation, dataAccessorType, animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, useQuaternion, animationSampleRate, morphAnimationChannels) {
-        const animationData = _GLTFAnimation._CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate);
+    static _AddAnimation(name, glTFAnimation, babylonTransformNode, animation, dataAccessorType, animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, useQuaternion, animationSampleRate, morphAnimationChannels) {
+        const animationData = _GLTFAnimation._CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, useQuaternion, animationSampleRate);
         let bufferView;
         let accessor;
         let keyframeAccessorIndex;
@@ -436,10 +430,9 @@ export class _GLTFAnimation {
      * @param minMaxFrames
      * @param minMaxFrames.min
      * @param minMaxFrames.max
-     * @param convertToRightHandedSystem converts the values to right-handed
      * @param useQuaternion specifies if quaternions should be used
      */
-    static _CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minFrame, maxFrame, fps, sampleRate, inputs, outputs, minMaxFrames, convertToRightHandedSystem, useQuaternion) {
+    static _CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minFrame, maxFrame, fps, sampleRate, inputs, outputs, minMaxFrames, useQuaternion) {
         let value;
         const quaternionCache = Quaternion.Identity();
         let previousTime = null;
@@ -493,7 +486,7 @@ export class _GLTFAnimation {
                         loopMode: animation.loopMode,
                     };
                     value = animation._interpolate(f, state);
-                    _GLTFAnimation._SetInterpolatedValue(babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+                    _GLTFAnimation._SetInterpolatedValue(babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, useQuaternion);
                 }
             }
         }
@@ -501,23 +494,17 @@ export class _GLTFAnimation {
             minMaxFrames.max = maxUsedFrame;
         }
     }
-    static _ConvertFactorToVector3OrQuaternion(factor, babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
-        const basePositionRotationOrScale = _GLTFAnimation._GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+    static _ConvertFactorToVector3OrQuaternion(factor, babylonTransformNode, animation, animationChannelTargetPath, useQuaternion) {
+        const basePositionRotationOrScale = _GLTFAnimation._GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, useQuaternion);
         // handles single component x, y, z or w component animation by using a base property and animating over a component.
         const property = animation.targetProperty.split(".");
-        const componentName = property ? property[1] : ""; // x, y, or z component
+        const componentName = property ? property[1] : ""; // x, y, z, or w component
         const value = useQuaternion ? Quaternion.FromArray(basePositionRotationOrScale).normalize() : Vector3.FromArray(basePositionRotationOrScale);
         switch (componentName) {
-            case "x": {
-                value[componentName] = convertToRightHandedSystem && useQuaternion && animationChannelTargetPath !== "scale" /* AnimationChannelTargetPath.SCALE */ ? -factor : factor;
-                break;
-            }
-            case "y": {
-                value[componentName] = convertToRightHandedSystem && useQuaternion && animationChannelTargetPath !== "scale" /* AnimationChannelTargetPath.SCALE */ ? -factor : factor;
-                break;
-            }
+            case "x":
+            case "y":
             case "z": {
-                value[componentName] = convertToRightHandedSystem && !useQuaternion && animationChannelTargetPath !== "scale" /* AnimationChannelTargetPath.SCALE */ ? -factor : factor;
+                value[componentName] = factor;
                 break;
             }
             case "w": {
@@ -530,7 +517,7 @@ export class _GLTFAnimation {
         }
         return value;
     }
-    static _SetInterpolatedValue(babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+    static _SetInterpolatedValue(babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, useQuaternion) {
         let cacheValue;
         inputs.push(time);
         if (animationChannelTargetPath === "weights" /* AnimationChannelTargetPath.WEIGHTS */) {
@@ -538,7 +525,7 @@ export class _GLTFAnimation {
             return;
         }
         if (animation.dataType === Animation.ANIMATIONTYPE_FLOAT) {
-            value = this._ConvertFactorToVector3OrQuaternion(value, babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+            value = this._ConvertFactorToVector3OrQuaternion(value, babylonTransformNode, animation, animationChannelTargetPath, useQuaternion);
         }
         if (animationChannelTargetPath === "rotation" /* AnimationChannelTargetPath.ROTATION */) {
             if (useQuaternion) {
@@ -548,24 +535,11 @@ export class _GLTFAnimation {
                 cacheValue = value;
                 Quaternion.RotationYawPitchRollToRef(cacheValue.y, cacheValue.x, cacheValue.z, quaternionCache);
             }
-            if (convertToRightHandedSystem) {
-                _GLTFUtilities._GetRightHandedQuaternionFromRef(quaternionCache);
-                if (!babylonTransformNode.parent) {
-                    quaternionCache = Quaternion.FromArray([0, 1, 0, 0]).multiply(quaternionCache);
-                }
-            }
             outputs.push(quaternionCache.asArray());
         }
         else {
             // scaling and position animation
             cacheValue = value;
-            if (convertToRightHandedSystem && animationChannelTargetPath !== "scale" /* AnimationChannelTargetPath.SCALE */) {
-                _GLTFUtilities._GetRightHandedPositionVector3FromRef(cacheValue);
-                if (!babylonTransformNode.parent) {
-                    cacheValue.x *= -1;
-                    cacheValue.z *= -1;
-                }
-            }
             outputs.push(cacheValue.asArray());
         }
     }
@@ -574,16 +548,14 @@ export class _GLTFAnimation {
      * @param babylonTransformNode BabylonJS mesh
      * @param animation BabylonJS animation
      * @param animationChannelTargetPath The target animation channel
-     * @param frameDelta The difference between the last and first frame of the animation
      * @param inputs Array to store the key frame times
      * @param outputs Array to store the key frame data
-     * @param convertToRightHandedSystem Specifies if the position data should be converted to right handed
      * @param useQuaternion Specifies if quaternions are used in the animation
      */
-    static _CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+    static _CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion) {
         for (const keyFrame of animation.getKeys()) {
             inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
-            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion);
+            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, useQuaternion);
         }
     }
     /**
@@ -594,42 +566,31 @@ export class _GLTFAnimation {
      * @param frameDelta The difference between the last and first frame of the animation
      * @param inputs Array to store the key frame times
      * @param outputs Array to store the key frame data
-     * @param convertToRightHandedSystem Specifies if the position data should be converted to right handed
      * @param useQuaternion Specifies if quaternions are used in the animation
      */
-    static _CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+    static _CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, inputs, outputs, useQuaternion) {
         animation.getKeys().forEach(function (keyFrame) {
             inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
-            _GLTFAnimation._AddSplineTangent(babylonTransformNode, _TangentType.INTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem);
-            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion);
-            _GLTFAnimation._AddSplineTangent(babylonTransformNode, _TangentType.OUTTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem);
+            _GLTFAnimation._AddSplineTangent(_TangentType.INTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */, keyFrame, useQuaternion);
+            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, useQuaternion);
+            _GLTFAnimation._AddSplineTangent(_TangentType.OUTTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */, keyFrame, useQuaternion);
         });
     }
-    static _GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
+    static _GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, useQuaternion) {
         let basePositionRotationOrScale;
         if (animationChannelTargetPath === "rotation" /* AnimationChannelTargetPath.ROTATION */) {
             if (useQuaternion) {
                 const q = babylonTransformNode.rotationQuaternion;
                 basePositionRotationOrScale = (q !== null && q !== void 0 ? q : Quaternion.Identity()).asArray();
-                if (convertToRightHandedSystem) {
-                    _GLTFUtilities._GetRightHandedQuaternionArrayFromRef(basePositionRotationOrScale);
-                    if (!babylonTransformNode.parent) {
-                        basePositionRotationOrScale = Quaternion.FromArray([0, 1, 0, 0]).multiply(Quaternion.FromArray(basePositionRotationOrScale)).asArray();
-                    }
-                }
             }
             else {
                 const r = babylonTransformNode.rotation;
                 basePositionRotationOrScale = (r !== null && r !== void 0 ? r : Vector3.Zero()).asArray();
-                _GLTFUtilities._GetRightHandedNormalArray3FromRef(basePositionRotationOrScale);
             }
         }
         else if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
             const p = babylonTransformNode.position;
             basePositionRotationOrScale = (p !== null && p !== void 0 ? p : Vector3.Zero()).asArray();
-            if (convertToRightHandedSystem) {
-                _GLTFUtilities._GetRightHandedPositionArray3FromRef(basePositionRotationOrScale);
-            }
         }
         else {
             // scale
@@ -645,35 +606,18 @@ export class _GLTFAnimation {
      * @param outputs
      * @param animationChannelTargetPath
      * @param babylonTransformNode
-     * @param convertToRightHandedSystem
      * @param useQuaternion
      */
-    static _AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion) {
-        let value;
+    static _AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, useQuaternion) {
         let newPositionRotationOrScale;
         const animationType = animation.dataType;
         if (animationType === Animation.ANIMATIONTYPE_VECTOR3) {
-            value = keyFrame.value.asArray();
+            let value = keyFrame.value.asArray();
             if (animationChannelTargetPath === "rotation" /* AnimationChannelTargetPath.ROTATION */) {
                 const array = Vector3.FromArray(value);
-                let rotationQuaternion = Quaternion.RotationYawPitchRoll(array.y, array.x, array.z);
-                if (convertToRightHandedSystem) {
-                    _GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
-                    if (!babylonTransformNode.parent) {
-                        rotationQuaternion = Quaternion.FromArray([0, 1, 0, 0]).multiply(rotationQuaternion);
-                    }
-                }
+                const rotationQuaternion = Quaternion.RotationYawPitchRoll(array.y, array.x, array.z);
                 value = rotationQuaternion.asArray();
             }
-            else if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
-                if (convertToRightHandedSystem) {
-                    _GLTFUtilities._GetRightHandedNormalArray3FromRef(value);
-                    if (!babylonTransformNode.parent) {
-                        value[0] *= -1;
-                        value[2] *= -1;
-                    }
-                }
-            }
             outputs.push(value); // scale  vector.
         }
         else if (animationType === Animation.ANIMATIONTYPE_FLOAT) {
@@ -682,42 +626,20 @@ export class _GLTFAnimation {
             }
             else {
                 // handles single component x, y, z or w component animation by using a base property and animating over a component.
-                newPositionRotationOrScale = this._ConvertFactorToVector3OrQuaternion(keyFrame.value, babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+                newPositionRotationOrScale = this._ConvertFactorToVector3OrQuaternion(keyFrame.value, babylonTransformNode, animation, animationChannelTargetPath, useQuaternion);
                 if (newPositionRotationOrScale) {
                     if (animationChannelTargetPath === "rotation" /* AnimationChannelTargetPath.ROTATION */) {
-                        let posRotScale = useQuaternion
+                        const posRotScale = useQuaternion
                             ? newPositionRotationOrScale
                             : Quaternion.RotationYawPitchRoll(newPositionRotationOrScale.y, newPositionRotationOrScale.x, newPositionRotationOrScale.z).normalize();
-                        if (convertToRightHandedSystem) {
-                            _GLTFUtilities._GetRightHandedQuaternionFromRef(posRotScale);
-                            if (!babylonTransformNode.parent) {
-                                posRotScale = Quaternion.FromArray([0, 1, 0, 0]).multiply(posRotScale);
-                            }
-                        }
                         outputs.push(posRotScale.asArray());
                     }
-                    else if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
-                        if (convertToRightHandedSystem) {
-                            _GLTFUtilities._GetRightHandedNormalVector3FromRef(newPositionRotationOrScale);
-                            if (!babylonTransformNode.parent) {
-                                newPositionRotationOrScale.x *= -1;
-                                newPositionRotationOrScale.z *= -1;
-                            }
-                        }
-                    }
                     outputs.push(newPositionRotationOrScale.asArray());
                 }
             }
         }
         else if (animationType === Animation.ANIMATIONTYPE_QUATERNION) {
-            value = keyFrame.value.normalize().asArray();
-            if (convertToRightHandedSystem) {
-                _GLTFUtilities._GetRightHandedQuaternionArrayFromRef(value);
-                if (!babylonTransformNode.parent) {
-                    value = Quaternion.FromArray([0, 1, 0, 0]).multiply(Quaternion.FromArray(value)).asArray();
-                }
-            }
-            outputs.push(value);
+            outputs.push(keyFrame.value.normalize().asArray());
         }
         else {
             Tools.Error("glTFAnimation: Unsupported key frame values for animation!");
@@ -785,9 +707,8 @@ export class _GLTFAnimation {
      * @param keyFrame The key frame with the animation data
      * @param frameDelta Time difference between two frames used to scale the tangent by the frame delta
      * @param useQuaternion Specifies if quaternions are used
-     * @param convertToRightHandedSystem Specifies if the values should be converted to right-handed
      */
-    static _AddSplineTangent(babylonTransformNode, tangentType, outputs, animationChannelTargetPath, interpolation, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem) {
+    static _AddSplineTangent(tangentType, outputs, animationChannelTargetPath, interpolation, keyFrame, useQuaternion) {
         let tangent;
         const tangentValue = tangentType === _TangentType.INTANGENT ? keyFrame.inTangent : keyFrame.outTangent;
         if (interpolation === "CUBICSPLINE" /* AnimationSamplerInterpolation.CUBICSPLINE */) {
@@ -800,12 +721,6 @@ export class _GLTFAnimation {
                         const array = tangentValue;
                         tangent = Quaternion.RotationYawPitchRoll(array.y, array.x, array.z).asArray();
                     }
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedQuaternionArrayFromRef(tangent);
-                        if (!babylonTransformNode.parent) {
-                            tangent = Quaternion.FromArray([0, 1, 0, 0]).multiply(Quaternion.FromArray(tangent)).asArray();
-                        }
-                    }
                 }
                 else {
                     tangent = [0, 0, 0, 0];
@@ -822,15 +737,6 @@ export class _GLTFAnimation {
             else {
                 if (tangentValue) {
                     tangent = tangentValue.asArray();
-                    if (convertToRightHandedSystem) {
-                        if (animationChannelTargetPath === "translation" /* AnimationChannelTargetPath.TRANSLATION */) {
-                            _GLTFUtilities._GetRightHandedPositionArray3FromRef(tangent);
-                            if (!babylonTransformNode.parent) {
-                                tangent[0] *= -1; // x
-                                tangent[2] *= -1; // z
-                            }
-                        }
-                    }
                 }
                 else {
                     tangent = [0, 0, 0];