@babylonjs/serializers 5.0.0-rc.6 → 5.0.0

package/glTF/2.0/glTFAnimation.js

@@ -1,853 +1,853 @@
-import { Vector3, Quaternion } from "@babylonjs/core/Maths/math.vector.js";
-import { Tools } from "@babylonjs/core/Misc/tools.js";
-import { Animation } from "@babylonjs/core/Animations/animation.js";
-import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
-import { MorphTarget } from "@babylonjs/core/Morph/morphTarget.js";
-import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
-import { _GLTFUtilities } from "./glTFUtilities.js";
-import { AnimationKeyInterpolation } from "@babylonjs/core/Animations/animationKey.js";
-/**
- * @hidden
- * Enum for handling in tangent and out tangent.
- */
-// eslint-disable-next-line @typescript-eslint/naming-convention
-var _TangentType;
-(function (_TangentType) {
-    /**
-     * Specifies that input tangents are used.
-     */
-    _TangentType[_TangentType["INTANGENT"] = 0] = "INTANGENT";
-    /**
-     * Specifies that output tangents are used.
-     */
-    _TangentType[_TangentType["OUTTANGENT"] = 1] = "OUTTANGENT";
-})(_TangentType || (_TangentType = {}));
-/**
- * @hidden
- * Utility class for generating glTF animation data from BabylonJS.
- */
-var _GLTFAnimation = /** @class */ (function () {
-    function _GLTFAnimation() {
-    }
-    /**
-     * @ignore
-     *
-     * Creates glTF channel animation from BabylonJS animation.
-     * @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
-     */
-    _GLTFAnimation._CreateNodeAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate) {
-        var inputs = [];
-        var outputs = [];
-        var keyFrames = animation.getKeys();
-        var minMaxKeyFrames = _GLTFAnimation._CalculateMinMaxKeyFrames(keyFrames);
-        var interpolationOrBake = _GLTFAnimation._DeduceInterpolation(keyFrames, animationChannelTargetPath, useQuaternion);
-        var frameDelta = minMaxKeyFrames.max - minMaxKeyFrames.min;
-        var interpolation = interpolationOrBake.interpolationType;
-        var shouldBakeAnimation = interpolationOrBake.shouldBakeAnimation;
-        if (shouldBakeAnimation) {
-            _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
-        }
-        else {
-            if (interpolation === "LINEAR" /* LINEAR */ || interpolation === "STEP" /* STEP */) {
-                _GLTFAnimation._CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
-            }
-            else if (interpolation === "CUBICSPLINE" /* CUBICSPLINE */) {
-                _GLTFAnimation._CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
-            }
-            else {
-                _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
-            }
-        }
-        if (inputs.length && outputs.length) {
-            var result = {
-                inputs: inputs,
-                outputs: outputs,
-                samplerInterpolation: interpolation,
-                inputsMin: shouldBakeAnimation ? minMaxKeyFrames.min : Tools.FloatRound(minMaxKeyFrames.min / animation.framePerSecond),
-                inputsMax: shouldBakeAnimation ? minMaxKeyFrames.max : Tools.FloatRound(minMaxKeyFrames.max / animation.framePerSecond),
-            };
-            return result;
-        }
-        return null;
-    };
-    _GLTFAnimation._DeduceAnimationInfo = function (animation) {
-        var animationChannelTargetPath = null;
-        var dataAccessorType = "VEC3" /* VEC3 */;
-        var useQuaternion = false;
-        var property = animation.targetProperty.split(".");
-        switch (property[0]) {
-            case "scaling": {
-                animationChannelTargetPath = "scale" /* SCALE */;
-                break;
-            }
-            case "position": {
-                animationChannelTargetPath = "translation" /* TRANSLATION */;
-                break;
-            }
-            case "rotation": {
-                dataAccessorType = "VEC4" /* VEC4 */;
-                animationChannelTargetPath = "rotation" /* ROTATION */;
-                break;
-            }
-            case "rotationQuaternion": {
-                dataAccessorType = "VEC4" /* VEC4 */;
-                useQuaternion = true;
-                animationChannelTargetPath = "rotation" /* ROTATION */;
-                break;
-            }
-            case "influence": {
-                dataAccessorType = "SCALAR" /* SCALAR */;
-                animationChannelTargetPath = "weights" /* WEIGHTS */;
-                break;
-            }
-            default: {
-                Tools.Error("Unsupported animatable property ".concat(property[0]));
-            }
-        }
-        if (animationChannelTargetPath) {
-            return { animationChannelTargetPath: animationChannelTargetPath, dataAccessorType: dataAccessorType, useQuaternion: useQuaternion };
-        }
-        else {
-            Tools.Error("animation channel target path and data accessor type could be deduced");
-        }
-        return null;
-    };
-    /**
-     * @ignore
-     * Create node animations from the transform node animations
-     * @param babylonNode
-     * @param runtimeGLTFAnimation
-     * @param idleGLTFAnimations
-     * @param nodeMap
-     * @param nodes
-     * @param binaryWriter
-     * @param bufferViews
-     * @param accessors
-     * @param convertToRightHandedSystem
-     * @param animationSampleRate
-     */
-    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate) {
-        var glTFAnimation;
-        if (babylonNode instanceof TransformNode) {
-            if (babylonNode.animations) {
-                for (var _i = 0, _a = babylonNode.animations; _i < _a.length; _i++) {
-                    var animation = _a[_i];
-                    var animationInfo = _GLTFAnimation._DeduceAnimationInfo(animation);
-                    if (animationInfo) {
-                        glTFAnimation = {
-                            name: animation.name,
-                            samplers: [],
-                            channels: [],
-                        };
-                        _GLTFAnimation._AddAnimation("".concat(animation.name), animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate);
-                        if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
-                            idleGLTFAnimations.push(glTFAnimation);
-                        }
-                    }
-                }
-            }
-        }
-    };
-    /**
-     * @ignore
-     * Create individual morph animations from the mesh's morph target animation tracks
-     * @param babylonNode
-     * @param runtimeGLTFAnimation
-     * @param idleGLTFAnimations
-     * @param nodeMap
-     * @param nodes
-     * @param binaryWriter
-     * @param bufferViews
-     * @param accessors
-     * @param convertToRightHandedSystem
-     * @param animationSampleRate
-     */
-    _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate) {
-        var glTFAnimation;
-        if (babylonNode instanceof Mesh) {
-            var morphTargetManager = babylonNode.morphTargetManager;
-            if (morphTargetManager) {
-                for (var i = 0; i < morphTargetManager.numTargets; ++i) {
-                    var morphTarget = morphTargetManager.getTarget(i);
-                    for (var _i = 0, _a = morphTarget.animations; _i < _a.length; _i++) {
-                        var animation = _a[_i];
-                        var combinedAnimation = new Animation("".concat(animation.name), "influence", animation.framePerSecond, animation.dataType, animation.loopMode, animation.enableBlending);
-                        var combinedAnimationKeys = [];
-                        var animationKeys = animation.getKeys();
-                        for (var j = 0; j < animationKeys.length; ++j) {
-                            var animationKey = animationKeys[j];
-                            for (var k = 0; k < morphTargetManager.numTargets; ++k) {
-                                if (k == i) {
-                                    combinedAnimationKeys.push(animationKey);
-                                }
-                                else {
-                                    combinedAnimationKeys.push({ frame: animationKey.frame, value: 0 });
-                                }
-                            }
-                        }
-                        combinedAnimation.setKeys(combinedAnimationKeys);
-                        var animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimation);
-                        if (animationInfo) {
-                            glTFAnimation = {
-                                name: combinedAnimation.name,
-                                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);
-                            if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
-                                idleGLTFAnimations.push(glTFAnimation);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    };
-    /**
-     * @ignore
-     * Create node and morph animations from the animation groups
-     * @param babylonScene
-     * @param glTFAnimations
-     * @param nodeMap
-     * @param nodes
-     * @param binaryWriter
-     * @param bufferViews
-     * @param accessors
-     * @param convertToRightHandedSystemMap
-     * @param animationSampleRate
-     */
-    _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups = function (babylonScene, glTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystemMap, animationSampleRate) {
-        var _a;
-        var glTFAnimation;
-        if (babylonScene.animationGroups) {
-            var animationGroups = babylonScene.animationGroups;
-            var _loop_1 = function (animationGroup) {
-                var morphAnimations = new Map();
-                var sampleAnimations = new Map();
-                var morphAnimationMeshes = new Set();
-                var animationGroupFrameDiff = animationGroup.to - animationGroup.from;
-                glTFAnimation = {
-                    name: animationGroup.name,
-                    channels: [],
-                    samplers: [],
-                };
-                var _loop_2 = function (i) {
-                    var targetAnimation = animationGroup.targetedAnimations[i];
-                    var target = targetAnimation.target;
-                    var animation = targetAnimation.animation;
-                    if (target instanceof TransformNode || (target.length === 1 && target[0] instanceof TransformNode)) {
-                        var animationInfo = _GLTFAnimation._DeduceAnimationInfo(targetAnimation.animation);
-                        if (animationInfo) {
-                            var babylonTransformNode = target instanceof TransformNode ? target : target[0];
-                            var convertToRightHandedSystem = convertToRightHandedSystemMap[babylonTransformNode.uniqueId];
-                            _GLTFAnimation._AddAnimation("".concat(animation.name), glTFAnimation, babylonTransformNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate);
-                        }
-                    }
-                    else if (target instanceof MorphTarget || (target.length === 1 && target[0] instanceof MorphTarget)) {
-                        var animationInfo = _GLTFAnimation._DeduceAnimationInfo(targetAnimation.animation);
-                        if (animationInfo) {
-                            var babylonMorphTarget_1 = target instanceof MorphTarget ? target : target[0];
-                            if (babylonMorphTarget_1) {
-                                var babylonMorphTargetManager_1 = babylonScene.morphTargetManagers.find(function (morphTargetManager) {
-                                    for (var j = 0; j < morphTargetManager.numTargets; ++j) {
-                                        if (morphTargetManager.getTarget(j) === babylonMorphTarget_1) {
-                                            return true;
-                                        }
-                                    }
-                                    return false;
-                                });
-                                if (babylonMorphTargetManager_1) {
-                                    var babylonMesh = babylonScene.meshes.find(function (mesh) {
-                                        return mesh.morphTargetManager === babylonMorphTargetManager_1;
-                                    });
-                                    if (babylonMesh) {
-                                        if (!morphAnimations.has(babylonMesh)) {
-                                            morphAnimations.set(babylonMesh, new Map());
-                                        }
-                                        (_a = morphAnimations.get(babylonMesh)) === null || _a === void 0 ? void 0 : _a.set(babylonMorphTarget_1, animation);
-                                        morphAnimationMeshes.add(babylonMesh);
-                                        sampleAnimations.set(babylonMesh, animation);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                };
-                for (var i = 0; i < animationGroup.targetedAnimations.length; ++i) {
-                    _loop_2(i);
-                }
-                morphAnimationMeshes.forEach(function (mesh) {
-                    var morphTargetManager = mesh.morphTargetManager;
-                    var combinedAnimationGroup = null;
-                    var animationKeys = [];
-                    var sampleAnimation = sampleAnimations.get(mesh);
-                    var sampleAnimationKeys = sampleAnimation.getKeys();
-                    var numAnimationKeys = sampleAnimationKeys.length;
-                    /*
-                        Due to how glTF expects morph target animation data to be formatted, we need to rearrange the individual morph target animation tracks,
-                        such that we have a single animation, where a given keyframe input value has successive output values for each morph target belonging to the manager.
-                        See: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
-
-                        We do this via constructing a new Animation track, and interleaving the frames of each morph target animation track in the current Animation Group
-                        We reuse the Babylon Animation data structure for ease of handling export of cubic spline animation keys, and to reuse the
-                        existing _GLTFAnimation.AddAnimation codepath with minimal modification, however the constructed Babylon Animation is NOT intended for use in-engine.
-                    */
-                    for (var i = 0; i < numAnimationKeys; ++i) {
-                        for (var j = 0; j < morphTargetManager.numTargets; ++j) {
-                            var morphTarget = morphTargetManager.getTarget(j);
-                            var animationsByMorphTarget = morphAnimations.get(mesh);
-                            if (animationsByMorphTarget) {
-                                var morphTargetAnimation = animationsByMorphTarget.get(morphTarget);
-                                if (morphTargetAnimation) {
-                                    if (!combinedAnimationGroup) {
-                                        combinedAnimationGroup = new Animation("".concat(animationGroup.name, "_").concat(mesh.name, "_MorphWeightAnimation"), "influence", morphTargetAnimation.framePerSecond, Animation.ANIMATIONTYPE_FLOAT, morphTargetAnimation.loopMode, morphTargetAnimation.enableBlending);
-                                    }
-                                    animationKeys.push(morphTargetAnimation.getKeys()[i]);
-                                }
-                                else {
-                                    animationKeys.push({
-                                        frame: animationGroup.from + (animationGroupFrameDiff / numAnimationKeys) * i,
-                                        value: morphTarget.influence,
-                                        inTangent: sampleAnimationKeys[0].inTangent ? 0 : undefined,
-                                        outTangent: sampleAnimationKeys[0].outTangent ? 0 : undefined,
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    combinedAnimationGroup.setKeys(animationKeys);
-                    var animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimationGroup);
-                    if (animationInfo) {
-                        _GLTFAnimation._AddAnimation("".concat(animationGroup.name, "_").concat(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);
-                    }
-                });
-                if (glTFAnimation.channels.length && glTFAnimation.samplers.length) {
-                    glTFAnimations.push(glTFAnimation);
-                }
-            };
-            for (var _i = 0, animationGroups_1 = animationGroups; _i < animationGroups_1.length; _i++) {
-                var animationGroup = animationGroups_1[_i];
-                _loop_1(animationGroup);
-            }
-        }
-    };
-    _GLTFAnimation._AddAnimation = function (name, glTFAnimation, babylonTransformNode, animation, dataAccessorType, animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, useQuaternion, animationSampleRate, morphAnimationChannels) {
-        var animationData = _GLTFAnimation._CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate);
-        var bufferView;
-        var accessor;
-        var keyframeAccessorIndex;
-        var dataAccessorIndex;
-        var outputLength;
-        var animationSampler;
-        var animationChannel;
-        if (animationData) {
-            /*
-             * Now that we have the glTF converted morph target animation data,
-             * we can remove redundant input data so that we have n input frames,
-             * and morphAnimationChannels * n output frames
-             */
-            if (morphAnimationChannels) {
-                var index = 0;
-                var currentInput = 0;
-                var newInputs = [];
-                while (animationData.inputs.length > 0) {
-                    currentInput = animationData.inputs.shift();
-                    if (index % morphAnimationChannels == 0) {
-                        newInputs.push(currentInput);
-                    }
-                    index++;
-                }
-                animationData.inputs = newInputs;
-            }
-            var nodeIndex = nodeMap[babylonTransformNode.uniqueId];
-            // Creates buffer view and accessor for key frames.
-            var byteLength = animationData.inputs.length * 4;
-            bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, undefined, "".concat(name, "  keyframe data view"));
-            bufferViews.push(bufferView);
-            animationData.inputs.forEach(function (input) {
-                binaryWriter.setFloat32(input);
-            });
-            accessor = _GLTFUtilities._CreateAccessor(bufferViews.length - 1, "".concat(name, "  keyframes"), "SCALAR" /* SCALAR */, 5126 /* FLOAT */, animationData.inputs.length, null, [animationData.inputsMin], [animationData.inputsMax]);
-            accessors.push(accessor);
-            keyframeAccessorIndex = accessors.length - 1;
-            // create bufferview and accessor for keyed values.
-            outputLength = animationData.outputs.length;
-            byteLength = _GLTFUtilities._GetDataAccessorElementCount(dataAccessorType) * 4 * animationData.outputs.length;
-            // check for in and out tangents
-            bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, undefined, "".concat(name, "  data view"));
-            bufferViews.push(bufferView);
-            animationData.outputs.forEach(function (output) {
-                output.forEach(function (entry) {
-                    binaryWriter.setFloat32(entry);
-                });
-            });
-            accessor = _GLTFUtilities._CreateAccessor(bufferViews.length - 1, "".concat(name, "  data"), dataAccessorType, 5126 /* FLOAT */, outputLength, null, null, null);
-            accessors.push(accessor);
-            dataAccessorIndex = accessors.length - 1;
-            // create sampler
-            animationSampler = {
-                interpolation: animationData.samplerInterpolation,
-                input: keyframeAccessorIndex,
-                output: dataAccessorIndex,
-            };
-            glTFAnimation.samplers.push(animationSampler);
-            // create channel
-            animationChannel = {
-                sampler: glTFAnimation.samplers.length - 1,
-                target: {
-                    node: nodeIndex,
-                    path: animationChannelTargetPath,
-                },
-            };
-            glTFAnimation.channels.push(animationChannel);
-        }
-    };
-    /**
-     * Create a baked animation
-     * @param babylonTransformNode BabylonJS mesh
-     * @param animation BabylonJS animation corresponding to the BabylonJS mesh
-     * @param animationChannelTargetPath animation target channel
-     * @param minFrame minimum animation frame
-     * @param maxFrame maximum animation frame
-     * @param fps frames per second of the animation
-     * @param sampleRate
-     * @param inputs input key frames of the animation
-     * @param outputs output key frame data of the animation
-     * @param minMaxFrames
-     * @param minMaxFrames.min
-     * @param minMaxFrames.max
-     * @param convertToRightHandedSystem converts the values to right-handed
-     * @param useQuaternion specifies if quaternions should be used
-     */
-    _GLTFAnimation._CreateBakedAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, minFrame, maxFrame, fps, sampleRate, inputs, outputs, minMaxFrames, convertToRightHandedSystem, useQuaternion) {
-        var value;
-        var quaternionCache = Quaternion.Identity();
-        var previousTime = null;
-        var time;
-        var maxUsedFrame = null;
-        var currKeyFrame = null;
-        var nextKeyFrame = null;
-        var prevKeyFrame = null;
-        var endFrame = null;
-        minMaxFrames.min = Tools.FloatRound(minFrame / fps);
-        var keyFrames = animation.getKeys();
-        for (var i = 0, length_1 = keyFrames.length; i < length_1; ++i) {
-            endFrame = null;
-            currKeyFrame = keyFrames[i];
-            if (i + 1 < length_1) {
-                nextKeyFrame = keyFrames[i + 1];
-                if ((currKeyFrame.value.equals && currKeyFrame.value.equals(nextKeyFrame.value)) || currKeyFrame.value === nextKeyFrame.value) {
-                    if (i === 0) {
-                        // set the first frame to itself
-                        endFrame = currKeyFrame.frame;
-                    }
-                    else {
-                        continue;
-                    }
-                }
-                else {
-                    endFrame = nextKeyFrame.frame;
-                }
-            }
-            else {
-                // at the last key frame
-                prevKeyFrame = keyFrames[i - 1];
-                if ((currKeyFrame.value.equals && currKeyFrame.value.equals(prevKeyFrame.value)) || currKeyFrame.value === prevKeyFrame.value) {
-                    continue;
-                }
-                else {
-                    endFrame = maxFrame;
-                }
-            }
-            if (endFrame) {
-                for (var f = currKeyFrame.frame; f <= endFrame; f += sampleRate) {
-                    time = Tools.FloatRound(f / fps);
-                    if (time === previousTime) {
-                        continue;
-                    }
-                    previousTime = time;
-                    maxUsedFrame = time;
-                    var state = {
-                        key: 0,
-                        repeatCount: 0,
-                        loopMode: animation.loopMode,
-                    };
-                    value = animation._interpolate(f, state);
-                    _GLTFAnimation._SetInterpolatedValue(babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, convertToRightHandedSystem, useQuaternion);
-                }
-            }
-        }
-        if (maxUsedFrame) {
-            minMaxFrames.max = maxUsedFrame;
-        }
-    };
-    _GLTFAnimation._ConvertFactorToVector3OrQuaternion = function (factor, babylonTransformNode, animation, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
-        var property;
-        var componentName;
-        var value = null;
-        var basePositionRotationOrScale = _GLTFAnimation._GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
-        if (animationType === Animation.ANIMATIONTYPE_FLOAT) {
-            // handles single component x, y, z or w component animation by using a base property and animating over a component.
-            property = animation.targetProperty.split(".");
-            componentName = property ? property[1] : ""; // x, y, or z component
-            value = useQuaternion ? Quaternion.FromArray(basePositionRotationOrScale).normalize() : Vector3.FromArray(basePositionRotationOrScale);
-            switch (componentName) {
-                case "x": {
-                    value[componentName] = convertToRightHandedSystem && useQuaternion && animationChannelTargetPath !== "scale" /* SCALE */ ? -factor : factor;
-                    break;
-                }
-                case "y": {
-                    value[componentName] = convertToRightHandedSystem && useQuaternion && animationChannelTargetPath !== "scale" /* SCALE */ ? -factor : factor;
-                    break;
-                }
-                case "z": {
-                    value[componentName] = convertToRightHandedSystem && !useQuaternion && animationChannelTargetPath !== "scale" /* SCALE */ ? -factor : factor;
-                    break;
-                }
-                case "w": {
-                    value.w = factor;
-                    break;
-                }
-                default: {
-                    Tools.Error("glTFAnimation: Unsupported component type \"".concat(componentName, "\" for scale animation!"));
-                }
-            }
-        }
-        return value;
-    };
-    _GLTFAnimation._SetInterpolatedValue = function (babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
-        var animationType = animation.dataType;
-        var cacheValue;
-        inputs.push(time);
-        if (typeof value === "number" && babylonTransformNode instanceof TransformNode) {
-            value = this._ConvertFactorToVector3OrQuaternion(value, babylonTransformNode, animation, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
-        }
-        if (value) {
-            if (animationChannelTargetPath === "rotation" /* ROTATION */) {
-                if (useQuaternion) {
-                    quaternionCache = value;
-                }
-                else {
-                    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 if (animationChannelTargetPath === "weights" /* WEIGHTS */) {
-                outputs.push([value]);
-            }
-            else {
-                // scaling and position animation
-                cacheValue = value;
-                if (convertToRightHandedSystem && animationChannelTargetPath !== "scale" /* SCALE */) {
-                    _GLTFUtilities._GetRightHandedPositionVector3FromRef(cacheValue);
-                    if (!babylonTransformNode.parent) {
-                        cacheValue.x *= -1;
-                        cacheValue.z *= -1;
-                    }
-                }
-                outputs.push(cacheValue.asArray());
-            }
-        }
-    };
-    /**
-     * Creates linear animation from the animation key frames
-     * @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
-     */
-    _GLTFAnimation._CreateLinearOrStepAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
-        for (var _i = 0, _a = animation.getKeys(); _i < _a.length; _i++) {
-            var keyFrame = _a[_i];
-            inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
-            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion);
-        }
-    };
-    /**
-     * Creates cubic spline animation from the animation key frames
-     * @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
-     */
-    _GLTFAnimation._CreateCubicSplineAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
-        animation.getKeys().forEach(function (keyFrame) {
-            inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
-            _GLTFAnimation._AddSplineTangent(babylonTransformNode, _TangentType.INTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* CUBICSPLINE */, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem);
-            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion);
-            _GLTFAnimation._AddSplineTangent(babylonTransformNode, _TangentType.OUTTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* CUBICSPLINE */, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem);
-        });
-    };
-    _GLTFAnimation._GetBasePositionRotationOrScale = function (babylonTransformNode, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
-        var basePositionRotationOrScale;
-        if (animationChannelTargetPath === "rotation" /* ROTATION */) {
-            if (useQuaternion) {
-                if (babylonTransformNode.rotationQuaternion) {
-                    basePositionRotationOrScale = babylonTransformNode.rotationQuaternion.asArray();
-                    if (convertToRightHandedSystem) {
-                        _GLTFUtilities._GetRightHandedQuaternionArrayFromRef(basePositionRotationOrScale);
-                        if (!babylonTransformNode.parent) {
-                            basePositionRotationOrScale = Quaternion.FromArray([0, 1, 0, 0]).multiply(Quaternion.FromArray(basePositionRotationOrScale)).asArray();
-                        }
-                    }
-                }
-                else {
-                    basePositionRotationOrScale = Quaternion.Identity().asArray();
-                }
-            }
-            else {
-                basePositionRotationOrScale = babylonTransformNode.rotation.asArray();
-                _GLTFUtilities._GetRightHandedNormalArray3FromRef(basePositionRotationOrScale);
-            }
-        }
-        else if (animationChannelTargetPath === "translation" /* TRANSLATION */) {
-            basePositionRotationOrScale = babylonTransformNode.position.asArray();
-            if (convertToRightHandedSystem) {
-                _GLTFUtilities._GetRightHandedPositionArray3FromRef(basePositionRotationOrScale);
-            }
-        }
-        else {
-            // scale
-            basePositionRotationOrScale = babylonTransformNode.scaling.asArray();
-        }
-        return basePositionRotationOrScale;
-    };
-    /**
-     * Adds a key frame value
-     * @param keyFrame
-     * @param animation
-     * @param outputs
-     * @param animationChannelTargetPath
-     * @param babylonTransformNode
-     * @param convertToRightHandedSystem
-     * @param useQuaternion
-     */
-    _GLTFAnimation._AddKeyframeValue = function (keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion) {
-        var value;
-        var newPositionRotationOrScale;
-        var animationType = animation.dataType;
-        if (animationType === Animation.ANIMATIONTYPE_VECTOR3) {
-            value = keyFrame.value.asArray();
-            if (animationChannelTargetPath === "rotation" /* ROTATION */) {
-                var array = Vector3.FromArray(value);
-                var 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);
-                    }
-                }
-                value = rotationQuaternion.asArray();
-            }
-            else if (animationChannelTargetPath === "translation" /* 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) {
-            if (animationChannelTargetPath === "weights" /* WEIGHTS */) {
-                outputs.push([keyFrame.value]);
-            }
-            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, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
-                if (newPositionRotationOrScale) {
-                    if (animationChannelTargetPath === "rotation" /* ROTATION */) {
-                        var 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" /* 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);
-        }
-        else {
-            Tools.Error("glTFAnimation: Unsupported key frame values for animation!");
-        }
-    };
-    /**
-     * Determine the interpolation based on the key frames
-     * @param keyFrames
-     * @param animationChannelTargetPath
-     * @param useQuaternion
-     */
-    _GLTFAnimation._DeduceInterpolation = function (keyFrames, animationChannelTargetPath, useQuaternion) {
-        var interpolationType;
-        var shouldBakeAnimation = false;
-        var key;
-        if (animationChannelTargetPath === "rotation" /* ROTATION */ && !useQuaternion) {
-            return { interpolationType: "LINEAR" /* LINEAR */, shouldBakeAnimation: true };
-        }
-        for (var i = 0, length_2 = keyFrames.length; i < length_2; ++i) {
-            key = keyFrames[i];
-            if (key.inTangent || key.outTangent) {
-                if (interpolationType) {
-                    if (interpolationType !== "CUBICSPLINE" /* CUBICSPLINE */) {
-                        interpolationType = "LINEAR" /* LINEAR */;
-                        shouldBakeAnimation = true;
-                        break;
-                    }
-                }
-                else {
-                    interpolationType = "CUBICSPLINE" /* CUBICSPLINE */;
-                }
-            }
-            else {
-                if (interpolationType) {
-                    if (interpolationType === "CUBICSPLINE" /* CUBICSPLINE */ ||
-                        (key.interpolation && key.interpolation === AnimationKeyInterpolation.STEP && interpolationType !== "STEP" /* STEP */)) {
-                        interpolationType = "LINEAR" /* LINEAR */;
-                        shouldBakeAnimation = true;
-                        break;
-                    }
-                }
-                else {
-                    if (key.interpolation && key.interpolation === AnimationKeyInterpolation.STEP) {
-                        interpolationType = "STEP" /* STEP */;
-                    }
-                    else {
-                        interpolationType = "LINEAR" /* LINEAR */;
-                    }
-                }
-            }
-        }
-        if (!interpolationType) {
-            interpolationType = "LINEAR" /* LINEAR */;
-        }
-        return { interpolationType: interpolationType, shouldBakeAnimation: shouldBakeAnimation };
-    };
-    /**
-     * Adds an input tangent or output tangent to the output data
-     * If an input tangent or output tangent is missing, it uses the zero vector or zero quaternion
-     * @param babylonTransformNode
-     * @param tangentType Specifies which type of tangent to handle (inTangent or outTangent)
-     * @param outputs The animation data by keyframe
-     * @param animationChannelTargetPath The target animation channel
-     * @param interpolation The interpolation type
-     * @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
-     */
-    _GLTFAnimation._AddSplineTangent = function (babylonTransformNode, tangentType, outputs, animationChannelTargetPath, interpolation, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem) {
-        var tangent;
-        var tangentValue = tangentType === _TangentType.INTANGENT ? keyFrame.inTangent : keyFrame.outTangent;
-        if (interpolation === "CUBICSPLINE" /* CUBICSPLINE */) {
-            if (animationChannelTargetPath === "rotation" /* ROTATION */) {
-                if (tangentValue) {
-                    if (useQuaternion) {
-                        tangent = tangentValue.asArray();
-                    }
-                    else {
-                        var 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];
-                }
-            }
-            else if (animationChannelTargetPath === "weights" /* WEIGHTS */) {
-                if (tangentValue) {
-                    tangent = [tangentValue];
-                }
-                else {
-                    tangent = [0];
-                }
-            }
-            else {
-                if (tangentValue) {
-                    tangent = tangentValue.asArray();
-                    if (convertToRightHandedSystem) {
-                        if (animationChannelTargetPath === "translation" /* TRANSLATION */) {
-                            _GLTFUtilities._GetRightHandedPositionArray3FromRef(tangent);
-                            if (!babylonTransformNode.parent) {
-                                tangent[0] *= -1; // x
-                                tangent[2] *= -1; // z
-                            }
-                        }
-                    }
-                }
-                else {
-                    tangent = [0, 0, 0];
-                }
-            }
-            outputs.push(tangent);
-        }
-    };
-    /**
-     * Get the minimum and maximum key frames' frame values
-     * @param keyFrames animation key frames
-     * @returns the minimum and maximum key frame value
-     */
-    _GLTFAnimation._CalculateMinMaxKeyFrames = function (keyFrames) {
-        var min = Infinity;
-        var max = -Infinity;
-        keyFrames.forEach(function (keyFrame) {
-            min = Math.min(min, keyFrame.frame);
-            max = Math.max(max, keyFrame.frame);
-        });
-        return { min: min, max: max };
-    };
-    return _GLTFAnimation;
-}());
-export { _GLTFAnimation };
+import { Vector3, Quaternion } from "@babylonjs/core/Maths/math.vector.js";
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+import { Animation } from "@babylonjs/core/Animations/animation.js";
+import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import { MorphTarget } from "@babylonjs/core/Morph/morphTarget.js";
+import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import { _GLTFUtilities } from "./glTFUtilities.js";
+import { AnimationKeyInterpolation } from "@babylonjs/core/Animations/animationKey.js";
+/**
+ * @hidden
+ * Enum for handling in tangent and out tangent.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+var _TangentType;
+(function (_TangentType) {
+    /**
+     * Specifies that input tangents are used.
+     */
+    _TangentType[_TangentType["INTANGENT"] = 0] = "INTANGENT";
+    /**
+     * Specifies that output tangents are used.
+     */
+    _TangentType[_TangentType["OUTTANGENT"] = 1] = "OUTTANGENT";
+})(_TangentType || (_TangentType = {}));
+/**
+ * @hidden
+ * Utility class for generating glTF animation data from BabylonJS.
+ */
+var _GLTFAnimation = /** @class */ (function () {
+    function _GLTFAnimation() {
+    }
+    /**
+     * @ignore
+     *
+     * Creates glTF channel animation from BabylonJS animation.
+     * @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
+     */
+    _GLTFAnimation._CreateNodeAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate) {
+        var inputs = [];
+        var outputs = [];
+        var keyFrames = animation.getKeys();
+        var minMaxKeyFrames = _GLTFAnimation._CalculateMinMaxKeyFrames(keyFrames);
+        var interpolationOrBake = _GLTFAnimation._DeduceInterpolation(keyFrames, animationChannelTargetPath, useQuaternion);
+        var frameDelta = minMaxKeyFrames.max - minMaxKeyFrames.min;
+        var interpolation = interpolationOrBake.interpolationType;
+        var shouldBakeAnimation = interpolationOrBake.shouldBakeAnimation;
+        if (shouldBakeAnimation) {
+            _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
+        }
+        else {
+            if (interpolation === "LINEAR" /* LINEAR */ || interpolation === "STEP" /* STEP */) {
+                _GLTFAnimation._CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+            }
+            else if (interpolation === "CUBICSPLINE" /* CUBICSPLINE */) {
+                _GLTFAnimation._CreateCubicSplineAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+            }
+            else {
+                _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
+            }
+        }
+        if (inputs.length && outputs.length) {
+            var result = {
+                inputs: inputs,
+                outputs: outputs,
+                samplerInterpolation: interpolation,
+                inputsMin: shouldBakeAnimation ? minMaxKeyFrames.min : Tools.FloatRound(minMaxKeyFrames.min / animation.framePerSecond),
+                inputsMax: shouldBakeAnimation ? minMaxKeyFrames.max : Tools.FloatRound(minMaxKeyFrames.max / animation.framePerSecond),
+            };
+            return result;
+        }
+        return null;
+    };
+    _GLTFAnimation._DeduceAnimationInfo = function (animation) {
+        var animationChannelTargetPath = null;
+        var dataAccessorType = "VEC3" /* VEC3 */;
+        var useQuaternion = false;
+        var property = animation.targetProperty.split(".");
+        switch (property[0]) {
+            case "scaling": {
+                animationChannelTargetPath = "scale" /* SCALE */;
+                break;
+            }
+            case "position": {
+                animationChannelTargetPath = "translation" /* TRANSLATION */;
+                break;
+            }
+            case "rotation": {
+                dataAccessorType = "VEC4" /* VEC4 */;
+                animationChannelTargetPath = "rotation" /* ROTATION */;
+                break;
+            }
+            case "rotationQuaternion": {
+                dataAccessorType = "VEC4" /* VEC4 */;
+                useQuaternion = true;
+                animationChannelTargetPath = "rotation" /* ROTATION */;
+                break;
+            }
+            case "influence": {
+                dataAccessorType = "SCALAR" /* SCALAR */;
+                animationChannelTargetPath = "weights" /* WEIGHTS */;
+                break;
+            }
+            default: {
+                Tools.Error("Unsupported animatable property ".concat(property[0]));
+            }
+        }
+        if (animationChannelTargetPath) {
+            return { animationChannelTargetPath: animationChannelTargetPath, dataAccessorType: dataAccessorType, useQuaternion: useQuaternion };
+        }
+        else {
+            Tools.Error("animation channel target path and data accessor type could be deduced");
+        }
+        return null;
+    };
+    /**
+     * @ignore
+     * Create node animations from the transform node animations
+     * @param babylonNode
+     * @param runtimeGLTFAnimation
+     * @param idleGLTFAnimations
+     * @param nodeMap
+     * @param nodes
+     * @param binaryWriter
+     * @param bufferViews
+     * @param accessors
+     * @param convertToRightHandedSystem
+     * @param animationSampleRate
+     */
+    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate) {
+        var glTFAnimation;
+        if (babylonNode instanceof TransformNode) {
+            if (babylonNode.animations) {
+                for (var _i = 0, _a = babylonNode.animations; _i < _a.length; _i++) {
+                    var animation = _a[_i];
+                    var animationInfo = _GLTFAnimation._DeduceAnimationInfo(animation);
+                    if (animationInfo) {
+                        glTFAnimation = {
+                            name: animation.name,
+                            samplers: [],
+                            channels: [],
+                        };
+                        _GLTFAnimation._AddAnimation("".concat(animation.name), animation.hasRunningRuntimeAnimations ? runtimeGLTFAnimation : glTFAnimation, babylonNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate);
+                        if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
+                            idleGLTFAnimations.push(glTFAnimation);
+                        }
+                    }
+                }
+            }
+        }
+    };
+    /**
+     * @ignore
+     * Create individual morph animations from the mesh's morph target animation tracks
+     * @param babylonNode
+     * @param runtimeGLTFAnimation
+     * @param idleGLTFAnimations
+     * @param nodeMap
+     * @param nodes
+     * @param binaryWriter
+     * @param bufferViews
+     * @param accessors
+     * @param convertToRightHandedSystem
+     * @param animationSampleRate
+     */
+    _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate) {
+        var glTFAnimation;
+        if (babylonNode instanceof Mesh) {
+            var morphTargetManager = babylonNode.morphTargetManager;
+            if (morphTargetManager) {
+                for (var i = 0; i < morphTargetManager.numTargets; ++i) {
+                    var morphTarget = morphTargetManager.getTarget(i);
+                    for (var _i = 0, _a = morphTarget.animations; _i < _a.length; _i++) {
+                        var animation = _a[_i];
+                        var combinedAnimation = new Animation("".concat(animation.name), "influence", animation.framePerSecond, animation.dataType, animation.loopMode, animation.enableBlending);
+                        var combinedAnimationKeys = [];
+                        var animationKeys = animation.getKeys();
+                        for (var j = 0; j < animationKeys.length; ++j) {
+                            var animationKey = animationKeys[j];
+                            for (var k = 0; k < morphTargetManager.numTargets; ++k) {
+                                if (k == i) {
+                                    combinedAnimationKeys.push(animationKey);
+                                }
+                                else {
+                                    combinedAnimationKeys.push({ frame: animationKey.frame, value: 0 });
+                                }
+                            }
+                        }
+                        combinedAnimation.setKeys(combinedAnimationKeys);
+                        var animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimation);
+                        if (animationInfo) {
+                            glTFAnimation = {
+                                name: combinedAnimation.name,
+                                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);
+                            if (glTFAnimation.samplers.length && glTFAnimation.channels.length) {
+                                idleGLTFAnimations.push(glTFAnimation);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    };
+    /**
+     * @ignore
+     * Create node and morph animations from the animation groups
+     * @param babylonScene
+     * @param glTFAnimations
+     * @param nodeMap
+     * @param nodes
+     * @param binaryWriter
+     * @param bufferViews
+     * @param accessors
+     * @param convertToRightHandedSystemMap
+     * @param animationSampleRate
+     */
+    _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups = function (babylonScene, glTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystemMap, animationSampleRate) {
+        var _a;
+        var glTFAnimation;
+        if (babylonScene.animationGroups) {
+            var animationGroups = babylonScene.animationGroups;
+            var _loop_1 = function (animationGroup) {
+                var morphAnimations = new Map();
+                var sampleAnimations = new Map();
+                var morphAnimationMeshes = new Set();
+                var animationGroupFrameDiff = animationGroup.to - animationGroup.from;
+                glTFAnimation = {
+                    name: animationGroup.name,
+                    channels: [],
+                    samplers: [],
+                };
+                var _loop_2 = function (i) {
+                    var targetAnimation = animationGroup.targetedAnimations[i];
+                    var target = targetAnimation.target;
+                    var animation = targetAnimation.animation;
+                    if (target instanceof TransformNode || (target.length === 1 && target[0] instanceof TransformNode)) {
+                        var animationInfo = _GLTFAnimation._DeduceAnimationInfo(targetAnimation.animation);
+                        if (animationInfo) {
+                            var babylonTransformNode = target instanceof TransformNode ? target : target[0];
+                            var convertToRightHandedSystem = convertToRightHandedSystemMap[babylonTransformNode.uniqueId];
+                            _GLTFAnimation._AddAnimation("".concat(animation.name), glTFAnimation, babylonTransformNode, animation, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationInfo.useQuaternion, animationSampleRate);
+                        }
+                    }
+                    else if (target instanceof MorphTarget || (target.length === 1 && target[0] instanceof MorphTarget)) {
+                        var animationInfo = _GLTFAnimation._DeduceAnimationInfo(targetAnimation.animation);
+                        if (animationInfo) {
+                            var babylonMorphTarget_1 = target instanceof MorphTarget ? target : target[0];
+                            if (babylonMorphTarget_1) {
+                                var babylonMorphTargetManager_1 = babylonScene.morphTargetManagers.find(function (morphTargetManager) {
+                                    for (var j = 0; j < morphTargetManager.numTargets; ++j) {
+                                        if (morphTargetManager.getTarget(j) === babylonMorphTarget_1) {
+                                            return true;
+                                        }
+                                    }
+                                    return false;
+                                });
+                                if (babylonMorphTargetManager_1) {
+                                    var babylonMesh = babylonScene.meshes.find(function (mesh) {
+                                        return mesh.morphTargetManager === babylonMorphTargetManager_1;
+                                    });
+                                    if (babylonMesh) {
+                                        if (!morphAnimations.has(babylonMesh)) {
+                                            morphAnimations.set(babylonMesh, new Map());
+                                        }
+                                        (_a = morphAnimations.get(babylonMesh)) === null || _a === void 0 ? void 0 : _a.set(babylonMorphTarget_1, animation);
+                                        morphAnimationMeshes.add(babylonMesh);
+                                        sampleAnimations.set(babylonMesh, animation);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
+                for (var i = 0; i < animationGroup.targetedAnimations.length; ++i) {
+                    _loop_2(i);
+                }
+                morphAnimationMeshes.forEach(function (mesh) {
+                    var morphTargetManager = mesh.morphTargetManager;
+                    var combinedAnimationGroup = null;
+                    var animationKeys = [];
+                    var sampleAnimation = sampleAnimations.get(mesh);
+                    var sampleAnimationKeys = sampleAnimation.getKeys();
+                    var numAnimationKeys = sampleAnimationKeys.length;
+                    /*
+                        Due to how glTF expects morph target animation data to be formatted, we need to rearrange the individual morph target animation tracks,
+                        such that we have a single animation, where a given keyframe input value has successive output values for each morph target belonging to the manager.
+                        See: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+
+                        We do this via constructing a new Animation track, and interleaving the frames of each morph target animation track in the current Animation Group
+                        We reuse the Babylon Animation data structure for ease of handling export of cubic spline animation keys, and to reuse the
+                        existing _GLTFAnimation.AddAnimation codepath with minimal modification, however the constructed Babylon Animation is NOT intended for use in-engine.
+                    */
+                    for (var i = 0; i < numAnimationKeys; ++i) {
+                        for (var j = 0; j < morphTargetManager.numTargets; ++j) {
+                            var morphTarget = morphTargetManager.getTarget(j);
+                            var animationsByMorphTarget = morphAnimations.get(mesh);
+                            if (animationsByMorphTarget) {
+                                var morphTargetAnimation = animationsByMorphTarget.get(morphTarget);
+                                if (morphTargetAnimation) {
+                                    if (!combinedAnimationGroup) {
+                                        combinedAnimationGroup = new Animation("".concat(animationGroup.name, "_").concat(mesh.name, "_MorphWeightAnimation"), "influence", morphTargetAnimation.framePerSecond, Animation.ANIMATIONTYPE_FLOAT, morphTargetAnimation.loopMode, morphTargetAnimation.enableBlending);
+                                    }
+                                    animationKeys.push(morphTargetAnimation.getKeys()[i]);
+                                }
+                                else {
+                                    animationKeys.push({
+                                        frame: animationGroup.from + (animationGroupFrameDiff / numAnimationKeys) * i,
+                                        value: morphTarget.influence,
+                                        inTangent: sampleAnimationKeys[0].inTangent ? 0 : undefined,
+                                        outTangent: sampleAnimationKeys[0].outTangent ? 0 : undefined,
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    combinedAnimationGroup.setKeys(animationKeys);
+                    var animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimationGroup);
+                    if (animationInfo) {
+                        _GLTFAnimation._AddAnimation("".concat(animationGroup.name, "_").concat(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);
+                    }
+                });
+                if (glTFAnimation.channels.length && glTFAnimation.samplers.length) {
+                    glTFAnimations.push(glTFAnimation);
+                }
+            };
+            for (var _i = 0, animationGroups_1 = animationGroups; _i < animationGroups_1.length; _i++) {
+                var animationGroup = animationGroups_1[_i];
+                _loop_1(animationGroup);
+            }
+        }
+    };
+    _GLTFAnimation._AddAnimation = function (name, glTFAnimation, babylonTransformNode, animation, dataAccessorType, animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, useQuaternion, animationSampleRate, morphAnimationChannels) {
+        var animationData = _GLTFAnimation._CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate);
+        var bufferView;
+        var accessor;
+        var keyframeAccessorIndex;
+        var dataAccessorIndex;
+        var outputLength;
+        var animationSampler;
+        var animationChannel;
+        if (animationData) {
+            /*
+             * Now that we have the glTF converted morph target animation data,
+             * we can remove redundant input data so that we have n input frames,
+             * and morphAnimationChannels * n output frames
+             */
+            if (morphAnimationChannels) {
+                var index = 0;
+                var currentInput = 0;
+                var newInputs = [];
+                while (animationData.inputs.length > 0) {
+                    currentInput = animationData.inputs.shift();
+                    if (index % morphAnimationChannels == 0) {
+                        newInputs.push(currentInput);
+                    }
+                    index++;
+                }
+                animationData.inputs = newInputs;
+            }
+            var nodeIndex = nodeMap[babylonTransformNode.uniqueId];
+            // Creates buffer view and accessor for key frames.
+            var byteLength = animationData.inputs.length * 4;
+            bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, undefined, "".concat(name, "  keyframe data view"));
+            bufferViews.push(bufferView);
+            animationData.inputs.forEach(function (input) {
+                binaryWriter.setFloat32(input);
+            });
+            accessor = _GLTFUtilities._CreateAccessor(bufferViews.length - 1, "".concat(name, "  keyframes"), "SCALAR" /* SCALAR */, 5126 /* FLOAT */, animationData.inputs.length, null, [animationData.inputsMin], [animationData.inputsMax]);
+            accessors.push(accessor);
+            keyframeAccessorIndex = accessors.length - 1;
+            // create bufferview and accessor for keyed values.
+            outputLength = animationData.outputs.length;
+            byteLength = _GLTFUtilities._GetDataAccessorElementCount(dataAccessorType) * 4 * animationData.outputs.length;
+            // check for in and out tangents
+            bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, undefined, "".concat(name, "  data view"));
+            bufferViews.push(bufferView);
+            animationData.outputs.forEach(function (output) {
+                output.forEach(function (entry) {
+                    binaryWriter.setFloat32(entry);
+                });
+            });
+            accessor = _GLTFUtilities._CreateAccessor(bufferViews.length - 1, "".concat(name, "  data"), dataAccessorType, 5126 /* FLOAT */, outputLength, null, null, null);
+            accessors.push(accessor);
+            dataAccessorIndex = accessors.length - 1;
+            // create sampler
+            animationSampler = {
+                interpolation: animationData.samplerInterpolation,
+                input: keyframeAccessorIndex,
+                output: dataAccessorIndex,
+            };
+            glTFAnimation.samplers.push(animationSampler);
+            // create channel
+            animationChannel = {
+                sampler: glTFAnimation.samplers.length - 1,
+                target: {
+                    node: nodeIndex,
+                    path: animationChannelTargetPath,
+                },
+            };
+            glTFAnimation.channels.push(animationChannel);
+        }
+    };
+    /**
+     * Create a baked animation
+     * @param babylonTransformNode BabylonJS mesh
+     * @param animation BabylonJS animation corresponding to the BabylonJS mesh
+     * @param animationChannelTargetPath animation target channel
+     * @param minFrame minimum animation frame
+     * @param maxFrame maximum animation frame
+     * @param fps frames per second of the animation
+     * @param sampleRate
+     * @param inputs input key frames of the animation
+     * @param outputs output key frame data of the animation
+     * @param minMaxFrames
+     * @param minMaxFrames.min
+     * @param minMaxFrames.max
+     * @param convertToRightHandedSystem converts the values to right-handed
+     * @param useQuaternion specifies if quaternions should be used
+     */
+    _GLTFAnimation._CreateBakedAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, minFrame, maxFrame, fps, sampleRate, inputs, outputs, minMaxFrames, convertToRightHandedSystem, useQuaternion) {
+        var value;
+        var quaternionCache = Quaternion.Identity();
+        var previousTime = null;
+        var time;
+        var maxUsedFrame = null;
+        var currKeyFrame = null;
+        var nextKeyFrame = null;
+        var prevKeyFrame = null;
+        var endFrame = null;
+        minMaxFrames.min = Tools.FloatRound(minFrame / fps);
+        var keyFrames = animation.getKeys();
+        for (var i = 0, length_1 = keyFrames.length; i < length_1; ++i) {
+            endFrame = null;
+            currKeyFrame = keyFrames[i];
+            if (i + 1 < length_1) {
+                nextKeyFrame = keyFrames[i + 1];
+                if ((currKeyFrame.value.equals && currKeyFrame.value.equals(nextKeyFrame.value)) || currKeyFrame.value === nextKeyFrame.value) {
+                    if (i === 0) {
+                        // set the first frame to itself
+                        endFrame = currKeyFrame.frame;
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                else {
+                    endFrame = nextKeyFrame.frame;
+                }
+            }
+            else {
+                // at the last key frame
+                prevKeyFrame = keyFrames[i - 1];
+                if ((currKeyFrame.value.equals && currKeyFrame.value.equals(prevKeyFrame.value)) || currKeyFrame.value === prevKeyFrame.value) {
+                    continue;
+                }
+                else {
+                    endFrame = maxFrame;
+                }
+            }
+            if (endFrame) {
+                for (var f = currKeyFrame.frame; f <= endFrame; f += sampleRate) {
+                    time = Tools.FloatRound(f / fps);
+                    if (time === previousTime) {
+                        continue;
+                    }
+                    previousTime = time;
+                    maxUsedFrame = time;
+                    var state = {
+                        key: 0,
+                        repeatCount: 0,
+                        loopMode: animation.loopMode,
+                    };
+                    value = animation._interpolate(f, state);
+                    _GLTFAnimation._SetInterpolatedValue(babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, convertToRightHandedSystem, useQuaternion);
+                }
+            }
+        }
+        if (maxUsedFrame) {
+            minMaxFrames.max = maxUsedFrame;
+        }
+    };
+    _GLTFAnimation._ConvertFactorToVector3OrQuaternion = function (factor, babylonTransformNode, animation, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
+        var property;
+        var componentName;
+        var value = null;
+        var basePositionRotationOrScale = _GLTFAnimation._GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+        if (animationType === Animation.ANIMATIONTYPE_FLOAT) {
+            // handles single component x, y, z or w component animation by using a base property and animating over a component.
+            property = animation.targetProperty.split(".");
+            componentName = property ? property[1] : ""; // x, y, or z component
+            value = useQuaternion ? Quaternion.FromArray(basePositionRotationOrScale).normalize() : Vector3.FromArray(basePositionRotationOrScale);
+            switch (componentName) {
+                case "x": {
+                    value[componentName] = convertToRightHandedSystem && useQuaternion && animationChannelTargetPath !== "scale" /* SCALE */ ? -factor : factor;
+                    break;
+                }
+                case "y": {
+                    value[componentName] = convertToRightHandedSystem && useQuaternion && animationChannelTargetPath !== "scale" /* SCALE */ ? -factor : factor;
+                    break;
+                }
+                case "z": {
+                    value[componentName] = convertToRightHandedSystem && !useQuaternion && animationChannelTargetPath !== "scale" /* SCALE */ ? -factor : factor;
+                    break;
+                }
+                case "w": {
+                    value.w = factor;
+                    break;
+                }
+                default: {
+                    Tools.Error("glTFAnimation: Unsupported component type \"".concat(componentName, "\" for scale animation!"));
+                }
+            }
+        }
+        return value;
+    };
+    _GLTFAnimation._SetInterpolatedValue = function (babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+        var animationType = animation.dataType;
+        var cacheValue;
+        inputs.push(time);
+        if (typeof value === "number" && babylonTransformNode instanceof TransformNode) {
+            value = this._ConvertFactorToVector3OrQuaternion(value, babylonTransformNode, animation, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+        }
+        if (value) {
+            if (animationChannelTargetPath === "rotation" /* ROTATION */) {
+                if (useQuaternion) {
+                    quaternionCache = value;
+                }
+                else {
+                    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 if (animationChannelTargetPath === "weights" /* WEIGHTS */) {
+                outputs.push([value]);
+            }
+            else {
+                // scaling and position animation
+                cacheValue = value;
+                if (convertToRightHandedSystem && animationChannelTargetPath !== "scale" /* SCALE */) {
+                    _GLTFUtilities._GetRightHandedPositionVector3FromRef(cacheValue);
+                    if (!babylonTransformNode.parent) {
+                        cacheValue.x *= -1;
+                        cacheValue.z *= -1;
+                    }
+                }
+                outputs.push(cacheValue.asArray());
+            }
+        }
+    };
+    /**
+     * Creates linear animation from the animation key frames
+     * @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
+     */
+    _GLTFAnimation._CreateLinearOrStepAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+        for (var _i = 0, _a = animation.getKeys(); _i < _a.length; _i++) {
+            var keyFrame = _a[_i];
+            inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
+            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion);
+        }
+    };
+    /**
+     * Creates cubic spline animation from the animation key frames
+     * @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
+     */
+    _GLTFAnimation._CreateCubicSplineAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+        animation.getKeys().forEach(function (keyFrame) {
+            inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
+            _GLTFAnimation._AddSplineTangent(babylonTransformNode, _TangentType.INTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* CUBICSPLINE */, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem);
+            _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion);
+            _GLTFAnimation._AddSplineTangent(babylonTransformNode, _TangentType.OUTTANGENT, outputs, animationChannelTargetPath, "CUBICSPLINE" /* CUBICSPLINE */, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem);
+        });
+    };
+    _GLTFAnimation._GetBasePositionRotationOrScale = function (babylonTransformNode, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
+        var basePositionRotationOrScale;
+        if (animationChannelTargetPath === "rotation" /* ROTATION */) {
+            if (useQuaternion) {
+                if (babylonTransformNode.rotationQuaternion) {
+                    basePositionRotationOrScale = babylonTransformNode.rotationQuaternion.asArray();
+                    if (convertToRightHandedSystem) {
+                        _GLTFUtilities._GetRightHandedQuaternionArrayFromRef(basePositionRotationOrScale);
+                        if (!babylonTransformNode.parent) {
+                            basePositionRotationOrScale = Quaternion.FromArray([0, 1, 0, 0]).multiply(Quaternion.FromArray(basePositionRotationOrScale)).asArray();
+                        }
+                    }
+                }
+                else {
+                    basePositionRotationOrScale = Quaternion.Identity().asArray();
+                }
+            }
+            else {
+                basePositionRotationOrScale = babylonTransformNode.rotation.asArray();
+                _GLTFUtilities._GetRightHandedNormalArray3FromRef(basePositionRotationOrScale);
+            }
+        }
+        else if (animationChannelTargetPath === "translation" /* TRANSLATION */) {
+            basePositionRotationOrScale = babylonTransformNode.position.asArray();
+            if (convertToRightHandedSystem) {
+                _GLTFUtilities._GetRightHandedPositionArray3FromRef(basePositionRotationOrScale);
+            }
+        }
+        else {
+            // scale
+            basePositionRotationOrScale = babylonTransformNode.scaling.asArray();
+        }
+        return basePositionRotationOrScale;
+    };
+    /**
+     * Adds a key frame value
+     * @param keyFrame
+     * @param animation
+     * @param outputs
+     * @param animationChannelTargetPath
+     * @param babylonTransformNode
+     * @param convertToRightHandedSystem
+     * @param useQuaternion
+     */
+    _GLTFAnimation._AddKeyframeValue = function (keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion) {
+        var value;
+        var newPositionRotationOrScale;
+        var animationType = animation.dataType;
+        if (animationType === Animation.ANIMATIONTYPE_VECTOR3) {
+            value = keyFrame.value.asArray();
+            if (animationChannelTargetPath === "rotation" /* ROTATION */) {
+                var array = Vector3.FromArray(value);
+                var 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);
+                    }
+                }
+                value = rotationQuaternion.asArray();
+            }
+            else if (animationChannelTargetPath === "translation" /* 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) {
+            if (animationChannelTargetPath === "weights" /* WEIGHTS */) {
+                outputs.push([keyFrame.value]);
+            }
+            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, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
+                if (newPositionRotationOrScale) {
+                    if (animationChannelTargetPath === "rotation" /* ROTATION */) {
+                        var 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" /* 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);
+        }
+        else {
+            Tools.Error("glTFAnimation: Unsupported key frame values for animation!");
+        }
+    };
+    /**
+     * Determine the interpolation based on the key frames
+     * @param keyFrames
+     * @param animationChannelTargetPath
+     * @param useQuaternion
+     */
+    _GLTFAnimation._DeduceInterpolation = function (keyFrames, animationChannelTargetPath, useQuaternion) {
+        var interpolationType;
+        var shouldBakeAnimation = false;
+        var key;
+        if (animationChannelTargetPath === "rotation" /* ROTATION */ && !useQuaternion) {
+            return { interpolationType: "LINEAR" /* LINEAR */, shouldBakeAnimation: true };
+        }
+        for (var i = 0, length_2 = keyFrames.length; i < length_2; ++i) {
+            key = keyFrames[i];
+            if (key.inTangent || key.outTangent) {
+                if (interpolationType) {
+                    if (interpolationType !== "CUBICSPLINE" /* CUBICSPLINE */) {
+                        interpolationType = "LINEAR" /* LINEAR */;
+                        shouldBakeAnimation = true;
+                        break;
+                    }
+                }
+                else {
+                    interpolationType = "CUBICSPLINE" /* CUBICSPLINE */;
+                }
+            }
+            else {
+                if (interpolationType) {
+                    if (interpolationType === "CUBICSPLINE" /* CUBICSPLINE */ ||
+                        (key.interpolation && key.interpolation === AnimationKeyInterpolation.STEP && interpolationType !== "STEP" /* STEP */)) {
+                        interpolationType = "LINEAR" /* LINEAR */;
+                        shouldBakeAnimation = true;
+                        break;
+                    }
+                }
+                else {
+                    if (key.interpolation && key.interpolation === AnimationKeyInterpolation.STEP) {
+                        interpolationType = "STEP" /* STEP */;
+                    }
+                    else {
+                        interpolationType = "LINEAR" /* LINEAR */;
+                    }
+                }
+            }
+        }
+        if (!interpolationType) {
+            interpolationType = "LINEAR" /* LINEAR */;
+        }
+        return { interpolationType: interpolationType, shouldBakeAnimation: shouldBakeAnimation };
+    };
+    /**
+     * Adds an input tangent or output tangent to the output data
+     * If an input tangent or output tangent is missing, it uses the zero vector or zero quaternion
+     * @param babylonTransformNode
+     * @param tangentType Specifies which type of tangent to handle (inTangent or outTangent)
+     * @param outputs The animation data by keyframe
+     * @param animationChannelTargetPath The target animation channel
+     * @param interpolation The interpolation type
+     * @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
+     */
+    _GLTFAnimation._AddSplineTangent = function (babylonTransformNode, tangentType, outputs, animationChannelTargetPath, interpolation, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem) {
+        var tangent;
+        var tangentValue = tangentType === _TangentType.INTANGENT ? keyFrame.inTangent : keyFrame.outTangent;
+        if (interpolation === "CUBICSPLINE" /* CUBICSPLINE */) {
+            if (animationChannelTargetPath === "rotation" /* ROTATION */) {
+                if (tangentValue) {
+                    if (useQuaternion) {
+                        tangent = tangentValue.asArray();
+                    }
+                    else {
+                        var 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];
+                }
+            }
+            else if (animationChannelTargetPath === "weights" /* WEIGHTS */) {
+                if (tangentValue) {
+                    tangent = [tangentValue];
+                }
+                else {
+                    tangent = [0];
+                }
+            }
+            else {
+                if (tangentValue) {
+                    tangent = tangentValue.asArray();
+                    if (convertToRightHandedSystem) {
+                        if (animationChannelTargetPath === "translation" /* TRANSLATION */) {
+                            _GLTFUtilities._GetRightHandedPositionArray3FromRef(tangent);
+                            if (!babylonTransformNode.parent) {
+                                tangent[0] *= -1; // x
+                                tangent[2] *= -1; // z
+                            }
+                        }
+                    }
+                }
+                else {
+                    tangent = [0, 0, 0];
+                }
+            }
+            outputs.push(tangent);
+        }
+    };
+    /**
+     * Get the minimum and maximum key frames' frame values
+     * @param keyFrames animation key frames
+     * @returns the minimum and maximum key frame value
+     */
+    _GLTFAnimation._CalculateMinMaxKeyFrames = function (keyFrames) {
+        var min = Infinity;
+        var max = -Infinity;
+        keyFrames.forEach(function (keyFrame) {
+            min = Math.min(min, keyFrame.frame);
+            max = Math.max(max, keyFrame.frame);
+        });
+        return { min: min, max: max };
+    };
+    return _GLTFAnimation;
+}());
+export { _GLTFAnimation };
 //# sourceMappingURL=glTFAnimation.js.map