@babylonjs/serializers 5.0.0-beta.8 → 5.0.0-beta.8-snapshot

package/glTF/2.0/glTFAnimation.js

@@ -1,840 +0,0 @@
-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.
- */
-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 inputs input key frames of the animation
-     * @param outputs output key frame data of the animation
-     * @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 basePositionRotationOrScale
-     * @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 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