@babylonjs/loaders 5.20.0 → 5.22.1

package/glTF/1.0/glTFLoader.js

@@ -36,8 +36,8 @@ var ETokenType;
     ETokenType[ETokenType["UNKNOWN"] = 2] = "UNKNOWN";
     ETokenType[ETokenType["END_OF_INPUT"] = 3] = "END_OF_INPUT";
 })(ETokenType || (ETokenType = {}));
-var Tokenizer = /** @class */ (function () {
-    function Tokenizer(toParse) {
+class Tokenizer {
+    constructor(toParse) {
         this._pos = 0;
         this.currentToken = ETokenType.UNKNOWN;
         this.currentIdentifier = "";
@@ -46,7 +46,7 @@ var Tokenizer = /** @class */ (function () {
         this._toParse = toParse;
         this._maxPos = toParse.length;
     }
-    Tokenizer.prototype.getNextToken = function () {
+    getNextToken() {
         if (this.isEnd()) {
             return ETokenType.END_OF_INPUT;
         }
@@ -61,50 +61,49 @@ var Tokenizer = /** @class */ (function () {
             }
         }
         return this.currentToken;
-    };
-    Tokenizer.prototype.peek = function () {
+    }
+    peek() {
         return this._toParse[this._pos];
-    };
-    Tokenizer.prototype.read = function () {
+    }
+    read() {
         return this._toParse[this._pos++];
-    };
-    Tokenizer.prototype.forward = function () {
+    }
+    forward() {
         this._pos++;
-    };
-    Tokenizer.prototype.isEnd = function () {
+    }
+    isEnd() {
         return this._pos >= this._maxPos;
-    };
-    return Tokenizer;
-}());
+    }
+}
 /**
  * Values
  */
-var glTFTransforms = ["MODEL", "VIEW", "PROJECTION", "MODELVIEW", "MODELVIEWPROJECTION", "JOINTMATRIX"];
-var babylonTransforms = ["world", "view", "projection", "worldView", "worldViewProjection", "mBones"];
-var glTFAnimationPaths = ["translation", "rotation", "scale"];
-var babylonAnimationPaths = ["position", "rotationQuaternion", "scaling"];
+const glTFTransforms = ["MODEL", "VIEW", "PROJECTION", "MODELVIEW", "MODELVIEWPROJECTION", "JOINTMATRIX"];
+const babylonTransforms = ["world", "view", "projection", "worldView", "worldViewProjection", "mBones"];
+const glTFAnimationPaths = ["translation", "rotation", "scale"];
+const babylonAnimationPaths = ["position", "rotationQuaternion", "scaling"];
 /**
  * Parse
  * @param parsedBuffers
  * @param gltfRuntime
  */
-var parseBuffers = function (parsedBuffers, gltfRuntime) {
-    for (var buf in parsedBuffers) {
-        var parsedBuffer = parsedBuffers[buf];
+const parseBuffers = (parsedBuffers, gltfRuntime) => {
+    for (const buf in parsedBuffers) {
+        const parsedBuffer = parsedBuffers[buf];
         gltfRuntime.buffers[buf] = parsedBuffer;
         gltfRuntime.buffersCount++;
     }
 };
-var parseShaders = function (parsedShaders, gltfRuntime) {
-    for (var sha in parsedShaders) {
-        var parsedShader = parsedShaders[sha];
+const parseShaders = (parsedShaders, gltfRuntime) => {
+    for (const sha in parsedShaders) {
+        const parsedShader = parsedShaders[sha];
         gltfRuntime.shaders[sha] = parsedShader;
         gltfRuntime.shaderscount++;
     }
 };
-var parseObject = function (parsedObjects, runtimeProperty, gltfRuntime) {
-    for (var object in parsedObjects) {
-        var parsedObject = parsedObjects[object];
+const parseObject = (parsedObjects, runtimeProperty, gltfRuntime) => {
+    for (const object in parsedObjects) {
+        const parsedObject = parsedObjects[object];
         gltfRuntime[runtimeProperty][object] = parsedObject;
     }
 };
@@ -112,15 +111,15 @@ var parseObject = function (parsedObjects, runtimeProperty, gltfRuntime) {
  * Utils
  * @param buffer
  */
-var normalizeUVs = function (buffer) {
+const normalizeUVs = (buffer) => {
     if (!buffer) {
         return;
     }
-    for (var i = 0; i < buffer.length / 2; i++) {
+    for (let i = 0; i < buffer.length / 2; i++) {
         buffer[i * 2 + 1] = 1.0 - buffer[i * 2 + 1];
     }
 };
-var getAttribute = function (attributeParameter) {
+const getAttribute = (attributeParameter) => {
     if (attributeParameter.semantic === "NORMAL") {
         return "normal";
     }
@@ -137,7 +136,7 @@ var getAttribute = function (attributeParameter) {
         return "color";
     }
     else if (attributeParameter.semantic && attributeParameter.semantic.indexOf("TEXCOORD_") !== -1) {
-        var channel = Number(attributeParameter.semantic.split("_")[1]);
+        const channel = Number(attributeParameter.semantic.split("_")[1]);
         return "uv" + (channel === 0 ? "" : channel + 1);
     }
     return null;
@@ -146,22 +145,22 @@ var getAttribute = function (attributeParameter) {
  * Loads and creates animations
  * @param gltfRuntime
  */
-var loadAnimations = function (gltfRuntime) {
-    for (var anim in gltfRuntime.animations) {
-        var animation = gltfRuntime.animations[anim];
+const loadAnimations = (gltfRuntime) => {
+    for (const anim in gltfRuntime.animations) {
+        const animation = gltfRuntime.animations[anim];
         if (!animation.channels || !animation.samplers) {
             continue;
         }
-        var lastAnimation = null;
-        for (var i = 0; i < animation.channels.length; i++) {
+        let lastAnimation = null;
+        for (let i = 0; i < animation.channels.length; i++) {
             // Get parameters and load buffers
-            var channel = animation.channels[i];
-            var sampler = animation.samplers[channel.sampler];
+            const channel = animation.channels[i];
+            const sampler = animation.samplers[channel.sampler];
             if (!sampler) {
                 continue;
             }
-            var inputData = null;
-            var outputData = null;
+            let inputData = null;
+            let outputData = null;
             if (animation.parameters) {
                 inputData = animation.parameters[sampler.input];
                 outputData = animation.parameters[sampler.output];
@@ -170,10 +169,10 @@ var loadAnimations = function (gltfRuntime) {
                 inputData = sampler.input;
                 outputData = sampler.output;
             }
-            var bufferInput = GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[inputData]);
-            var bufferOutput = GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[outputData]);
-            var targetId = channel.target.id;
-            var targetNode = gltfRuntime.scene.getNodeById(targetId);
+            const bufferInput = GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[inputData]);
+            const bufferOutput = GLTFUtils.GetBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[outputData]);
+            const targetId = channel.target.id;
+            let targetNode = gltfRuntime.scene.getNodeById(targetId);
             if (targetNode === null) {
                 targetNode = gltfRuntime.scene.getNodeByName(targetId);
             }
@@ -181,15 +180,15 @@ var loadAnimations = function (gltfRuntime) {
                 Tools.Warn("Creating animation named " + anim + ". But cannot find node named " + targetId + " to attach to");
                 continue;
             }
-            var isBone = targetNode instanceof Bone;
+            const isBone = targetNode instanceof Bone;
             // Get target path (position, rotation or scaling)
-            var targetPath = channel.target.path;
-            var targetPathIndex = glTFAnimationPaths.indexOf(targetPath);
+            let targetPath = channel.target.path;
+            const targetPathIndex = glTFAnimationPaths.indexOf(targetPath);
             if (targetPathIndex !== -1) {
                 targetPath = babylonAnimationPaths[targetPathIndex];
             }
             // Determine animation type
-            var animationType = Animation.ANIMATIONTYPE_MATRIX;
+            let animationType = Animation.ANIMATIONTYPE_MATRIX;
             if (!isBone) {
                 if (targetPath === "rotationQuaternion") {
                     animationType = Animation.ANIMATIONTYPE_QUATERNION;
@@ -200,10 +199,10 @@ var loadAnimations = function (gltfRuntime) {
                 }
             }
             // Create animation and key frames
-            var babylonAnimation = null;
-            var keys = [];
-            var arrayOffset = 0;
-            var modifyKey = false;
+            let babylonAnimation = null;
+            const keys = [];
+            let arrayOffset = 0;
+            let modifyKey = false;
             if (isBone && lastAnimation && lastAnimation.getKeys().length === bufferInput.length) {
                 babylonAnimation = lastAnimation;
                 modifyKey = true;
@@ -214,8 +213,8 @@ var loadAnimations = function (gltfRuntime) {
                 gltfRuntime.scene._blockEntityCollection = false;
             }
             // For each frame
-            for (var j = 0; j < bufferInput.length; j++) {
-                var value = null;
+            for (let j = 0; j < bufferInput.length; j++) {
+                let value = null;
                 if (targetPath === "rotationQuaternion") {
                     // VEC4
                     value = Quaternion.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2], bufferOutput[arrayOffset + 3]]);
@@ -227,12 +226,12 @@ var loadAnimations = function (gltfRuntime) {
                     arrayOffset += 3;
                 }
                 if (isBone) {
-                    var bone = targetNode;
-                    var translation = Vector3.Zero();
-                    var rotationQuaternion = new Quaternion();
-                    var scaling = Vector3.Zero();
+                    const bone = targetNode;
+                    let translation = Vector3.Zero();
+                    let rotationQuaternion = new Quaternion();
+                    let scaling = Vector3.Zero();
                     // Warning on decompose
-                    var mat = bone.getBaseMatrix();
+                    let mat = bone.getBaseMatrix();
                     if (modifyKey && lastAnimation) {
                         mat = lastAnimation.getKeys()[j].value;
                     }
@@ -273,12 +272,12 @@ var loadAnimations = function (gltfRuntime) {
  * Returns the bones transformation matrix
  * @param node
  */
-var configureBoneTransformation = function (node) {
-    var mat = null;
+const configureBoneTransformation = (node) => {
+    let mat = null;
     if (node.translation || node.rotation || node.scale) {
-        var scale = Vector3.FromArray(node.scale || [1, 1, 1]);
-        var rotation = Quaternion.FromArray(node.rotation || [0, 0, 0, 1]);
-        var position = Vector3.FromArray(node.translation || [0, 0, 0]);
+        const scale = Vector3.FromArray(node.scale || [1, 1, 1]);
+        const rotation = Quaternion.FromArray(node.rotation || [0, 0, 0, 1]);
+        const position = Vector3.FromArray(node.translation || [0, 0, 0]);
         mat = Matrix.Compose(scale, rotation, position);
     }
     else {
@@ -293,29 +292,29 @@ var configureBoneTransformation = function (node) {
  * @param jointName
  * @param newSkeleton
  */
-var getParentBone = function (gltfRuntime, skins, jointName, newSkeleton) {
+const getParentBone = (gltfRuntime, skins, jointName, newSkeleton) => {
     // Try to find
-    for (var i = 0; i < newSkeleton.bones.length; i++) {
+    for (let i = 0; i < newSkeleton.bones.length; i++) {
         if (newSkeleton.bones[i].name === jointName) {
             return newSkeleton.bones[i];
         }
     }
     // Not found, search in gltf nodes
-    var nodes = gltfRuntime.nodes;
-    for (var nde in nodes) {
-        var node = nodes[nde];
+    const nodes = gltfRuntime.nodes;
+    for (const nde in nodes) {
+        const node = nodes[nde];
         if (!node.jointName) {
             continue;
         }
-        var children = node.children;
-        for (var i = 0; i < children.length; i++) {
-            var child = gltfRuntime.nodes[children[i]];
+        const children = node.children;
+        for (let i = 0; i < children.length; i++) {
+            const child = gltfRuntime.nodes[children[i]];
             if (!child.jointName) {
                 continue;
             }
             if (child.jointName === jointName) {
-                var mat = configureBoneTransformation(node);
-                var bone = new Bone(node.name || "", newSkeleton, getParentBone(gltfRuntime, skins, node.jointName, newSkeleton), mat);
+                const mat = configureBoneTransformation(node);
+                const bone = new Bone(node.name || "", newSkeleton, getParentBone(gltfRuntime, skins, node.jointName, newSkeleton), mat);
                 bone.id = nde;
                 return bone;
             }
@@ -328,11 +327,11 @@ var getParentBone = function (gltfRuntime, skins, jointName, newSkeleton) {
  * @param nodesToRoot
  * @param id
  */
-var getNodeToRoot = function (nodesToRoot, id) {
-    for (var i = 0; i < nodesToRoot.length; i++) {
-        var nodeToRoot = nodesToRoot[i];
-        for (var j = 0; j < nodeToRoot.node.children.length; j++) {
-            var child = nodeToRoot.node.children[j];
+const getNodeToRoot = (nodesToRoot, id) => {
+    for (let i = 0; i < nodesToRoot.length; i++) {
+        const nodeToRoot = nodesToRoot[i];
+        for (let j = 0; j < nodeToRoot.node.children.length; j++) {
+            const child = nodeToRoot.node.children[j];
             if (child === id) {
                 return nodeToRoot.bone;
             }
@@ -345,16 +344,16 @@ var getNodeToRoot = function (nodesToRoot, id) {
  * @param gltfRuntime
  * @param jointName
  */
-var getJointNode = function (gltfRuntime, jointName) {
-    var nodes = gltfRuntime.nodes;
-    var node = nodes[jointName];
+const getJointNode = (gltfRuntime, jointName) => {
+    const nodes = gltfRuntime.nodes;
+    let node = nodes[jointName];
     if (node) {
         return {
             node: node,
             id: jointName,
         };
     }
-    for (var nde in nodes) {
+    for (const nde in nodes) {
         node = nodes[nde];
         if (node.jointName === jointName) {
             return {
@@ -370,8 +369,8 @@ var getJointNode = function (gltfRuntime, jointName) {
  * @param skins
  * @param id
  */
-var nodeIsInJoints = function (skins, id) {
-    for (var i = 0; i < skins.jointNames.length; i++) {
+const nodeIsInJoints = (skins, id) => {
+    for (let i = 0; i < skins.jointNames.length; i++) {
         if (skins.jointNames[i] === id) {
             return true;
         }
@@ -385,27 +384,27 @@ var nodeIsInJoints = function (skins, id) {
  * @param skins
  * @param nodesToRoot
  */
-var getNodesToRoot = function (gltfRuntime, newSkeleton, skins, nodesToRoot) {
+const getNodesToRoot = (gltfRuntime, newSkeleton, skins, nodesToRoot) => {
     // Creates nodes for root
-    for (var nde in gltfRuntime.nodes) {
-        var node = gltfRuntime.nodes[nde];
-        var id = nde;
+    for (const nde in gltfRuntime.nodes) {
+        const node = gltfRuntime.nodes[nde];
+        const id = nde;
         if (!node.jointName || nodeIsInJoints(skins, node.jointName)) {
             continue;
         }
         // Create node to root bone
-        var mat = configureBoneTransformation(node);
-        var bone = new Bone(node.name || "", newSkeleton, null, mat);
+        const mat = configureBoneTransformation(node);
+        const bone = new Bone(node.name || "", newSkeleton, null, mat);
         bone.id = id;
         nodesToRoot.push({ bone: bone, node: node, id: id });
     }
     // Parenting
-    for (var i = 0; i < nodesToRoot.length; i++) {
-        var nodeToRoot = nodesToRoot[i];
-        var children = nodeToRoot.node.children;
-        for (var j = 0; j < children.length; j++) {
-            var child = null;
-            for (var k = 0; k < nodesToRoot.length; k++) {
+    for (let i = 0; i < nodesToRoot.length; i++) {
+        const nodeToRoot = nodesToRoot[i];
+        const children = nodeToRoot.node.children;
+        for (let j = 0; j < children.length; j++) {
+            let child = null;
+            for (let k = 0; k < nodesToRoot.length; k++) {
                 if (nodesToRoot[k].id === children[j]) {
                     child = nodesToRoot[k];
                     break;
@@ -425,7 +424,7 @@ var getNodesToRoot = function (gltfRuntime, newSkeleton, skins, nodesToRoot) {
  * @param mesh
  * @param newSkeleton
  */
-var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
+const importSkeleton = (gltfRuntime, skins, mesh, newSkeleton) => {
     if (!newSkeleton) {
         newSkeleton = new Skeleton(skins.name || "", "", gltfRuntime.scene);
     }
@@ -433,47 +432,47 @@ var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
         return newSkeleton;
     }
     // Find the root bones
-    var nodesToRoot = [];
-    var nodesToRootToAdd = [];
+    const nodesToRoot = [];
+    const nodesToRootToAdd = [];
     getNodesToRoot(gltfRuntime, newSkeleton, skins, nodesToRoot);
     newSkeleton.bones = [];
     // Joints
-    for (var i = 0; i < skins.jointNames.length; i++) {
-        var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
+    for (let i = 0; i < skins.jointNames.length; i++) {
+        const jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
         if (!jointNode) {
             continue;
         }
-        var node = jointNode.node;
+        const node = jointNode.node;
         if (!node) {
             Tools.Warn("Joint named " + skins.jointNames[i] + " does not exist");
             continue;
         }
-        var id = jointNode.id;
+        const id = jointNode.id;
         // Optimize, if the bone already exists...
-        var existingBone = gltfRuntime.scene.getBoneById(id);
+        const existingBone = gltfRuntime.scene.getBoneById(id);
         if (existingBone) {
             newSkeleton.bones.push(existingBone);
             continue;
         }
         // Search for parent bone
-        var foundBone = false;
-        var parentBone = null;
-        for (var j = 0; j < i; j++) {
-            var jointNode_1 = getJointNode(gltfRuntime, skins.jointNames[j]);
-            if (!jointNode_1) {
+        let foundBone = false;
+        let parentBone = null;
+        for (let j = 0; j < i; j++) {
+            const jointNode = getJointNode(gltfRuntime, skins.jointNames[j]);
+            if (!jointNode) {
                 continue;
             }
-            var joint = jointNode_1.node;
+            const joint = jointNode.node;
             if (!joint) {
                 Tools.Warn("Joint named " + skins.jointNames[j] + " does not exist when looking for parent");
                 continue;
             }
-            var children = joint.children;
+            const children = joint.children;
             if (!children) {
                 continue;
             }
             foundBone = false;
-            for (var k = 0; k < children.length; k++) {
+            for (let k = 0; k < children.length; k++) {
                 if (children[k] === id) {
                     parentBone = getParentBone(gltfRuntime, skins, skins.jointNames[j], newSkeleton);
                     foundBone = true;
@@ -485,7 +484,7 @@ var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
             }
         }
         // Create bone
-        var mat = configureBoneTransformation(node);
+        const mat = configureBoneTransformation(node);
         if (!parentBone && nodesToRoot.length > 0) {
             parentBone = getNodeToRoot(nodesToRoot, id);
             if (parentBone) {
@@ -494,18 +493,18 @@ var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
                 }
             }
         }
-        var bone = new Bone(node.jointName || "", newSkeleton, parentBone, mat);
+        const bone = new Bone(node.jointName || "", newSkeleton, parentBone, mat);
         bone.id = id;
     }
     // Polish
-    var bones = newSkeleton.bones;
+    const bones = newSkeleton.bones;
     newSkeleton.bones = [];
-    for (var i = 0; i < skins.jointNames.length; i++) {
-        var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
+    for (let i = 0; i < skins.jointNames.length; i++) {
+        const jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
         if (!jointNode) {
             continue;
         }
-        for (var j = 0; j < bones.length; j++) {
+        for (let j = 0; j < bones.length; j++) {
             if (bones[j].id === jointNode.id) {
                 newSkeleton.bones.push(bones[j]);
                 break;
@@ -514,7 +513,7 @@ var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
     }
     newSkeleton.prepare();
     // Finish
-    for (var i = 0; i < nodesToRootToAdd.length; i++) {
+    for (let i = 0; i < nodesToRootToAdd.length; i++) {
         newSkeleton.bones.push(nodesToRootToAdd[i]);
     }
     return newSkeleton;
@@ -527,7 +526,7 @@ var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
  * @param id
  * @param newMesh
  */
-var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
+const importMesh = (gltfRuntime, node, meshes, id, newMesh) => {
     if (!newMesh) {
         gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
         newMesh = new Mesh(node.name || "", gltfRuntime.scene);
@@ -538,31 +537,31 @@ var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
     if (!node.babylonNode) {
         return newMesh;
     }
-    var subMaterials = [];
-    var vertexData = null;
-    var verticesStarts = new Array();
-    var verticesCounts = new Array();
-    var indexStarts = new Array();
-    var indexCounts = new Array();
-    for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
-        var meshId = meshes[meshIndex];
-        var mesh = gltfRuntime.meshes[meshId];
+    const subMaterials = [];
+    let vertexData = null;
+    const verticesStarts = new Array();
+    const verticesCounts = new Array();
+    const indexStarts = new Array();
+    const indexCounts = new Array();
+    for (let meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
+        const meshId = meshes[meshIndex];
+        const mesh = gltfRuntime.meshes[meshId];
         if (!mesh) {
             continue;
         }
         // Positions, normals and UVs
-        for (var i = 0; i < mesh.primitives.length; i++) {
+        for (let i = 0; i < mesh.primitives.length; i++) {
             // Temporary vertex data
-            var tempVertexData = new VertexData();
-            var primitive = mesh.primitives[i];
+            const tempVertexData = new VertexData();
+            const primitive = mesh.primitives[i];
             if (primitive.mode !== 4) {
                 // continue;
             }
-            var attributes = primitive.attributes;
-            var accessor = null;
-            var buffer = null;
+            const attributes = primitive.attributes;
+            let accessor = null;
+            let buffer = null;
             // Set positions, normal and uvs
-            for (var semantic in attributes) {
+            for (const semantic in attributes) {
                 // Link accessor and buffer view
                 accessor = gltfRuntime.accessors[attributes[semantic]];
                 buffer = GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
@@ -573,7 +572,7 @@ var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
                 else if (semantic === "POSITION") {
                     if (GLTFFileLoader.HomogeneousCoordinates) {
                         tempVertexData.positions = new Float32Array(buffer.length - buffer.length / 4);
-                        for (var j = 0; j < buffer.length; j += 4) {
+                        for (let j = 0; j < buffer.length; j += 4) {
                             tempVertexData.positions[j] = buffer[j];
                             tempVertexData.positions[j + 1] = buffer[j + 1];
                             tempVertexData.positions[j + 2] = buffer[j + 2];
@@ -586,9 +585,9 @@ var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
                     verticesCounts.push(tempVertexData.positions.length);
                 }
                 else if (semantic.indexOf("TEXCOORD_") !== -1) {
-                    var channel = Number(semantic.split("_")[1]);
-                    var uvKind = VertexBuffer.UVKind + (channel === 0 ? "" : channel + 1);
-                    var uvs = new Float32Array(buffer.length);
+                    const channel = Number(semantic.split("_")[1]);
+                    const uvKind = VertexBuffer.UVKind + (channel === 0 ? "" : channel + 1);
+                    const uvs = new Float32Array(buffer.length);
                     uvs.set(buffer);
                     normalizeUVs(uvs);
                     tempVertexData.set(uvs, uvKind);
@@ -616,8 +615,8 @@ var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
             }
             else {
                 // Set indices on the fly
-                var indices = [];
-                for (var j = 0; j < tempVertexData.positions.length / 3; j++) {
+                const indices = [];
+                for (let j = 0; j < tempVertexData.positions.length / 3; j++) {
                     indices.push(j);
                 }
                 tempVertexData.indices = new Int32Array(indices);
@@ -630,14 +629,14 @@ var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
                 vertexData.merge(tempVertexData);
             }
             // Sub material
-            var material_1 = gltfRuntime.scene.getMaterialById(primitive.material);
-            subMaterials.push(material_1 === null ? GLTFUtils.GetDefaultMaterial(gltfRuntime.scene) : material_1);
+            const material = gltfRuntime.scene.getMaterialById(primitive.material);
+            subMaterials.push(material === null ? GLTFUtils.GetDefaultMaterial(gltfRuntime.scene) : material);
             // Update vertices start and index start
             verticesStarts.push(verticesStarts.length === 0 ? 0 : verticesStarts[verticesStarts.length - 1] + verticesCounts[verticesCounts.length - 2]);
             indexStarts.push(indexStarts.length === 0 ? 0 : indexStarts[indexStarts.length - 1] + indexCounts[indexCounts.length - 2]);
         }
     }
-    var material;
+    let material;
     gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
     if (subMaterials.length > 1) {
         material = new MultiMaterial("multimat" + id, gltfRuntime.scene);
@@ -659,14 +658,14 @@ var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
     gltfRuntime.scene._blockEntityCollection = false;
     // Apply submeshes
     newMesh.subMeshes = [];
-    var index = 0;
-    for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
-        var meshId = meshes[meshIndex];
-        var mesh = gltfRuntime.meshes[meshId];
+    let index = 0;
+    for (let meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
+        const meshId = meshes[meshIndex];
+        const mesh = gltfRuntime.meshes[meshId];
         if (!mesh) {
             continue;
         }
-        for (var i = 0; i < mesh.primitives.length; i++) {
+        for (let i = 0; i < mesh.primitives.length; i++) {
             if (mesh.primitives[i].mode !== 4) {
                 //continue;
             }
@@ -684,7 +683,7 @@ var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
  * @param rotation
  * @param scaling
  */
-var configureNode = function (newNode, position, rotation, scaling) {
+const configureNode = (newNode, position, rotation, scaling) => {
     if (newNode.position) {
         newNode.position = position;
     }
@@ -700,12 +699,12 @@ var configureNode = function (newNode, position, rotation, scaling) {
  * @param newNode
  * @param node
  */
-var configureNodeFromMatrix = function (newNode, node) {
+const configureNodeFromMatrix = (newNode, node) => {
     if (node.matrix) {
-        var position = new Vector3(0, 0, 0);
-        var rotation = new Quaternion();
-        var scaling = new Vector3(0, 0, 0);
-        var mat = Matrix.FromArray(node.matrix);
+        const position = new Vector3(0, 0, 0);
+        const rotation = new Quaternion();
+        const scaling = new Vector3(0, 0, 0);
+        const mat = Matrix.FromArray(node.matrix);
         mat.decompose(scaling, rotation, position);
         configureNode(newNode, position, rotation, scaling);
     }
@@ -720,8 +719,8 @@ var configureNodeFromMatrix = function (newNode, node) {
  * @param node
  * @param id
  */
-var importNode = function (gltfRuntime, node, id) {
-    var lastNode = null;
+const importNode = (gltfRuntime, node, id) => {
+    let lastNode = null;
     if (gltfRuntime.importOnlyMeshes && (node.skin || node.meshes)) {
         if (gltfRuntime.importMeshesNames && gltfRuntime.importMeshesNames.length > 0 && gltfRuntime.importMeshesNames.indexOf(node.name || "") === -1) {
             return null;
@@ -730,8 +729,8 @@ var importNode = function (gltfRuntime, node, id) {
     // Meshes
     if (node.skin) {
         if (node.meshes) {
-            var skin = gltfRuntime.skins[node.skin];
-            var newMesh = importMesh(gltfRuntime, node, node.meshes, id, node.babylonNode);
+            const skin = gltfRuntime.skins[node.skin];
+            const newMesh = importMesh(gltfRuntime, node, node.meshes, id, node.babylonNode);
             newMesh.skeleton = gltfRuntime.scene.getLastSkeletonById(node.skin);
             if (newMesh.skeleton === null) {
                 newMesh.skeleton = importSkeleton(gltfRuntime, skin, newMesh, skin.babylonSkeleton);
@@ -746,16 +745,16 @@ var importNode = function (gltfRuntime, node, id) {
         /**
          * Improve meshes property
          */
-        var newMesh = importMesh(gltfRuntime, node, node.mesh ? [node.mesh] : node.meshes, id, node.babylonNode);
+        const newMesh = importMesh(gltfRuntime, node, node.mesh ? [node.mesh] : node.meshes, id, node.babylonNode);
         lastNode = newMesh;
     }
     // Lights
     else if (node.light && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
-        var light = gltfRuntime.lights[node.light];
+        const light = gltfRuntime.lights[node.light];
         if (light) {
             if (light.type === "ambient") {
-                var ambienLight = light[light.type];
-                var hemiLight = new HemisphericLight(node.light, Vector3.Zero(), gltfRuntime.scene);
+                const ambienLight = light[light.type];
+                const hemiLight = new HemisphericLight(node.light, Vector3.Zero(), gltfRuntime.scene);
                 hemiLight.name = node.name || "";
                 if (ambienLight.color) {
                     hemiLight.diffuse = Color3.FromArray(ambienLight.color);
@@ -763,8 +762,8 @@ var importNode = function (gltfRuntime, node, id) {
                 lastNode = hemiLight;
             }
             else if (light.type === "directional") {
-                var directionalLight = light[light.type];
-                var dirLight = new DirectionalLight(node.light, Vector3.Zero(), gltfRuntime.scene);
+                const directionalLight = light[light.type];
+                const dirLight = new DirectionalLight(node.light, Vector3.Zero(), gltfRuntime.scene);
                 dirLight.name = node.name || "";
                 if (directionalLight.color) {
                     dirLight.diffuse = Color3.FromArray(directionalLight.color);
@@ -772,8 +771,8 @@ var importNode = function (gltfRuntime, node, id) {
                 lastNode = dirLight;
             }
             else if (light.type === "point") {
-                var pointLight = light[light.type];
-                var ptLight = new PointLight(node.light, Vector3.Zero(), gltfRuntime.scene);
+                const pointLight = light[light.type];
+                const ptLight = new PointLight(node.light, Vector3.Zero(), gltfRuntime.scene);
                 ptLight.name = node.name || "";
                 if (pointLight.color) {
                     ptLight.diffuse = Color3.FromArray(pointLight.color);
@@ -781,8 +780,8 @@ var importNode = function (gltfRuntime, node, id) {
                 lastNode = ptLight;
             }
             else if (light.type === "spot") {
-                var spotLight = light[light.type];
-                var spLight = new SpotLight(node.light, Vector3.Zero(), Vector3.Zero(), 0, 0, gltfRuntime.scene);
+                const spotLight = light[light.type];
+                const spLight = new SpotLight(node.light, Vector3.Zero(), Vector3.Zero(), 0, 0, gltfRuntime.scene);
                 spLight.name = node.name || "";
                 if (spotLight.color) {
                     spLight.diffuse = Color3.FromArray(spotLight.color);
@@ -799,11 +798,11 @@ var importNode = function (gltfRuntime, node, id) {
     }
     // Cameras
     else if (node.camera && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
-        var camera = gltfRuntime.cameras[node.camera];
+        const camera = gltfRuntime.cameras[node.camera];
         if (camera) {
             gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
             if (camera.type === "orthographic") {
-                var orthoCamera = new FreeCamera(node.camera, Vector3.Zero(), gltfRuntime.scene, false);
+                const orthoCamera = new FreeCamera(node.camera, Vector3.Zero(), gltfRuntime.scene, false);
                 orthoCamera.name = node.name || "";
                 orthoCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;
                 orthoCamera.attachControl();
@@ -811,8 +810,8 @@ var importNode = function (gltfRuntime, node, id) {
                 orthoCamera._parentContainer = gltfRuntime.assetContainer;
             }
             else if (camera.type === "perspective") {
-                var perspectiveCamera = camera[camera.type];
-                var persCamera = new FreeCamera(node.camera, Vector3.Zero(), gltfRuntime.scene, false);
+                const perspectiveCamera = camera[camera.type];
+                const persCamera = new FreeCamera(node.camera, Vector3.Zero(), gltfRuntime.scene, false);
                 persCamera.name = node.name || "";
                 persCamera.attachControl();
                 if (!perspectiveCamera.aspectRatio) {
@@ -835,7 +834,7 @@ var importNode = function (gltfRuntime, node, id) {
         }
         else if (lastNode === null) {
             gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
-            var dummy = new Mesh(node.name || "", gltfRuntime.scene);
+            const dummy = new Mesh(node.name || "", gltfRuntime.scene);
             dummy._parentContainer = gltfRuntime.assetContainer;
             gltfRuntime.scene._blockEntityCollection = false;
             node.babylonNode = dummy;
@@ -847,9 +846,9 @@ var importNode = function (gltfRuntime, node, id) {
             configureNodeFromMatrix(lastNode, node);
         }
         else {
-            var translation = node.translation || [0, 0, 0];
-            var rotation = node.rotation || [0, 0, 0, 1];
-            var scale = node.scale || [1, 1, 1];
+            const translation = node.translation || [0, 0, 0];
+            const rotation = node.rotation || [0, 0, 0, 1];
+            const scale = node.scale || [1, 1, 1];
             configureNode(lastNode, Vector3.FromArray(translation), Quaternion.FromArray(rotation), Vector3.FromArray(scale));
         }
         lastNode.updateCache(true);
@@ -864,10 +863,9 @@ var importNode = function (gltfRuntime, node, id) {
  * @param parent
  * @param meshIncluded
  */
-var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
-    if (meshIncluded === void 0) { meshIncluded = false; }
-    var node = gltfRuntime.nodes[id];
-    var newNode = null;
+const traverseNodes = (gltfRuntime, id, parent, meshIncluded = false) => {
+    const node = gltfRuntime.nodes[id];
+    let newNode = null;
     if (gltfRuntime.importOnlyMeshes && !meshIncluded && gltfRuntime.importMeshesNames) {
         if (gltfRuntime.importMeshesNames.indexOf(node.name || "") !== -1 || gltfRuntime.importMeshesNames.length === 0) {
             meshIncluded = true;
@@ -887,7 +885,7 @@ var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
         }
     }
     if (node.children) {
-        for (var i = 0; i < node.children.length; i++) {
+        for (let i = 0; i < node.children.length; i++) {
             traverseNodes(gltfRuntime, node.children[i], newNode, meshIncluded);
         }
     }
@@ -896,26 +894,26 @@ var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
  * do stuff after buffers, shaders are loaded (e.g. hook up materials, load animations, etc.)
  * @param gltfRuntime
  */
-var postLoad = function (gltfRuntime) {
+const postLoad = (gltfRuntime) => {
     // Nodes
-    var currentScene = gltfRuntime.currentScene;
+    let currentScene = gltfRuntime.currentScene;
     if (currentScene) {
-        for (var i = 0; i < currentScene.nodes.length; i++) {
+        for (let i = 0; i < currentScene.nodes.length; i++) {
             traverseNodes(gltfRuntime, currentScene.nodes[i], null);
         }
     }
     else {
-        for (var thing in gltfRuntime.scenes) {
+        for (const thing in gltfRuntime.scenes) {
             currentScene = gltfRuntime.scenes[thing];
-            for (var i = 0; i < currentScene.nodes.length; i++) {
+            for (let i = 0; i < currentScene.nodes.length; i++) {
                 traverseNodes(gltfRuntime, currentScene.nodes[i], null);
             }
         }
     }
     // Set animations
     loadAnimations(gltfRuntime);
-    for (var i = 0; i < gltfRuntime.scene.skeletons.length; i++) {
-        var skeleton = gltfRuntime.scene.skeletons[i];
+    for (let i = 0; i < gltfRuntime.scene.skeletons.length; i++) {
+        const skeleton = gltfRuntime.scene.skeletons[i];
         gltfRuntime.scene.beginAnimation(skeleton, 0, Number.MAX_VALUE, true, 1.0);
     }
 };
@@ -929,17 +927,17 @@ var postLoad = function (gltfRuntime) {
  * @param material
  * @param onSuccess
  */
-var onBindShaderMaterial = function (mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess) {
-    var materialValues = material.values || technique.parameters;
-    for (var unif in unTreatedUniforms) {
-        var uniform = unTreatedUniforms[unif];
-        var type = uniform.type;
+const onBindShaderMaterial = (mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess) => {
+    const materialValues = material.values || technique.parameters;
+    for (const unif in unTreatedUniforms) {
+        const uniform = unTreatedUniforms[unif];
+        const type = uniform.type;
         if (type === EParameterType.FLOAT_MAT2 || type === EParameterType.FLOAT_MAT3 || type === EParameterType.FLOAT_MAT4) {
             if (uniform.semantic && !uniform.source && !uniform.node) {
                 GLTFUtils.SetMatrix(gltfRuntime.scene, mesh, uniform, unif, shaderMaterial.getEffect());
             }
             else if (uniform.semantic && (uniform.source || uniform.node)) {
-                var source = gltfRuntime.scene.getNodeByName(uniform.source || uniform.node || "");
+                let source = gltfRuntime.scene.getNodeByName(uniform.source || uniform.node || "");
                 if (source === null) {
                     source = gltfRuntime.scene.getNodeById(uniform.source || uniform.node || "");
                 }
@@ -950,12 +948,12 @@ var onBindShaderMaterial = function (mesh, gltfRuntime, unTreatedUniforms, shade
             }
         }
         else {
-            var value = materialValues[technique.uniforms[unif]];
+            const value = materialValues[technique.uniforms[unif]];
             if (!value) {
                 continue;
             }
             if (type === EParameterType.SAMPLER_2D) {
-                var texture = gltfRuntime.textures[material.values ? value : uniform.value].babylonTexture;
+                const texture = gltfRuntime.textures[material.values ? value : uniform.value].babylonTexture;
                 if (texture === null || texture === undefined) {
                     continue;
                 }
@@ -976,22 +974,25 @@ var onBindShaderMaterial = function (mesh, gltfRuntime, unTreatedUniforms, shade
  * @param technique
  * @param material
  */
-var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) {
-    var materialValues = material.values || technique.parameters;
-    var techniqueUniforms = technique.uniforms;
-    var _loop_1 = function (unif) {
-        var uniform = unTreatedUniforms[unif];
-        var type = uniform.type;
-        var value = materialValues[techniqueUniforms[unif]];
+const prepareShaderMaterialUniforms = (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) => {
+    const materialValues = material.values || technique.parameters;
+    const techniqueUniforms = technique.uniforms;
+    /**
+     * Prepare values here (not matrices)
+     */
+    for (const unif in unTreatedUniforms) {
+        const uniform = unTreatedUniforms[unif];
+        const type = uniform.type;
+        let value = materialValues[techniqueUniforms[unif]];
         if (value === undefined) {
             // In case the value is the same for all materials
             value = uniform.value;
         }
         if (!value) {
-            return "continue";
+            continue;
         }
-        var onLoadTexture = function (uniformName) {
-            return function (texture) {
+        const onLoadTexture = (uniformName) => {
+            return (texture) => {
                 if (uniform.value && uniformName) {
                     // Static uniform
                     shaderMaterial.setTexture(uniformName, texture);
@@ -1001,7 +1002,7 @@ var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, techn
         };
         // Texture (sampler2D)
         if (type === EParameterType.SAMPLER_2D) {
-            GLTFLoaderExtension.LoadTextureAsync(gltfRuntime, material.values ? value : uniform.value, onLoadTexture(unif), function () { return onLoadTexture(null); });
+            GLTFLoaderExtension.LoadTextureAsync(gltfRuntime, material.values ? value : uniform.value, onLoadTexture(unif), () => onLoadTexture(null));
         }
         // Others
         else {
@@ -1010,12 +1011,6 @@ var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, techn
                 delete unTreatedUniforms[unif];
             }
         }
-    };
-    /**
-     * Prepare values here (not matrices)
-     */
-    for (var unif in unTreatedUniforms) {
-        _loop_1(unif);
     }
 };
 /**
@@ -1024,8 +1019,8 @@ var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, techn
  * @param shaderMaterial
  * @param onError
  */
-var onShaderCompileError = function (program, shaderMaterial, onError) {
-    return function (effect, error) {
+const onShaderCompileError = (program, shaderMaterial, onError) => {
+    return (effect, error) => {
         shaderMaterial.dispose(true);
         onError("Cannot compile program named " + program.name + ". Error: " + error + ". Default material will be applied");
     };
@@ -1039,10 +1034,10 @@ var onShaderCompileError = function (program, shaderMaterial, onError) {
  * @param unTreatedUniforms
  * @param onSuccess
  */
-var onShaderCompileSuccess = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess) {
-    return function (_) {
+const onShaderCompileSuccess = (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess) => {
+    return (_) => {
         prepareShaderMaterialUniforms(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms);
-        shaderMaterial.onBind = function (mesh) {
+        shaderMaterial.onBind = (mesh) => {
             onBindShaderMaterial(mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess);
         };
     };
@@ -1052,13 +1047,13 @@ var onShaderCompileSuccess = function (gltfRuntime, shaderMaterial, technique, m
  * @param tokenizer
  * @param technique
  */
-var parseShaderUniforms = function (tokenizer, technique, unTreatedUniforms) {
-    for (var unif in technique.uniforms) {
-        var uniform = technique.uniforms[unif];
-        var uniformParameter = technique.parameters[uniform];
+const parseShaderUniforms = (tokenizer, technique, unTreatedUniforms) => {
+    for (const unif in technique.uniforms) {
+        const uniform = technique.uniforms[unif];
+        const uniformParameter = technique.parameters[uniform];
         if (tokenizer.currentIdentifier === unif) {
             if (uniformParameter.semantic && !uniformParameter.source && !uniformParameter.node) {
-                var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
+                const transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
                 if (transformIndex !== -1) {
                     delete unTreatedUniforms[unif];
                     return babylonTransforms[transformIndex];
@@ -1072,21 +1067,19 @@ var parseShaderUniforms = function (tokenizer, technique, unTreatedUniforms) {
  * All shaders loaded. Create materials one by one
  * @param gltfRuntime
  */
-var importMaterials = function (gltfRuntime) {
+const importMaterials = (gltfRuntime) => {
     // Create materials
-    for (var mat in gltfRuntime.materials) {
-        GLTFLoaderExtension.LoadMaterialAsync(gltfRuntime, mat, function () { }, function () { });
+    for (const mat in gltfRuntime.materials) {
+        GLTFLoaderExtension.LoadMaterialAsync(gltfRuntime, mat, () => { }, () => { });
     }
 };
 /**
  * Implementation of the base glTF spec
  * @hidden
  */
-var GLTFLoaderBase = /** @class */ (function () {
-    function GLTFLoaderBase() {
-    }
-    GLTFLoaderBase.CreateRuntime = function (parsedData, scene, rootUrl) {
-        var gltfRuntime = {
+export class GLTFLoaderBase {
+    static CreateRuntime(parsedData, scene, rootUrl) {
+        const gltfRuntime = {
             extensions: {},
             accessors: {},
             buffers: {},
@@ -1179,22 +1172,22 @@ var GLTFLoaderBase = /** @class */ (function () {
             gltfRuntime.currentScene = parsedData.scenes[parsedData.scene];
         }
         return gltfRuntime;
-    };
-    GLTFLoaderBase.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
-        var buffer = gltfRuntime.buffers[id];
+    }
+    static LoadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress) {
+        const buffer = gltfRuntime.buffers[id];
         if (Tools.IsBase64(buffer.uri)) {
-            setTimeout(function () { return onSuccess(new Uint8Array(Tools.DecodeBase64(buffer.uri))); });
+            setTimeout(() => onSuccess(new Uint8Array(Tools.DecodeBase64(buffer.uri))));
         }
         else {
-            Tools.LoadFile(gltfRuntime.rootUrl + buffer.uri, function (data) { return onSuccess(new Uint8Array(data)); }, onProgress, undefined, true, function (request) {
+            Tools.LoadFile(gltfRuntime.rootUrl + buffer.uri, (data) => onSuccess(new Uint8Array(data)), onProgress, undefined, true, (request) => {
                 if (request) {
                     onError(request.status + " " + request.statusText);
                 }
             });
         }
-    };
-    GLTFLoaderBase.LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
-        var texture = gltfRuntime.textures[id];
+    }
+    static LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError) {
+        const texture = gltfRuntime.textures[id];
         if (!texture || !texture.source) {
             onError("");
             return;
@@ -1203,34 +1196,34 @@ var GLTFLoaderBase = /** @class */ (function () {
             onSuccess(null);
             return;
         }
-        var source = gltfRuntime.images[texture.source];
+        const source = gltfRuntime.images[texture.source];
         if (Tools.IsBase64(source.uri)) {
-            setTimeout(function () { return onSuccess(new Uint8Array(Tools.DecodeBase64(source.uri))); });
+            setTimeout(() => onSuccess(new Uint8Array(Tools.DecodeBase64(source.uri))));
         }
         else {
-            Tools.LoadFile(gltfRuntime.rootUrl + source.uri, function (data) { return onSuccess(new Uint8Array(data)); }, undefined, undefined, true, function (request) {
+            Tools.LoadFile(gltfRuntime.rootUrl + source.uri, (data) => onSuccess(new Uint8Array(data)), undefined, undefined, true, (request) => {
                 if (request) {
                     onError(request.status + " " + request.statusText);
                 }
             });
         }
-    };
-    GLTFLoaderBase.CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess) {
-        var texture = gltfRuntime.textures[id];
+    }
+    static CreateTextureAsync(gltfRuntime, id, buffer, onSuccess) {
+        const texture = gltfRuntime.textures[id];
         if (texture.babylonTexture) {
             onSuccess(texture.babylonTexture);
             return;
         }
-        var sampler = gltfRuntime.samplers[texture.sampler];
-        var createMipMaps = sampler.minFilter === ETextureFilterType.NEAREST_MIPMAP_NEAREST ||
+        const sampler = gltfRuntime.samplers[texture.sampler];
+        const createMipMaps = sampler.minFilter === ETextureFilterType.NEAREST_MIPMAP_NEAREST ||
             sampler.minFilter === ETextureFilterType.NEAREST_MIPMAP_LINEAR ||
             sampler.minFilter === ETextureFilterType.LINEAR_MIPMAP_NEAREST ||
             sampler.minFilter === ETextureFilterType.LINEAR_MIPMAP_LINEAR;
-        var samplingMode = Texture.BILINEAR_SAMPLINGMODE;
-        var blob = buffer == null ? new Blob() : new Blob([buffer]);
-        var blobURL = URL.createObjectURL(blob);
-        var revokeBlobURL = function () { return URL.revokeObjectURL(blobURL); };
-        var newTexture = new Texture(blobURL, gltfRuntime.scene, !createMipMaps, true, samplingMode, revokeBlobURL, revokeBlobURL);
+        const samplingMode = Texture.BILINEAR_SAMPLINGMODE;
+        const blob = buffer == null ? new Blob() : new Blob([buffer]);
+        const blobURL = URL.createObjectURL(blob);
+        const revokeBlobURL = () => URL.revokeObjectURL(blobURL);
+        const newTexture = new Texture(blobURL, gltfRuntime.scene, !createMipMaps, true, samplingMode, revokeBlobURL, revokeBlobURL);
         if (sampler.wrapS !== undefined) {
             newTexture.wrapU = GLTFUtils.GetWrapMode(sampler.wrapS);
         }
@@ -1240,35 +1233,35 @@ var GLTFLoaderBase = /** @class */ (function () {
         newTexture.name = id;
         texture.babylonTexture = newTexture;
         onSuccess(newTexture);
-    };
-    GLTFLoaderBase.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
-        var shader = gltfRuntime.shaders[id];
+    }
+    static LoadShaderStringAsync(gltfRuntime, id, onSuccess, onError) {
+        const shader = gltfRuntime.shaders[id];
         if (Tools.IsBase64(shader.uri)) {
-            var shaderString = atob(shader.uri.split(",")[1]);
+            const shaderString = atob(shader.uri.split(",")[1]);
             if (onSuccess) {
                 onSuccess(shaderString);
             }
         }
         else {
-            Tools.LoadFile(gltfRuntime.rootUrl + shader.uri, onSuccess, undefined, undefined, false, function (request) {
+            Tools.LoadFile(gltfRuntime.rootUrl + shader.uri, onSuccess, undefined, undefined, false, (request) => {
                 if (request && onError) {
                     onError(request.status + " " + request.statusText);
                 }
             });
         }
-    };
-    GLTFLoaderBase.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
-        var material = gltfRuntime.materials[id];
+    }
+    static LoadMaterialAsync(gltfRuntime, id, onSuccess, onError) {
+        const material = gltfRuntime.materials[id];
         if (!material.technique) {
             if (onError) {
                 onError("No technique found.");
             }
             return;
         }
-        var technique = gltfRuntime.techniques[material.technique];
+        const technique = gltfRuntime.techniques[material.technique];
         if (!technique) {
             gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
-            var defaultMaterial = new StandardMaterial(id, gltfRuntime.scene);
+            const defaultMaterial = new StandardMaterial(id, gltfRuntime.scene);
             defaultMaterial._parentContainer = gltfRuntime.assetContainer;
             gltfRuntime.scene._blockEntityCollection = false;
             defaultMaterial.diffuseColor = new Color3(0.5, 0.5, 0.5);
@@ -1276,25 +1269,25 @@ var GLTFLoaderBase = /** @class */ (function () {
             onSuccess(defaultMaterial);
             return;
         }
-        var program = gltfRuntime.programs[technique.program];
-        var states = technique.states;
-        var vertexShader = Effect.ShadersStore[program.vertexShader + "VertexShader"];
-        var pixelShader = Effect.ShadersStore[program.fragmentShader + "PixelShader"];
-        var newVertexShader = "";
-        var newPixelShader = "";
-        var vertexTokenizer = new Tokenizer(vertexShader);
-        var pixelTokenizer = new Tokenizer(pixelShader);
-        var unTreatedUniforms = {};
-        var uniforms = [];
-        var attributes = [];
-        var samplers = [];
+        const program = gltfRuntime.programs[technique.program];
+        const states = technique.states;
+        const vertexShader = Effect.ShadersStore[program.vertexShader + "VertexShader"];
+        const pixelShader = Effect.ShadersStore[program.fragmentShader + "PixelShader"];
+        let newVertexShader = "";
+        let newPixelShader = "";
+        const vertexTokenizer = new Tokenizer(vertexShader);
+        const pixelTokenizer = new Tokenizer(pixelShader);
+        const unTreatedUniforms = {};
+        const uniforms = [];
+        const attributes = [];
+        const samplers = [];
         // Fill uniform, sampler2D and attributes
-        for (var unif in technique.uniforms) {
-            var uniform = technique.uniforms[unif];
-            var uniformParameter = technique.parameters[uniform];
+        for (const unif in technique.uniforms) {
+            const uniform = technique.uniforms[unif];
+            const uniformParameter = technique.parameters[uniform];
             unTreatedUniforms[unif] = uniformParameter;
             if (uniformParameter.semantic && !uniformParameter.node && !uniformParameter.source) {
-                var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
+                const transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
                 if (transformIndex !== -1) {
                     uniforms.push(babylonTransforms[transformIndex]);
                     delete unTreatedUniforms[unif];
@@ -1310,27 +1303,27 @@ var GLTFLoaderBase = /** @class */ (function () {
                 uniforms.push(unif);
             }
         }
-        for (var attr in technique.attributes) {
-            var attribute = technique.attributes[attr];
-            var attributeParameter = technique.parameters[attribute];
+        for (const attr in technique.attributes) {
+            const attribute = technique.attributes[attr];
+            const attributeParameter = technique.parameters[attribute];
             if (attributeParameter.semantic) {
-                var name_1 = getAttribute(attributeParameter);
-                if (name_1) {
-                    attributes.push(name_1);
+                const name = getAttribute(attributeParameter);
+                if (name) {
+                    attributes.push(name);
                 }
             }
         }
         // Configure vertex shader
         while (!vertexTokenizer.isEnd() && vertexTokenizer.getNextToken()) {
-            var tokenType = vertexTokenizer.currentToken;
+            const tokenType = vertexTokenizer.currentToken;
             if (tokenType !== ETokenType.IDENTIFIER) {
                 newVertexShader += vertexTokenizer.currentString;
                 continue;
             }
-            var foundAttribute = false;
-            for (var attr in technique.attributes) {
-                var attribute = technique.attributes[attr];
-                var attributeParameter = technique.parameters[attribute];
+            let foundAttribute = false;
+            for (const attr in technique.attributes) {
+                const attribute = technique.attributes[attr];
+                const attributeParameter = technique.parameters[attribute];
                 if (vertexTokenizer.currentIdentifier === attr && attributeParameter.semantic) {
                     newVertexShader += getAttribute(attributeParameter);
                     foundAttribute = true;
@@ -1344,7 +1337,7 @@ var GLTFLoaderBase = /** @class */ (function () {
         }
         // Configure pixel shader
         while (!pixelTokenizer.isEnd() && pixelTokenizer.getNextToken()) {
-            var tokenType = pixelTokenizer.currentToken;
+            const tokenType = pixelTokenizer.currentToken;
             if (tokenType !== ETokenType.IDENTIFIER) {
                 newPixelShader += pixelTokenizer.currentString;
                 continue;
@@ -1352,11 +1345,11 @@ var GLTFLoaderBase = /** @class */ (function () {
             newPixelShader += parseShaderUniforms(pixelTokenizer, technique, unTreatedUniforms);
         }
         // Create shader material
-        var shaderPath = {
+        const shaderPath = {
             vertex: program.vertexShader + id,
             fragment: program.fragmentShader + id,
         };
-        var options = {
+        const options = {
             attributes: attributes,
             uniforms: uniforms,
             samplers: samplers,
@@ -1364,16 +1357,16 @@ var GLTFLoaderBase = /** @class */ (function () {
         };
         Effect.ShadersStore[program.vertexShader + id + "VertexShader"] = newVertexShader;
         Effect.ShadersStore[program.fragmentShader + id + "PixelShader"] = newPixelShader;
-        var shaderMaterial = new ShaderMaterial(id, gltfRuntime.scene, shaderPath, options);
+        const shaderMaterial = new ShaderMaterial(id, gltfRuntime.scene, shaderPath, options);
         shaderMaterial.onError = onShaderCompileError(program, shaderMaterial, onError);
         shaderMaterial.onCompiled = onShaderCompileSuccess(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess);
         shaderMaterial.sideOrientation = Material.CounterClockWiseSideOrientation;
         if (states && states.functions) {
-            var functions = states.functions;
+            const functions = states.functions;
             if (functions.cullFace && functions.cullFace[0] !== ECullingType.BACK) {
                 shaderMaterial.backFaceCulling = false;
             }
-            var blendFunc = functions.blendFuncSeparate;
+            const blendFunc = functions.blendFuncSeparate;
             if (blendFunc) {
                 if (blendFunc[0] === EBlendingFunction.SRC_ALPHA &&
                     blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_ALPHA &&
@@ -1413,32 +1406,27 @@ var GLTFLoaderBase = /** @class */ (function () {
                 }
             }
         }
-    };
-    return GLTFLoaderBase;
-}());
-export { GLTFLoaderBase };
+    }
+}
 /**
  * glTF V1 Loader
  * @hidden
  * @deprecated
  */
-var GLTFLoader = /** @class */ (function () {
-    function GLTFLoader() {
-    }
-    GLTFLoader.RegisterExtension = function (extension) {
+export class GLTFLoader {
+    static RegisterExtension(extension) {
         if (GLTFLoader.Extensions[extension.name]) {
             Tools.Error('Tool with the same name "' + extension.name + '" already exists');
             return;
         }
         GLTFLoader.Extensions[extension.name] = extension;
-    };
-    GLTFLoader.prototype.dispose = function () {
+    }
+    dispose() {
         // do nothing
-    };
-    GLTFLoader.prototype._importMeshAsync = function (meshesNames, scene, data, rootUrl, assetContainer, onSuccess, onProgress, onError) {
-        var _this = this;
+    }
+    _importMeshAsync(meshesNames, scene, data, rootUrl, assetContainer, onSuccess, onProgress, onError) {
         scene.useRightHandedSystem = true;
-        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
+        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, (gltfRuntime) => {
             gltfRuntime.assetContainer = assetContainer;
             gltfRuntime.importOnlyMeshes = true;
             if (meshesNames === "") {
@@ -1455,25 +1443,25 @@ var GLTFLoader = /** @class */ (function () {
                 Tools.Warn("Argument meshesNames must be of type string or string[]");
             }
             // Create nodes
-            _this._createNodes(gltfRuntime);
-            var meshes = new Array();
-            var skeletons = new Array();
+            this._createNodes(gltfRuntime);
+            const meshes = new Array();
+            const skeletons = new Array();
             // Fill arrays of meshes and skeletons
-            for (var nde in gltfRuntime.nodes) {
-                var node = gltfRuntime.nodes[nde];
+            for (const nde in gltfRuntime.nodes) {
+                const node = gltfRuntime.nodes[nde];
                 if (node.babylonNode instanceof AbstractMesh) {
                     meshes.push(node.babylonNode);
                 }
             }
-            for (var skl in gltfRuntime.skins) {
-                var skin = gltfRuntime.skins[skl];
+            for (const skl in gltfRuntime.skins) {
+                const skin = gltfRuntime.skins[skl];
                 if (skin.babylonSkeleton instanceof Skeleton) {
                     skeletons.push(skin.babylonSkeleton);
                 }
             }
             // Load buffers, shaders, materials, etc.
-            _this._loadBuffersAsync(gltfRuntime, function () {
-                _this._loadShadersAsync(gltfRuntime, function () {
+            this._loadBuffersAsync(gltfRuntime, () => {
+                this._loadShadersAsync(gltfRuntime, () => {
                     importMaterials(gltfRuntime);
                     postLoad(gltfRuntime);
                     if (!GLTFFileLoader.IncrementalLoading && onSuccess) {
@@ -1486,7 +1474,7 @@ var GLTFLoader = /** @class */ (function () {
             }
         }, onError);
         return true;
-    };
+    }
     /**
      * Imports one or more meshes from a loaded gltf file and adds them to the scene
      * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
@@ -1497,10 +1485,9 @@ var GLTFLoader = /** @class */ (function () {
      * @param onProgress event that fires when loading progress has occured
      * @returns a promise containg the loaded meshes, particles, skeletons and animations
      */
-    GLTFLoader.prototype.importMeshAsync = function (meshesNames, scene, assetContainer, data, rootUrl, onProgress) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            _this._importMeshAsync(meshesNames, scene, data, rootUrl, assetContainer, function (meshes, skeletons) {
+    importMeshAsync(meshesNames, scene, assetContainer, data, rootUrl, onProgress) {
+        return new Promise((resolve, reject) => {
+            this._importMeshAsync(meshesNames, scene, data, rootUrl, assetContainer, (meshes, skeletons) => {
                 resolve({
                     meshes: meshes,
                     particleSystems: [],
@@ -1510,22 +1497,21 @@ var GLTFLoader = /** @class */ (function () {
                     transformNodes: [],
                     geometries: [],
                 });
-            }, onProgress, function (message) {
+            }, onProgress, (message) => {
                 reject(new Error(message));
             });
         });
-    };
-    GLTFLoader.prototype._loadAsync = function (scene, data, rootUrl, onSuccess, onProgress, onError) {
-        var _this = this;
+    }
+    _loadAsync(scene, data, rootUrl, onSuccess, onProgress, onError) {
         scene.useRightHandedSystem = true;
-        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
+        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, (gltfRuntime) => {
             // Load runtime extensios
-            GLTFLoaderExtension.LoadRuntimeExtensionsAsync(gltfRuntime, function () {
+            GLTFLoaderExtension.LoadRuntimeExtensionsAsync(gltfRuntime, () => {
                 // Create nodes
-                _this._createNodes(gltfRuntime);
+                this._createNodes(gltfRuntime);
                 // Load buffers, shaders, materials, etc.
-                _this._loadBuffersAsync(gltfRuntime, function () {
-                    _this._loadShadersAsync(gltfRuntime, function () {
+                this._loadBuffersAsync(gltfRuntime, () => {
+                    this._loadShadersAsync(gltfRuntime, () => {
                         importMaterials(gltfRuntime);
                         postLoad(gltfRuntime);
                         if (!GLTFFileLoader.IncrementalLoading) {
@@ -1538,7 +1524,7 @@ var GLTFLoader = /** @class */ (function () {
                 }
             }, onError);
         }, onError);
-    };
+    }
     /**
      * Imports all objects from a loaded gltf file and adds them to the scene
      * @param scene the scene the objects should be added to
@@ -1547,20 +1533,19 @@ var GLTFLoader = /** @class */ (function () {
      * @param onProgress event that fires when loading progress has occured
      * @returns a promise which completes when objects have been loaded to the scene
      */
-    GLTFLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            _this._loadAsync(scene, data, rootUrl, function () {
+    loadAsync(scene, data, rootUrl, onProgress) {
+        return new Promise((resolve, reject) => {
+            this._loadAsync(scene, data, rootUrl, () => {
                 resolve();
-            }, onProgress, function (message) {
+            }, onProgress, (message) => {
                 reject(new Error(message));
             });
         });
-    };
-    GLTFLoader.prototype._loadShadersAsync = function (gltfRuntime, onload) {
-        var hasShaders = false;
-        var processShader = function (sha, shader) {
-            GLTFLoaderExtension.LoadShaderStringAsync(gltfRuntime, sha, function (shaderString) {
+    }
+    _loadShadersAsync(gltfRuntime, onload) {
+        let hasShaders = false;
+        const processShader = (sha, shader) => {
+            GLTFLoaderExtension.LoadShaderStringAsync(gltfRuntime, sha, (shaderString) => {
                 if (shaderString instanceof ArrayBuffer) {
                     return;
                 }
@@ -1571,13 +1556,13 @@ var GLTFLoader = /** @class */ (function () {
                 if (gltfRuntime.loadedShaderCount === gltfRuntime.shaderscount) {
                     onload();
                 }
-            }, function () {
+            }, () => {
                 Tools.Error("Error when loading shader program named " + sha + " located at " + shader.uri);
             });
         };
-        for (var sha in gltfRuntime.shaders) {
+        for (const sha in gltfRuntime.shaders) {
             hasShaders = true;
-            var shader = gltfRuntime.shaders[sha];
+            const shader = gltfRuntime.shaders[sha];
             if (shader) {
                 processShader.bind(this, sha, shader)();
             }
@@ -1588,11 +1573,11 @@ var GLTFLoader = /** @class */ (function () {
         if (!hasShaders) {
             onload();
         }
-    };
-    GLTFLoader.prototype._loadBuffersAsync = function (gltfRuntime, onLoad) {
-        var hasBuffers = false;
-        var processBuffer = function (buf, buffer) {
-            GLTFLoaderExtension.LoadBufferAsync(gltfRuntime, buf, function (bufferView) {
+    }
+    _loadBuffersAsync(gltfRuntime, onLoad) {
+        let hasBuffers = false;
+        const processBuffer = (buf, buffer) => {
+            GLTFLoaderExtension.LoadBufferAsync(gltfRuntime, buf, (bufferView) => {
                 gltfRuntime.loadedBufferCount++;
                 if (bufferView) {
                     if (bufferView.byteLength != gltfRuntime.buffers[buf].byteLength) {
@@ -1603,13 +1588,13 @@ var GLTFLoader = /** @class */ (function () {
                 if (gltfRuntime.loadedBufferCount === gltfRuntime.buffersCount) {
                     onLoad();
                 }
-            }, function () {
+            }, () => {
                 Tools.Error("Error when loading buffer named " + buf + " located at " + buffer.uri);
             });
         };
-        for (var buf in gltfRuntime.buffers) {
+        for (const buf in gltfRuntime.buffers) {
             hasBuffers = true;
-            var buffer = gltfRuntime.buffers[buf];
+            const buffer = gltfRuntime.buffers[buf];
             if (buffer) {
                 processBuffer.bind(this, buf, buffer)();
             }
@@ -1620,41 +1605,35 @@ var GLTFLoader = /** @class */ (function () {
         if (!hasBuffers) {
             onLoad();
         }
-    };
-    GLTFLoader.prototype._createNodes = function (gltfRuntime) {
-        var currentScene = gltfRuntime.currentScene;
+    }
+    _createNodes(gltfRuntime) {
+        let currentScene = gltfRuntime.currentScene;
         if (currentScene) {
             // Only one scene even if multiple scenes are defined
-            for (var i = 0; i < currentScene.nodes.length; i++) {
+            for (let i = 0; i < currentScene.nodes.length; i++) {
                 traverseNodes(gltfRuntime, currentScene.nodes[i], null);
             }
         }
         else {
             // Load all scenes
-            for (var thing in gltfRuntime.scenes) {
+            for (const thing in gltfRuntime.scenes) {
                 currentScene = gltfRuntime.scenes[thing];
-                for (var i = 0; i < currentScene.nodes.length; i++) {
+                for (let i = 0; i < currentScene.nodes.length; i++) {
                     traverseNodes(gltfRuntime, currentScene.nodes[i], null);
                 }
             }
         }
-    };
-    GLTFLoader.Extensions = {};
-    return GLTFLoader;
-}());
-export { GLTFLoader };
+    }
+}
+GLTFLoader.Extensions = {};
 /** @hidden */
-var GLTFLoaderExtension = /** @class */ (function () {
-    function GLTFLoaderExtension(name) {
+export class GLTFLoaderExtension {
+    constructor(name) {
         this._name = name;
     }
-    Object.defineProperty(GLTFLoaderExtension.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    get name() {
+        return this._name;
+    }
     /**
      * Defines an override for loading the runtime
      * Return true to stop further extensions from loading the runtime
@@ -1664,9 +1643,9 @@ var GLTFLoaderExtension = /** @class */ (function () {
      * @param onSuccess
      * @param onError
      */
-    GLTFLoaderExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
+    loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError) {
         return false;
-    };
+    }
     /**
      * Defines an onverride for creating gltf runtime
      * Return true to stop further extensions from creating the runtime
@@ -1674,9 +1653,9 @@ var GLTFLoaderExtension = /** @class */ (function () {
      * @param onSuccess
      * @param onError
      */
-    GLTFLoaderExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
+    loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError) {
         return false;
-    };
+    }
     /**
      * Defines an override for loading buffers
      * Return true to stop further extensions from loading this buffer
@@ -1686,9 +1665,9 @@ var GLTFLoaderExtension = /** @class */ (function () {
      * @param onError
      * @param onProgress
      */
-    GLTFLoaderExtension.prototype.loadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
+    loadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress) {
         return false;
-    };
+    }
     /**
      * Defines an override for loading texture buffers
      * Return true to stop further extensions from loading this texture data
@@ -1697,9 +1676,9 @@ var GLTFLoaderExtension = /** @class */ (function () {
      * @param onSuccess
      * @param onError
      */
-    GLTFLoaderExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
+    loadTextureBufferAsync(gltfRuntime, id, onSuccess, onError) {
         return false;
-    };
+    }
     /**
      * Defines an override for creating textures
      * Return true to stop further extensions from loading this texture
@@ -1709,9 +1688,9 @@ var GLTFLoaderExtension = /** @class */ (function () {
      * @param onSuccess
      * @param onError
      */
-    GLTFLoaderExtension.prototype.createTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) {
+    createTextureAsync(gltfRuntime, id, buffer, onSuccess, onError) {
         return false;
-    };
+    }
     /**
      * Defines an override for loading shader strings
      * Return true to stop further extensions from loading this shader data
@@ -1720,9 +1699,9 @@ var GLTFLoaderExtension = /** @class */ (function () {
      * @param onSuccess
      * @param onError
      */
-    GLTFLoaderExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
+    loadShaderStringAsync(gltfRuntime, id, onSuccess, onError) {
         return false;
-    };
+    }
     /**
      * Defines an override for loading materials
      * Return true to stop further extensions from loading this material
@@ -1731,86 +1710,84 @@ var GLTFLoaderExtension = /** @class */ (function () {
      * @param onSuccess
      * @param onError
      */
-    GLTFLoaderExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
+    loadMaterialAsync(gltfRuntime, id, onSuccess, onError) {
         return false;
-    };
+    }
     // ---------
     // Utilities
     // ---------
-    GLTFLoaderExtension.LoadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
-        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+    static LoadRuntimeAsync(scene, data, rootUrl, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError);
-        }, function () {
-            setTimeout(function () {
+        }, () => {
+            setTimeout(() => {
                 if (!onSuccess) {
                     return;
                 }
                 onSuccess(GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl));
             });
         });
-    };
-    GLTFLoaderExtension.LoadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
-        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+    }
+    static LoadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError);
-        }, function () {
-            setTimeout(function () {
+        }, () => {
+            setTimeout(() => {
                 onSuccess();
             });
         });
-    };
-    GLTFLoaderExtension.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
-        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+    }
+    static LoadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress) {
+        GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress);
-        }, function () {
+        }, () => {
             GLTFLoaderBase.LoadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress);
         });
-    };
-    GLTFLoaderExtension.LoadTextureAsync = function (gltfRuntime, id, onSuccess, onError) {
-        GLTFLoaderExtension._LoadTextureBufferAsync(gltfRuntime, id, function (buffer) {
+    }
+    static LoadTextureAsync(gltfRuntime, id, onSuccess, onError) {
+        GLTFLoaderExtension._LoadTextureBufferAsync(gltfRuntime, id, (buffer) => {
             if (buffer) {
                 GLTFLoaderExtension._CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
             }
         }, onError);
-    };
-    GLTFLoaderExtension.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
-        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+    }
+    static LoadShaderStringAsync(gltfRuntime, id, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadShaderStringAsync(gltfRuntime, id, onSuccess, onError);
-        }, function () {
+        }, () => {
             GLTFLoaderBase.LoadShaderStringAsync(gltfRuntime, id, onSuccess, onError);
         });
-    };
-    GLTFLoaderExtension.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
-        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+    }
+    static LoadMaterialAsync(gltfRuntime, id, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadMaterialAsync(gltfRuntime, id, onSuccess, onError);
-        }, function () {
+        }, () => {
             GLTFLoaderBase.LoadMaterialAsync(gltfRuntime, id, onSuccess, onError);
         });
-    };
-    GLTFLoaderExtension._LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
-        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+    }
+    static _LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
-        }, function () {
+        }, () => {
             GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
         });
-    };
-    GLTFLoaderExtension._CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) {
-        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+    }
+    static _CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.createTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
-        }, function () {
+        }, () => {
             GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess);
         });
-    };
-    GLTFLoaderExtension._ApplyExtensions = function (func, defaultFunc) {
-        for (var extensionName in GLTFLoader.Extensions) {
-            var loaderExtension = GLTFLoader.Extensions[extensionName];
+    }
+    static _ApplyExtensions(func, defaultFunc) {
+        for (const extensionName in GLTFLoader.Extensions) {
+            const loaderExtension = GLTFLoader.Extensions[extensionName];
             if (func(loaderExtension)) {
                 return;
             }
         }
         defaultFunc();
-    };
-    return GLTFLoaderExtension;
-}());
-export { GLTFLoaderExtension };
-GLTFFileLoader._CreateGLTF1Loader = function () { return new GLTFLoader(); };
+    }
+}
+GLTFFileLoader._CreateGLTF1Loader = () => new GLTFLoader();
 //# sourceMappingURL=glTFLoader.js.map