@babylonjs/loaders 5.0.0-rc.2 → 5.0.0-rc.5

package/glTF/1.0/glTFLoader.js

@@ -1,6 +1,7 @@
-import { EParameterType, ETextureFilterType, ECullingType, EBlendingFunction, EShaderType } from "./glTFLoaderInterfaces.js";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { EParameterType, ETextureFilterType, ECullingType, EBlendingFunction, EShaderType, } from "./glTFLoaderInterfaces.js";
 import { Quaternion, Vector3, Matrix } from "@babylonjs/core/Maths/math.vector.js";
-import { Color3 } from '@babylonjs/core/Maths/math.color.js';
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
 import { Tools } from "@babylonjs/core/Misc/tools.js";
 import { Camera } from "@babylonjs/core/Cameras/camera.js";
 import { FreeCamera } from "@babylonjs/core/Cameras/freeCamera.js";
@@ -25,11 +26,11 @@ import { PointLight } from "@babylonjs/core/Lights/pointLight.js";
 import { SpotLight } from "@babylonjs/core/Lights/spotLight.js";
 import { GLTFUtils } from "./glTFLoaderUtils.js";
 import { GLTFFileLoader } from "../glTFFileLoader.js";
-import { Constants } from '@babylonjs/core/Engines/constants.js';
+import { Constants } from "@babylonjs/core/Engines/constants.js";
 /**
-* Tokenizer. Used for shaders compatibility
-* Automatically map world, view, projection, worldViewProjection, attributes and so on
-*/
+ * Tokenizer. Used for shaders compatibility
+ * Automatically map world, view, projection, worldViewProjection, attributes and so on
+ */
 var ETokenType;
 (function (ETokenType) {
     ETokenType[ETokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
@@ -55,7 +56,7 @@ var Tokenizer = /** @class */ (function () {
         if (this.currentString === "_" || this.isLetterOrDigitPattern.test(this.currentString)) {
             this.currentToken = ETokenType.IDENTIFIER;
             this.currentIdentifier = this.currentString;
-            while (!this.isEnd() && (this.isLetterOrDigitPattern.test(this.currentString = this.peek()) || this.currentString === "_")) {
+            while (!this.isEnd() && (this.isLetterOrDigitPattern.test((this.currentString = this.peek())) || this.currentString === "_")) {
                 this.currentIdentifier += this.currentString;
                 this.forward();
             }
@@ -77,15 +78,17 @@ var Tokenizer = /** @class */ (function () {
     return Tokenizer;
 }());
 /**
-* Values
-*/
+ * 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"];
 /**
-* Parse
-*/
+ * Parse
+ * @param parsedBuffers
+ * @param gltfRuntime
+ */
 var parseBuffers = function (parsedBuffers, gltfRuntime) {
     for (var buf in parsedBuffers) {
         var parsedBuffer = parsedBuffers[buf];
@@ -107,8 +110,9 @@ var parseObject = function (parsedObjects, runtimeProperty, gltfRuntime) {
     }
 };
 /**
-* Utils
-*/
+ * Utils
+ * @param buffer
+ */
 var normalizeUVs = function (buffer) {
     if (!buffer) {
         return;
@@ -140,8 +144,9 @@ var getAttribute = function (attributeParameter) {
     return null;
 };
 /**
-* Loads and creates animations
-*/
+ * Loads and creates animations
+ * @param gltfRuntime
+ */
 var loadAnimations = function (gltfRuntime) {
     for (var anim in gltfRuntime.animations) {
         var animation = gltfRuntime.animations[anim];
@@ -212,11 +217,13 @@ var loadAnimations = function (gltfRuntime) {
             // For each frame
             for (var j = 0; j < bufferInput.length; j++) {
                 var value = null;
-                if (targetPath === "rotationQuaternion") { // VEC4
+                if (targetPath === "rotationQuaternion") {
+                    // VEC4
                     value = Quaternion.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2], bufferOutput[arrayOffset + 3]]);
                     arrayOffset += 4;
                 }
-                else { // Position and scaling are VEC3
+                else {
+                    // Position and scaling are VEC3
                     value = Vector3.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]);
                     arrayOffset += 3;
                 }
@@ -245,7 +252,7 @@ var loadAnimations = function (gltfRuntime) {
                 if (!modifyKey) {
                     keys.push({
                         frame: bufferInput[j],
-                        value: value
+                        value: value,
                     });
                 }
                 else if (lastAnimation) {
@@ -264,8 +271,9 @@ var loadAnimations = function (gltfRuntime) {
     }
 };
 /**
-* Returns the bones transformation matrix
-*/
+ * Returns the bones transformation matrix
+ * @param node
+ */
 var configureBoneTransformation = function (node) {
     var mat = null;
     if (node.translation || node.rotation || node.scale) {
@@ -280,8 +288,12 @@ var configureBoneTransformation = function (node) {
     return mat;
 };
 /**
-* Returns the parent bone
-*/
+ * Returns the parent bone
+ * @param gltfRuntime
+ * @param skins
+ * @param jointName
+ * @param newSkeleton
+ */
 var getParentBone = function (gltfRuntime, skins, jointName, newSkeleton) {
     // Try to find
     for (var i = 0; i < newSkeleton.bones.length; i++) {
@@ -313,8 +325,10 @@ var getParentBone = function (gltfRuntime, skins, jointName, newSkeleton) {
     return null;
 };
 /**
-* Returns the appropriate root node
-*/
+ * Returns the appropriate root node
+ * @param nodesToRoot
+ * @param id
+ */
 var getNodeToRoot = function (nodesToRoot, id) {
     for (var i = 0; i < nodesToRoot.length; i++) {
         var nodeToRoot = nodesToRoot[i];
@@ -328,15 +342,17 @@ var getNodeToRoot = function (nodesToRoot, id) {
     return null;
 };
 /**
-* Returns the node with the joint name
-*/
+ * Returns the node with the joint name
+ * @param gltfRuntime
+ * @param jointName
+ */
 var getJointNode = function (gltfRuntime, jointName) {
     var nodes = gltfRuntime.nodes;
     var node = nodes[jointName];
     if (node) {
         return {
             node: node,
-            id: jointName
+            id: jointName,
         };
     }
     for (var nde in nodes) {
@@ -344,15 +360,17 @@ var getJointNode = function (gltfRuntime, jointName) {
         if (node.jointName === jointName) {
             return {
                 node: node,
-                id: nde
+                id: nde,
             };
         }
     }
     return null;
 };
 /**
-* Checks if a nodes is in joints
-*/
+ * Checks if a nodes is in joints
+ * @param skins
+ * @param id
+ */
 var nodeIsInJoints = function (skins, id) {
     for (var i = 0; i < skins.jointNames.length; i++) {
         if (skins.jointNames[i] === id) {
@@ -362,8 +380,12 @@ var nodeIsInJoints = function (skins, id) {
     return false;
 };
 /**
-* Fills the nodes to root for bones and builds hierarchy
-*/
+ * Fills the nodes to root for bones and builds hierarchy
+ * @param gltfRuntime
+ * @param newSkeleton
+ * @param skins
+ * @param nodesToRoot
+ */
 var getNodesToRoot = function (gltfRuntime, newSkeleton, skins, nodesToRoot) {
     // Creates nodes for root
     for (var nde in gltfRuntime.nodes) {
@@ -398,9 +420,13 @@ var getNodesToRoot = function (gltfRuntime, newSkeleton, skins, nodesToRoot) {
     }
 };
 /**
-* Imports a skeleton
-*/
-var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton, id) {
+ * Imports a skeleton
+ * @param gltfRuntime
+ * @param skins
+ * @param mesh
+ * @param newSkeleton
+ */
+var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
     if (!newSkeleton) {
         newSkeleton = new Skeleton(skins.name || "", "", gltfRuntime.scene);
     }
@@ -495,8 +521,13 @@ var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton, id) {
     return newSkeleton;
 };
 /**
-* Imports a mesh and its geometries
-*/
+ * Imports a mesh and its geometries
+ * @param gltfRuntime
+ * @param node
+ * @param meshes
+ * @param id
+ * @param newMesh
+ */
 var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
     if (!newMesh) {
         gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
@@ -557,7 +588,7 @@ var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
                 }
                 else if (semantic.indexOf("TEXCOORD_") !== -1) {
                     var channel = Number(semantic.split("_")[1]);
-                    var uvKind = VertexBuffer.UVKind + (channel === 0 ? "" : (channel + 1));
+                    var uvKind = VertexBuffer.UVKind + (channel === 0 ? "" : channel + 1);
                     var uvs = new Float32Array(buffer.length);
                     uvs.set(buffer);
                     normalizeUVs(uvs);
@@ -648,8 +679,12 @@ var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
     return newMesh;
 };
 /**
-* Configure node transformation from position, rotation and scaling
-*/
+ * Configure node transformation from position, rotation and scaling
+ * @param newNode
+ * @param position
+ * @param rotation
+ * @param scaling
+ */
 var configureNode = function (newNode, position, rotation, scaling) {
     if (newNode.position) {
         newNode.position = position;
@@ -662,9 +697,11 @@ var configureNode = function (newNode, position, rotation, scaling) {
     }
 };
 /**
-* Configures node from transformation matrix
-*/
-var configureNodeFromMatrix = function (newNode, node, parent) {
+ * Configures node from transformation matrix
+ * @param newNode
+ * @param node
+ */
+var configureNodeFromMatrix = function (newNode, node) {
     if (node.matrix) {
         var position = new Vector3(0, 0, 0);
         var rotation = new Quaternion();
@@ -679,9 +716,12 @@ var configureNodeFromMatrix = function (newNode, node, parent) {
     newNode.computeWorldMatrix(true);
 };
 /**
-* Imports a node
-*/
-var importNode = function (gltfRuntime, node, id, parent) {
+ * Imports a node
+ * @param gltfRuntime
+ * @param node
+ * @param id
+ */
+var importNode = function (gltfRuntime, node, id) {
     var lastNode = null;
     if (gltfRuntime.importOnlyMeshes && (node.skin || node.meshes)) {
         if (gltfRuntime.importMeshesNames && gltfRuntime.importMeshesNames.length > 0 && gltfRuntime.importMeshesNames.indexOf(node.name || "") === -1) {
@@ -695,7 +735,7 @@ var importNode = function (gltfRuntime, node, id, parent) {
             var 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, node.skin);
+                newMesh.skeleton = importSkeleton(gltfRuntime, skin, newMesh, skin.babylonSkeleton);
                 if (!skin.babylonSkeleton) {
                     skin.babylonSkeleton = newMesh.skeleton;
                 }
@@ -705,8 +745,8 @@ var importNode = function (gltfRuntime, node, id, parent) {
     }
     else if (node.meshes) {
         /**
-        * Improve meshes property
-        */
+         * Improve meshes property
+         */
         var newMesh = importMesh(gltfRuntime, node, node.mesh ? [node.mesh] : node.meshes, id, node.babylonNode);
         lastNode = newMesh;
     }
@@ -805,7 +845,7 @@ var importNode = function (gltfRuntime, node, id, parent) {
     }
     if (lastNode !== null) {
         if (node.matrix && lastNode instanceof Mesh) {
-            configureNodeFromMatrix(lastNode, node, parent);
+            configureNodeFromMatrix(lastNode, node);
         }
         else {
             var translation = node.translation || [0, 0, 0];
@@ -819,8 +859,12 @@ var importNode = function (gltfRuntime, node, id, parent) {
     return lastNode;
 };
 /**
-* Traverses nodes and creates them
-*/
+ * Traverses nodes and creates them
+ * @param gltfRuntime
+ * @param id
+ * @param parent
+ * @param meshIncluded
+ */
 var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
     if (meshIncluded === void 0) { meshIncluded = false; }
     var node = gltfRuntime.nodes[id];
@@ -837,7 +881,7 @@ var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
         meshIncluded = true;
     }
     if (!node.jointName && meshIncluded) {
-        newNode = importNode(gltfRuntime, node, id, parent);
+        newNode = importNode(gltfRuntime, node, id);
         if (newNode !== null) {
             newNode.id = id;
             newNode.parent = parent;
@@ -850,8 +894,9 @@ var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
     }
 };
 /**
-* do stuff after buffers, shaders are loaded (e.g. hook up materials, load animations, etc.)
-*/
+ * do stuff after buffers, shaders are loaded (e.g. hook up materials, load animations, etc.)
+ * @param gltfRuntime
+ */
 var postLoad = function (gltfRuntime) {
     // Nodes
     var currentScene = gltfRuntime.currentScene;
@@ -876,8 +921,15 @@ var postLoad = function (gltfRuntime) {
     }
 };
 /**
-* onBind shaderrs callback to set uniforms and matrices
-*/
+ * onBind shaderrs callback to set uniforms and matrices
+ * @param mesh
+ * @param gltfRuntime
+ * @param unTreatedUniforms
+ * @param shaderMaterial
+ * @param technique
+ * @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) {
@@ -911,23 +963,24 @@ var onBindShaderMaterial = function (mesh, gltfRuntime, unTreatedUniforms, shade
                 shaderMaterial.getEffect().setTexture(unif, texture);
             }
             else {
-                GLTFUtils.SetUniform((shaderMaterial.getEffect()), unif, value, type);
+                GLTFUtils.SetUniform(shaderMaterial.getEffect(), unif, value, type);
             }
         }
     }
     onSuccess(shaderMaterial);
 };
 /**
-* Prepare uniforms to send the only one time
-* Loads the appropriate textures
-*/
+ * Prepare uniforms to send the only one time
+ * Loads the appropriate textures
+ * @param gltfRuntime
+ * @param shaderMaterial
+ * @param technique
+ * @param material
+ */
 var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) {
     var materialValues = material.values || technique.parameters;
     var techniqueUniforms = technique.uniforms;
-    /**
-    * Prepare values here (not matrices)
-    */
-    for (var unif in unTreatedUniforms) {
+    var _loop_1 = function (unif) {
         var uniform = unTreatedUniforms[unif];
         var type = uniform.type;
         var value = materialValues[techniqueUniforms[unif]];
@@ -936,7 +989,7 @@ var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, techn
             value = uniform.value;
         }
         if (!value) {
-            continue;
+            return "continue";
         }
         var onLoadTexture = function (uniformName) {
             return function (texture) {
@@ -958,11 +1011,20 @@ var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, techn
                 delete unTreatedUniforms[unif];
             }
         }
+    };
+    /**
+     * Prepare values here (not matrices)
+     */
+    for (var unif in unTreatedUniforms) {
+        _loop_1(unif);
     }
 };
 /**
-* Shader compilation failed
-*/
+ * Shader compilation failed
+ * @param program
+ * @param shaderMaterial
+ * @param onError
+ */
 var onShaderCompileError = function (program, shaderMaterial, onError) {
     return function (effect, error) {
         shaderMaterial.dispose(true);
@@ -970,8 +1032,14 @@ var onShaderCompileError = function (program, shaderMaterial, onError) {
     };
 };
 /**
-* Shader compilation success
-*/
+ * Shader compilation success
+ * @param gltfRuntime
+ * @param shaderMaterial
+ * @param technique
+ * @param material
+ * @param unTreatedUniforms
+ * @param onSuccess
+ */
 var onShaderCompileSuccess = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess) {
     return function (_) {
         prepareShaderMaterialUniforms(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms);
@@ -981,8 +1049,10 @@ var onShaderCompileSuccess = function (gltfRuntime, shaderMaterial, technique, m
     };
 };
 /**
-* Returns the appropriate uniform if already handled by babylon
-*/
+ * Returns the appropriate uniform if already handled by babylon
+ * @param tokenizer
+ * @param technique
+ */
 var parseShaderUniforms = function (tokenizer, technique, unTreatedUniforms) {
     for (var unif in technique.uniforms) {
         var uniform = technique.uniforms[unif];
@@ -1000,18 +1070,19 @@ var parseShaderUniforms = function (tokenizer, technique, unTreatedUniforms) {
     return tokenizer.currentIdentifier;
 };
 /**
-* All shaders loaded. Create materials one by one
-*/
+ * All shaders loaded. Create materials one by one
+ * @param gltfRuntime
+ */
 var importMaterials = function (gltfRuntime) {
     // Create materials
     for (var mat in gltfRuntime.materials) {
-        GLTFLoaderExtension.LoadMaterialAsync(gltfRuntime, mat, function (material) { }, function () { });
+        GLTFLoaderExtension.LoadMaterialAsync(gltfRuntime, mat, function () { }, function () { });
     }
 };
 /**
-* Implementation of the base glTF spec
-* @hidden
-*/
+ * Implementation of the base glTF spec
+ * @hidden
+ */
 var GLTFLoaderBase = /** @class */ (function () {
     function GLTFLoaderBase() {
     }
@@ -1045,7 +1116,7 @@ var GLTFLoaderBase = /** @class */ (function () {
             loadedShaderCount: 0,
             importOnlyMeshes: false,
             dummyNodes: [],
-            assetContainer: null
+            assetContainer: null,
         };
         // Parse
         if (parsedData.extensions) {
@@ -1145,17 +1216,17 @@ var GLTFLoaderBase = /** @class */ (function () {
             });
         }
     };
-    GLTFLoaderBase.CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) {
+    GLTFLoaderBase.CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess) {
         var 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) ||
-            (sampler.minFilter === ETextureFilterType.NEAREST_MIPMAP_LINEAR) ||
-            (sampler.minFilter === ETextureFilterType.LINEAR_MIPMAP_NEAREST) ||
-            (sampler.minFilter === ETextureFilterType.LINEAR_MIPMAP_LINEAR);
+        var 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);
@@ -1284,13 +1355,13 @@ var GLTFLoaderBase = /** @class */ (function () {
         // Create shader material
         var shaderPath = {
             vertex: program.vertexShader + id,
-            fragment: program.fragmentShader + id
+            fragment: program.fragmentShader + id,
         };
         var options = {
             attributes: attributes,
             uniforms: uniforms,
             samplers: samplers,
-            needAlphaBlending: states && states.enable && states.enable.indexOf(3042) !== -1
+            needAlphaBlending: states && states.enable && states.enable.indexOf(3042) !== -1,
         };
         Effect.ShadersStore[program.vertexShader + id + "VertexShader"] = newVertexShader;
         Effect.ShadersStore[program.fragmentShader + id + "PixelShader"] = newPixelShader;
@@ -1305,22 +1376,40 @@ var GLTFLoaderBase = /** @class */ (function () {
             }
             var blendFunc = functions.blendFuncSeparate;
             if (blendFunc) {
-                if (blendFunc[0] === EBlendingFunction.SRC_ALPHA && blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_ALPHA && blendFunc[2] === EBlendingFunction.ONE && blendFunc[3] === EBlendingFunction.ONE) {
+                if (blendFunc[0] === EBlendingFunction.SRC_ALPHA &&
+                    blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_ALPHA &&
+                    blendFunc[2] === EBlendingFunction.ONE &&
+                    blendFunc[3] === EBlendingFunction.ONE) {
                     shaderMaterial.alphaMode = Constants.ALPHA_COMBINE;
                 }
-                else if (blendFunc[0] === EBlendingFunction.ONE && blendFunc[1] === EBlendingFunction.ONE && blendFunc[2] === EBlendingFunction.ZERO && blendFunc[3] === EBlendingFunction.ONE) {
+                else if (blendFunc[0] === EBlendingFunction.ONE &&
+                    blendFunc[1] === EBlendingFunction.ONE &&
+                    blendFunc[2] === EBlendingFunction.ZERO &&
+                    blendFunc[3] === EBlendingFunction.ONE) {
                     shaderMaterial.alphaMode = Constants.ALPHA_ONEONE;
                 }
-                else if (blendFunc[0] === EBlendingFunction.SRC_ALPHA && blendFunc[1] === EBlendingFunction.ONE && blendFunc[2] === EBlendingFunction.ZERO && blendFunc[3] === EBlendingFunction.ONE) {
+                else if (blendFunc[0] === EBlendingFunction.SRC_ALPHA &&
+                    blendFunc[1] === EBlendingFunction.ONE &&
+                    blendFunc[2] === EBlendingFunction.ZERO &&
+                    blendFunc[3] === EBlendingFunction.ONE) {
                     shaderMaterial.alphaMode = Constants.ALPHA_ADD;
                 }
-                else if (blendFunc[0] === EBlendingFunction.ZERO && blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_COLOR && blendFunc[2] === EBlendingFunction.ONE && blendFunc[3] === EBlendingFunction.ONE) {
+                else if (blendFunc[0] === EBlendingFunction.ZERO &&
+                    blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_COLOR &&
+                    blendFunc[2] === EBlendingFunction.ONE &&
+                    blendFunc[3] === EBlendingFunction.ONE) {
                     shaderMaterial.alphaMode = Constants.ALPHA_SUBTRACT;
                 }
-                else if (blendFunc[0] === EBlendingFunction.DST_COLOR && blendFunc[1] === EBlendingFunction.ZERO && blendFunc[2] === EBlendingFunction.ONE && blendFunc[3] === EBlendingFunction.ONE) {
+                else if (blendFunc[0] === EBlendingFunction.DST_COLOR &&
+                    blendFunc[1] === EBlendingFunction.ZERO &&
+                    blendFunc[2] === EBlendingFunction.ONE &&
+                    blendFunc[3] === EBlendingFunction.ONE) {
                     shaderMaterial.alphaMode = Constants.ALPHA_MULTIPLY;
                 }
-                else if (blendFunc[0] === EBlendingFunction.SRC_ALPHA && blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_COLOR && blendFunc[2] === EBlendingFunction.ONE && blendFunc[3] === EBlendingFunction.ONE) {
+                else if (blendFunc[0] === EBlendingFunction.SRC_ALPHA &&
+                    blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_COLOR &&
+                    blendFunc[2] === EBlendingFunction.ONE &&
+                    blendFunc[3] === EBlendingFunction.ONE) {
                     shaderMaterial.alphaMode = Constants.ALPHA_MAXIMIZED;
                 }
             }
@@ -1330,15 +1419,15 @@ var GLTFLoaderBase = /** @class */ (function () {
 }());
 export { GLTFLoaderBase };
 /**
-* glTF V1 Loader
-* @hidden
-*/
+ * glTF V1 Loader
+ * @hidden
+ */
 var GLTFLoader = /** @class */ (function () {
     function GLTFLoader() {
     }
     GLTFLoader.RegisterExtension = function (extension) {
         if (GLTFLoader.Extensions[extension.name]) {
-            Tools.Error("Tool with the same name \"" + extension.name + "\" already exists");
+            Tools.Error('Tool with the same name "' + extension.name + '" already exists');
             return;
         }
         GLTFLoader.Extensions[extension.name] = extension;
@@ -1391,7 +1480,7 @@ var GLTFLoader = /** @class */ (function () {
                         onSuccess(meshes, skeletons);
                     }
                 });
-            }, onProgress);
+            });
             if (GLTFFileLoader.IncrementalLoading && onSuccess) {
                 onSuccess(meshes, skeletons);
             }
@@ -1399,15 +1488,15 @@ var GLTFLoader = /** @class */ (function () {
         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
-    * @param scene the scene the meshes should be added to
-    * @param assetContainer defines the asset container to use (can be null)
-    * @param data gltf data containing information of the meshes in a loaded file
-    * @param rootUrl root url to load from
-    * @param onProgress event that fires when loading progress has occured
-    * @returns a promise containg the loaded meshes, particles, skeletons and animations
-    */
+     * 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
+     * @param scene the scene the meshes should be added to
+     * @param assetContainer defines the asset container to use (can be null)
+     * @param data gltf data containing information of the meshes in a loaded file
+     * @param rootUrl root url to load from
+     * @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) {
@@ -1419,7 +1508,7 @@ var GLTFLoader = /** @class */ (function () {
                     animationGroups: [],
                     lights: [],
                     transformNodes: [],
-                    geometries: []
+                    geometries: [],
                 });
             }, onProgress, function (message) {
                 reject(new Error(message));
@@ -1451,13 +1540,13 @@ var GLTFLoader = /** @class */ (function () {
         }, 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
-    * @param data gltf data containing information of the meshes in a loaded file
-    * @param rootUrl root url to load from
-    * @param onProgress event that fires when loading progress has occured
-    * @returns a promise which completes when objects have been loaded to the scene
-    */
+     * Imports all objects from a loaded gltf file and adds them to the scene
+     * @param scene the scene the objects should be added to
+     * @param data gltf data containing information of the meshes in a loaded file
+     * @param rootUrl root url to load from
+     * @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) {
@@ -1500,7 +1589,7 @@ var GLTFLoader = /** @class */ (function () {
             onload();
         }
     };
-    GLTFLoader.prototype._loadBuffersAsync = function (gltfRuntime, onLoad, onProgress) {
+    GLTFLoader.prototype._loadBuffersAsync = function (gltfRuntime, onLoad) {
         var hasBuffers = false;
         var processBuffer = function (buf, buffer) {
             GLTFLoaderExtension.LoadBufferAsync(gltfRuntime, buf, function (bufferView) {
@@ -1567,51 +1656,81 @@ var GLTFLoaderExtension = /** @class */ (function () {
         configurable: true
     });
     /**
-    * Defines an override for loading the runtime
-    * Return true to stop further extensions from loading the runtime
-    */
+     * Defines an override for loading the runtime
+     * Return true to stop further extensions from loading the runtime
+     * @param scene
+     * @param data
+     * @param rootUrl
+     * @param onSuccess
+     * @param onError
+     */
     GLTFLoaderExtension.prototype.loadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
         return false;
     };
     /**
      * Defines an onverride for creating gltf runtime
      * Return true to stop further extensions from creating the runtime
+     * @param gltfRuntime
+     * @param onSuccess
+     * @param onError
      */
     GLTFLoaderExtension.prototype.loadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
         return false;
     };
     /**
-    * Defines an override for loading buffers
-    * Return true to stop further extensions from loading this buffer
-    */
+     * Defines an override for loading buffers
+     * Return true to stop further extensions from loading this buffer
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     * @param onProgress
+     */
     GLTFLoaderExtension.prototype.loadBufferAsync = function (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
-    */
+     * Defines an override for loading texture buffers
+     * Return true to stop further extensions from loading this texture data
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
     GLTFLoaderExtension.prototype.loadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
         return false;
     };
     /**
-    * Defines an override for creating textures
-    * Return true to stop further extensions from loading this texture
-    */
+     * Defines an override for creating textures
+     * Return true to stop further extensions from loading this texture
+     * @param gltfRuntime
+     * @param id
+     * @param buffer
+     * @param onSuccess
+     * @param onError
+     */
     GLTFLoaderExtension.prototype.createTextureAsync = function (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
-    */
+     * Defines an override for loading shader strings
+     * Return true to stop further extensions from loading this shader data
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
     GLTFLoaderExtension.prototype.loadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
         return false;
     };
     /**
-    * Defines an override for loading materials
-    * Return true to stop further extensions from loading this material
-    */
+     * Defines an override for loading materials
+     * Return true to stop further extensions from loading this material
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
     GLTFLoaderExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
         return false;
     };
@@ -1619,7 +1738,7 @@ var GLTFLoaderExtension = /** @class */ (function () {
     // Utilities
     // ---------
     GLTFLoaderExtension.LoadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
-        GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
             return loaderExtension.loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError);
         }, function () {
             setTimeout(function () {
@@ -1631,7 +1750,7 @@ var GLTFLoaderExtension = /** @class */ (function () {
         });
     };
     GLTFLoaderExtension.LoadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
-        GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
             return loaderExtension.loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError);
         }, function () {
             setTimeout(function () {
@@ -1640,48 +1759,48 @@ var GLTFLoaderExtension = /** @class */ (function () {
         });
     };
     GLTFLoaderExtension.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
-        GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
+        GLTFLoaderExtension._ApplyExtensions(function (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) {
+        GLTFLoaderExtension._LoadTextureBufferAsync(gltfRuntime, id, function (buffer) {
             if (buffer) {
-                GLTFLoaderExtension.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
+                GLTFLoaderExtension._CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
             }
         }, onError);
     };
     GLTFLoaderExtension.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
-        GLTFLoaderExtension.ApplyExtensions(function (loaderExtension) {
+        GLTFLoaderExtension._ApplyExtensions(function (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) {
+        GLTFLoaderExtension._ApplyExtensions(function (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) {
+    GLTFLoaderExtension._LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (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) {
+    GLTFLoaderExtension._CreateTextureAsync = function (gltfRuntime, id, buffer, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
             return loaderExtension.createTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
         }, function () {
-            GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
+            GLTFLoaderBase.CreateTextureAsync(gltfRuntime, id, buffer, onSuccess);
         });
     };
-    GLTFLoaderExtension.ApplyExtensions = function (func, defaultFunc) {
+    GLTFLoaderExtension._ApplyExtensions = function (func, defaultFunc) {
         for (var extensionName in GLTFLoader.Extensions) {
             var loaderExtension = GLTFLoader.Extensions[extensionName];
             if (func(loaderExtension)) {