@babylonjs/serializers 5.20.0 → 5.22.1

package/glTF/2.0/glTFAnimation.js

@@ -28,17 +28,15 @@ var _TangentType;
  * @hidden
  * Utility class for generating glTF animation data from BabylonJS.
  */
-var _GLTFAnimation = /** @class */ (function () {
-    function _GLTFAnimation() {
-    }
+export class _GLTFAnimation {
     /**
      * Determine if a node is transformable - ie has properties it should be part of animation of transformation.
      * @param babylonNode the node to test
      * @returns true if can be animated, false otherwise. False if the parameter is null or undefined.
      */
-    _GLTFAnimation._IsTransformable = function (babylonNode) {
+    static _IsTransformable(babylonNode) {
         return babylonNode && (babylonNode instanceof TransformNode || babylonNode instanceof Camera || babylonNode instanceof Light);
-    };
+    }
     /**
      * @ignore
      *
@@ -50,16 +48,16 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param useQuaternion - Specifies if quaternions are used.
      * @returns nullable IAnimationData
      */
-    _GLTFAnimation._CreateNodeAnimation = function (babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate) {
+    static _CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate) {
         if (this._IsTransformable(babylonTransformNode)) {
-            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;
+            const inputs = [];
+            const outputs = [];
+            const keyFrames = animation.getKeys();
+            const minMaxKeyFrames = _GLTFAnimation._CalculateMinMaxKeyFrames(keyFrames);
+            const interpolationOrBake = _GLTFAnimation._DeduceInterpolation(keyFrames, animationChannelTargetPath, useQuaternion);
+            const frameDelta = minMaxKeyFrames.max - minMaxKeyFrames.min;
+            const interpolation = interpolationOrBake.interpolationType;
+            const shouldBakeAnimation = interpolationOrBake.shouldBakeAnimation;
             if (shouldBakeAnimation) {
                 _GLTFAnimation._CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minMaxKeyFrames.min, minMaxKeyFrames.max, animation.framePerSecond, animationSampleRate, inputs, outputs, minMaxKeyFrames, convertToRightHandedSystem, useQuaternion);
             }
@@ -75,7 +73,7 @@ var _GLTFAnimation = /** @class */ (function () {
                 }
             }
             if (inputs.length && outputs.length) {
-                var result = {
+                const result = {
                     inputs: inputs,
                     outputs: outputs,
                     samplerInterpolation: interpolation,
@@ -86,12 +84,12 @@ var _GLTFAnimation = /** @class */ (function () {
             }
         }
         return null;
-    };
-    _GLTFAnimation._DeduceAnimationInfo = function (animation) {
-        var animationChannelTargetPath = null;
-        var dataAccessorType = "VEC3" /* VEC3 */;
-        var useQuaternion = false;
-        var property = animation.targetProperty.split(".");
+    }
+    static _DeduceAnimationInfo(animation) {
+        let animationChannelTargetPath = null;
+        let dataAccessorType = "VEC3" /* VEC3 */;
+        let useQuaternion = false;
+        const property = animation.targetProperty.split(".");
         switch (property[0]) {
             case "scaling": {
                 animationChannelTargetPath = "scale" /* SCALE */;
@@ -118,7 +116,7 @@ var _GLTFAnimation = /** @class */ (function () {
                 break;
             }
             default: {
-                Tools.Error("Unsupported animatable property ".concat(property[0]));
+                Tools.Error(`Unsupported animatable property ${property[0]}`);
             }
         }
         if (animationChannelTargetPath) {
@@ -128,7 +126,7 @@ var _GLTFAnimation = /** @class */ (function () {
             Tools.Error("animation channel target path and data accessor type could be deduced");
         }
         return null;
-    };
+    }
     /**
      * @ignore
      * Create node animations from the transform node animations
@@ -143,20 +141,19 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param convertToRightHandedSystem
      * @param animationSampleRate
      */
-    _GLTFAnimation._CreateNodeAnimationFromNodeAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate) {
-        var glTFAnimation;
+    static _CreateNodeAnimationFromNodeAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate) {
+        let glTFAnimation;
         if (_GLTFAnimation._IsTransformable(babylonNode)) {
             if (babylonNode.animations) {
-                for (var _i = 0, _a = babylonNode.animations; _i < _a.length; _i++) {
-                    var animation = _a[_i];
-                    var animationInfo = _GLTFAnimation._DeduceAnimationInfo(animation);
+                for (const animation of babylonNode.animations) {
+                    const 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);
+                        _GLTFAnimation._AddAnimation(`${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);
                         }
@@ -164,7 +161,7 @@ var _GLTFAnimation = /** @class */ (function () {
                 }
             }
         }
-    };
+    }
     /**
      * @ignore
      * Create individual morph animations from the mesh's morph target animation tracks
@@ -179,21 +176,20 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param convertToRightHandedSystem
      * @param animationSampleRate
      */
-    _GLTFAnimation._CreateMorphTargetAnimationFromMorphTargetAnimations = function (babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate) {
-        var glTFAnimation;
+    static _CreateMorphTargetAnimationFromMorphTargetAnimations(babylonNode, runtimeGLTFAnimation, idleGLTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, animationSampleRate) {
+        let glTFAnimation;
         if (babylonNode instanceof Mesh) {
-            var morphTargetManager = babylonNode.morphTargetManager;
+            const 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) {
+                for (let i = 0; i < morphTargetManager.numTargets; ++i) {
+                    const morphTarget = morphTargetManager.getTarget(i);
+                    for (const animation of morphTarget.animations) {
+                        const combinedAnimation = new Animation(`${animation.name}`, "influence", animation.framePerSecond, animation.dataType, animation.loopMode, animation.enableBlending);
+                        const combinedAnimationKeys = [];
+                        const animationKeys = animation.getKeys();
+                        for (let j = 0; j < animationKeys.length; ++j) {
+                            const animationKey = animationKeys[j];
+                            for (let k = 0; k < morphTargetManager.numTargets; ++k) {
                                 if (k == i) {
                                     combinedAnimationKeys.push(animationKey);
                                 }
@@ -203,7 +199,7 @@ var _GLTFAnimation = /** @class */ (function () {
                             }
                         }
                         combinedAnimation.setKeys(combinedAnimationKeys);
-                        var animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimation);
+                        const animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimation);
                         if (animationInfo) {
                             glTFAnimation = {
                                 name: combinedAnimation.name,
@@ -219,7 +215,7 @@ var _GLTFAnimation = /** @class */ (function () {
                 }
             }
         }
-    };
+    }
     /**
      * @ignore
      * Create node and morph animations from the animation groups
@@ -233,57 +229,56 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param convertToRightHandedSystemMap
      * @param animationSampleRate
      */
-    _GLTFAnimation._CreateNodeAndMorphAnimationFromAnimationGroups = function (babylonScene, glTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystemMap, animationSampleRate) {
-        var _a;
-        var glTFAnimation;
+    static _CreateNodeAndMorphAnimationFromAnimationGroups(babylonScene, glTFAnimations, nodeMap, nodes, binaryWriter, bufferViews, accessors, convertToRightHandedSystemMap, animationSampleRate) {
+        let 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;
+            const animationGroups = babylonScene.animationGroups;
+            for (const animationGroup of animationGroups) {
+                const morphAnimations = new Map();
+                const sampleAnimations = new Map();
+                const morphAnimationMeshes = new Set();
+                const 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 (this_1._IsTransformable(target) || (target.length === 1 && this_1._IsTransformable(target[0]))) {
-                        var animationInfo = _GLTFAnimation._DeduceAnimationInfo(targetAnimation.animation);
+                for (let i = 0; i < animationGroup.targetedAnimations.length; ++i) {
+                    const targetAnimation = animationGroup.targetedAnimations[i];
+                    const target = targetAnimation.target;
+                    const animation = targetAnimation.animation;
+                    if (this._IsTransformable(target) || (target.length === 1 && this._IsTransformable(target[0]))) {
+                        const animationInfo = _GLTFAnimation._DeduceAnimationInfo(targetAnimation.animation);
                         if (animationInfo) {
-                            var babylonTransformNode = this_1._IsTransformable(target) ? target : this_1._IsTransformable(target[0]) ? target[0] : null;
+                            const babylonTransformNode = this._IsTransformable(target) ? target : this._IsTransformable(target[0]) ? target[0] : null;
                             if (babylonTransformNode) {
-                                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);
+                                const convertToRightHandedSystem = convertToRightHandedSystemMap[babylonTransformNode.uniqueId];
+                                _GLTFAnimation._AddAnimation(`${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);
+                        const 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) {
+                            const babylonMorphTarget = target instanceof MorphTarget ? target : target[0];
+                            if (babylonMorphTarget) {
+                                const babylonMorphTargetManager = babylonScene.morphTargetManagers.find((morphTargetManager) => {
+                                    for (let j = 0; j < morphTargetManager.numTargets; ++j) {
+                                        if (morphTargetManager.getTarget(j) === babylonMorphTarget) {
                                             return true;
                                         }
                                     }
                                     return false;
                                 });
-                                if (babylonMorphTargetManager_1) {
-                                    var babylonMesh = babylonScene.meshes.find(function (mesh) {
-                                        return mesh.morphTargetManager === babylonMorphTargetManager_1;
+                                if (babylonMorphTargetManager) {
+                                    const babylonMesh = babylonScene.meshes.find((mesh) => {
+                                        return mesh.morphTargetManager === babylonMorphTargetManager;
                                     });
                                     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);
+                                        morphAnimations.get(babylonMesh)?.set(babylonMorphTarget, animation);
                                         morphAnimationMeshes.add(babylonMesh);
                                         sampleAnimations.set(babylonMesh, animation);
                                     }
@@ -294,17 +289,14 @@ var _GLTFAnimation = /** @class */ (function () {
                     else {
                         // this is the place for the KHR_animation_pointer.
                     }
-                };
-                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;
+                }
+                morphAnimationMeshes.forEach((mesh) => {
+                    const morphTargetManager = mesh.morphTargetManager;
+                    let combinedAnimationGroup = null;
+                    const animationKeys = [];
+                    const sampleAnimation = sampleAnimations.get(mesh);
+                    const sampleAnimationKeys = sampleAnimation.getKeys();
+                    const 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.
@@ -314,15 +306,15 @@ var _GLTFAnimation = /** @class */ (function () {
                         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);
+                    for (let i = 0; i < numAnimationKeys; ++i) {
+                        for (let j = 0; j < morphTargetManager.numTargets; ++j) {
+                            const morphTarget = morphTargetManager.getTarget(j);
+                            const animationsByMorphTarget = morphAnimations.get(mesh);
                             if (animationsByMorphTarget) {
-                                var morphTargetAnimation = animationsByMorphTarget.get(morphTarget);
+                                const 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);
+                                        combinedAnimationGroup = new Animation(`${animationGroup.name}_${mesh.name}_MorphWeightAnimation`, "influence", morphTargetAnimation.framePerSecond, Animation.ANIMATIONTYPE_FLOAT, morphTargetAnimation.loopMode, morphTargetAnimation.enableBlending);
                                     }
                                     animationKeys.push(morphTargetAnimation.getKeys()[i]);
                                 }
@@ -338,31 +330,26 @@ var _GLTFAnimation = /** @class */ (function () {
                         }
                     }
                     combinedAnimationGroup.setKeys(animationKeys);
-                    var animationInfo = _GLTFAnimation._DeduceAnimationInfo(combinedAnimationGroup);
+                    const 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);
+                        _GLTFAnimation._AddAnimation(`${animationGroup.name}_${mesh.name}_MorphWeightAnimation`, glTFAnimation, mesh, combinedAnimationGroup, animationInfo.dataAccessorType, animationInfo.animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, false, animationInfo.useQuaternion, animationSampleRate, morphTargetManager?.numTargets);
                     }
                 });
                 if (glTFAnimation.channels.length && glTFAnimation.samplers.length) {
                     glTFAnimations.push(glTFAnimation);
                 }
-            };
-            var this_1 = this;
-            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;
+    }
+    static _AddAnimation(name, glTFAnimation, babylonTransformNode, animation, dataAccessorType, animationChannelTargetPath, nodeMap, binaryWriter, bufferViews, accessors, convertToRightHandedSystem, useQuaternion, animationSampleRate, morphAnimationChannels) {
+        const animationData = _GLTFAnimation._CreateNodeAnimation(babylonTransformNode, animation, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion, animationSampleRate);
+        let bufferView;
+        let accessor;
+        let keyframeAccessorIndex;
+        let dataAccessorIndex;
+        let outputLength;
+        let animationSampler;
+        let animationChannel;
         if (animationData) {
             /*
              * Now that we have the glTF converted morph target animation data,
@@ -370,9 +357,9 @@ var _GLTFAnimation = /** @class */ (function () {
              * and morphAnimationChannels * n output frames
              */
             if (morphAnimationChannels) {
-                var index = 0;
-                var currentInput = 0;
-                var newInputs = [];
+                let index = 0;
+                let currentInput = 0;
+                const newInputs = [];
                 while (animationData.inputs.length > 0) {
                     currentInput = animationData.inputs.shift();
                     if (index % morphAnimationChannels == 0) {
@@ -382,29 +369,29 @@ var _GLTFAnimation = /** @class */ (function () {
                 }
                 animationData.inputs = newInputs;
             }
-            var nodeIndex = nodeMap[babylonTransformNode.uniqueId];
+            const 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"));
+            let byteLength = animationData.inputs.length * 4;
+            bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, undefined, `${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]);
+            accessor = _GLTFUtilities._CreateAccessor(bufferViews.length - 1, `${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"));
+            bufferView = _GLTFUtilities._CreateBufferView(0, binaryWriter.getByteOffset(), byteLength, undefined, `${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);
+            accessor = _GLTFUtilities._CreateAccessor(bufferViews.length - 1, `${name}  data`, dataAccessorType, 5126 /* FLOAT */, outputLength, null, null, null);
             accessors.push(accessor);
             dataAccessorIndex = accessors.length - 1;
             // create sampler
@@ -424,7 +411,7 @@ var _GLTFAnimation = /** @class */ (function () {
             };
             glTFAnimation.channels.push(animationChannel);
         }
-    };
+    }
     /**
      * Create a baked animation
      * @param babylonTransformNode BabylonJS mesh
@@ -442,22 +429,22 @@ var _GLTFAnimation = /** @class */ (function () {
      * @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;
+    static _CreateBakedAnimation(babylonTransformNode, animation, animationChannelTargetPath, minFrame, maxFrame, fps, sampleRate, inputs, outputs, minMaxFrames, convertToRightHandedSystem, useQuaternion) {
+        let value;
+        const quaternionCache = Quaternion.Identity();
+        let previousTime = null;
+        let time;
+        let maxUsedFrame = null;
+        let currKeyFrame = null;
+        let nextKeyFrame = null;
+        let prevKeyFrame = null;
+        let endFrame = null;
         minMaxFrames.min = Tools.FloatRound(minFrame / fps);
-        var keyFrames = animation.getKeys();
-        for (var i = 0, length_1 = keyFrames.length; i < length_1; ++i) {
+        const keyFrames = animation.getKeys();
+        for (let i = 0, length = keyFrames.length; i < length; ++i) {
             endFrame = null;
             currKeyFrame = keyFrames[i];
-            if (i + 1 < length_1) {
+            if (i + 1 < length) {
                 nextKeyFrame = keyFrames[i + 1];
                 if ((currKeyFrame.value.equals && currKeyFrame.value.equals(nextKeyFrame.value)) || currKeyFrame.value === nextKeyFrame.value) {
                     if (i === 0) {
@@ -483,14 +470,14 @@ var _GLTFAnimation = /** @class */ (function () {
                 }
             }
             if (endFrame) {
-                for (var f = currKeyFrame.frame; f <= endFrame; f += sampleRate) {
+                for (let f = currKeyFrame.frame; f <= endFrame; f += sampleRate) {
                     time = Tools.FloatRound(f / fps);
                     if (time === previousTime) {
                         continue;
                     }
                     previousTime = time;
                     maxUsedFrame = time;
-                    var state = {
+                    const state = {
                         key: 0,
                         repeatCount: 0,
                         loopMode: animation.loopMode,
@@ -503,12 +490,12 @@ var _GLTFAnimation = /** @class */ (function () {
         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);
+    }
+    static _ConvertFactorToVector3OrQuaternion(factor, babylonTransformNode, animation, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
+        let property;
+        let componentName;
+        let value = null;
+        const 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(".");
@@ -532,15 +519,15 @@ var _GLTFAnimation = /** @class */ (function () {
                     break;
                 }
                 default: {
-                    Tools.Error("glTFAnimation: Unsupported component type \"".concat(componentName, "\" for scale animation!"));
+                    Tools.Error(`glTFAnimation: Unsupported component type "${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;
+    }
+    static _SetInterpolatedValue(babylonTransformNode, value, time, animation, animationChannelTargetPath, quaternionCache, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+        const animationType = animation.dataType;
+        let cacheValue;
         inputs.push(time);
         if (value) {
             if (animationChannelTargetPath === "weights" /* WEIGHTS */) {
@@ -579,7 +566,7 @@ var _GLTFAnimation = /** @class */ (function () {
                 outputs.push(cacheValue.asArray());
             }
         }
-    };
+    }
     /**
      * Creates linear animation from the animation key frames
      * @param babylonTransformNode BabylonJS mesh
@@ -591,13 +578,12 @@ var _GLTFAnimation = /** @class */ (function () {
      * @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];
+    static _CreateLinearOrStepAnimation(babylonTransformNode, animation, animationChannelTargetPath, frameDelta, inputs, outputs, convertToRightHandedSystem, useQuaternion) {
+        for (const keyFrame of animation.getKeys()) {
             inputs.push(keyFrame.frame / animation.framePerSecond); // keyframes in seconds.
             _GLTFAnimation._AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion);
         }
-    };
+    }
     /**
      * Creates cubic spline animation from the animation key frames
      * @param babylonTransformNode BabylonJS mesh
@@ -609,20 +595,20 @@ var _GLTFAnimation = /** @class */ (function () {
      * @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) {
+    static _CreateCubicSplineAnimation(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;
+    }
+    static _GetBasePositionRotationOrScale(babylonTransformNode, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion) {
+        let basePositionRotationOrScale;
         if (animationChannelTargetPath === "rotation" /* ROTATION */) {
             if (useQuaternion) {
-                var q = babylonTransformNode.rotationQuaternion;
-                basePositionRotationOrScale = (q !== null && q !== void 0 ? q : Quaternion.Identity()).asArray();
+                const q = babylonTransformNode.rotationQuaternion;
+                basePositionRotationOrScale = (q ?? Quaternion.Identity()).asArray();
                 if (convertToRightHandedSystem) {
                     _GLTFUtilities._GetRightHandedQuaternionArrayFromRef(basePositionRotationOrScale);
                     if (!babylonTransformNode.parent) {
@@ -631,25 +617,25 @@ var _GLTFAnimation = /** @class */ (function () {
                 }
             }
             else {
-                var r = babylonTransformNode.rotation;
-                basePositionRotationOrScale = (r !== null && r !== void 0 ? r : Vector3.Zero()).asArray();
+                const r = babylonTransformNode.rotation;
+                basePositionRotationOrScale = (r ?? Vector3.Zero()).asArray();
                 _GLTFUtilities._GetRightHandedNormalArray3FromRef(basePositionRotationOrScale);
             }
         }
         else if (animationChannelTargetPath === "translation" /* TRANSLATION */) {
-            var p = babylonTransformNode.position;
-            basePositionRotationOrScale = (p !== null && p !== void 0 ? p : Vector3.Zero()).asArray();
+            const p = babylonTransformNode.position;
+            basePositionRotationOrScale = (p ?? Vector3.Zero()).asArray();
             if (convertToRightHandedSystem) {
                 _GLTFUtilities._GetRightHandedPositionArray3FromRef(basePositionRotationOrScale);
             }
         }
         else {
             // scale
-            var s = babylonTransformNode.scaling;
-            basePositionRotationOrScale = (s !== null && s !== void 0 ? s : Vector3.One()).asArray();
+            const s = babylonTransformNode.scaling;
+            basePositionRotationOrScale = (s ?? Vector3.One()).asArray();
         }
         return basePositionRotationOrScale;
-    };
+    }
     /**
      * Adds a key frame value
      * @param keyFrame
@@ -660,15 +646,15 @@ var _GLTFAnimation = /** @class */ (function () {
      * @param convertToRightHandedSystem
      * @param useQuaternion
      */
-    _GLTFAnimation._AddKeyframeValue = function (keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion) {
-        var value;
-        var newPositionRotationOrScale;
-        var animationType = animation.dataType;
+    static _AddKeyframeValue(keyFrame, animation, outputs, animationChannelTargetPath, babylonTransformNode, convertToRightHandedSystem, useQuaternion) {
+        let value;
+        let newPositionRotationOrScale;
+        const 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);
+                const array = Vector3.FromArray(value);
+                let rotationQuaternion = Quaternion.RotationYawPitchRoll(array.y, array.x, array.z);
                 if (convertToRightHandedSystem) {
                     _GLTFUtilities._GetRightHandedQuaternionFromRef(rotationQuaternion);
                     if (!babylonTransformNode.parent) {
@@ -697,7 +683,7 @@ var _GLTFAnimation = /** @class */ (function () {
                 newPositionRotationOrScale = this._ConvertFactorToVector3OrQuaternion(keyFrame.value, babylonTransformNode, animation, animationType, animationChannelTargetPath, convertToRightHandedSystem, useQuaternion);
                 if (newPositionRotationOrScale) {
                     if (animationChannelTargetPath === "rotation" /* ROTATION */) {
-                        var posRotScale = useQuaternion
+                        let posRotScale = useQuaternion
                             ? newPositionRotationOrScale
                             : Quaternion.RotationYawPitchRoll(newPositionRotationOrScale.y, newPositionRotationOrScale.x, newPositionRotationOrScale.z).normalize();
                         if (convertToRightHandedSystem) {
@@ -734,21 +720,21 @@ var _GLTFAnimation = /** @class */ (function () {
         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;
+    static _DeduceInterpolation(keyFrames, animationChannelTargetPath, useQuaternion) {
+        let interpolationType;
+        let shouldBakeAnimation = false;
+        let key;
         if (animationChannelTargetPath === "rotation" /* ROTATION */ && !useQuaternion) {
             return { interpolationType: "LINEAR" /* LINEAR */, shouldBakeAnimation: true };
         }
-        for (var i = 0, length_2 = keyFrames.length; i < length_2; ++i) {
+        for (let i = 0, length = keyFrames.length; i < length; ++i) {
             key = keyFrames[i];
             if (key.inTangent || key.outTangent) {
                 if (interpolationType) {
@@ -785,7 +771,7 @@ var _GLTFAnimation = /** @class */ (function () {
             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
@@ -799,9 +785,9 @@ var _GLTFAnimation = /** @class */ (function () {
      * @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;
+    static _AddSplineTangent(babylonTransformNode, tangentType, outputs, animationChannelTargetPath, interpolation, keyFrame, frameDelta, useQuaternion, convertToRightHandedSystem) {
+        let tangent;
+        const tangentValue = tangentType === _TangentType.INTANGENT ? keyFrame.inTangent : keyFrame.outTangent;
         if (interpolation === "CUBICSPLINE" /* CUBICSPLINE */) {
             if (animationChannelTargetPath === "rotation" /* ROTATION */) {
                 if (tangentValue) {
@@ -809,7 +795,7 @@ var _GLTFAnimation = /** @class */ (function () {
                         tangent = tangentValue.asArray();
                     }
                     else {
-                        var array = tangentValue;
+                        const array = tangentValue;
                         tangent = Quaternion.RotationYawPitchRoll(array.y, array.x, array.z).asArray();
                     }
                     if (convertToRightHandedSystem) {
@@ -850,22 +836,20 @@ var _GLTFAnimation = /** @class */ (function () {
             }
             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;
+    static _CalculateMinMaxKeyFrames(keyFrames) {
+        let min = Infinity;
+        let 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