@babylonjs/loaders 8.5.0 → 8.6.0

package/glTF/1.0/glTFLoader.js

@@ -30,6 +30,7 @@ import { Constants } from "@babylonjs/core/Engines/constants.js";
  * Tokenizer. Used for shaders compatibility
  * Automatically map world, view, projection, worldViewProjection, attributes and so on
  */
+// eslint-disable-next-line @typescript-eslint/naming-convention
 var ETokenType;
 (function (ETokenType) {
     ETokenType[ETokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
@@ -78,30 +79,32 @@ class Tokenizer {
 /**
  * Values
  */
+// eslint-disable-next-line @typescript-eslint/naming-convention
 const glTFTransforms = ["MODEL", "VIEW", "PROJECTION", "MODELVIEW", "MODELVIEWPROJECTION", "JOINTMATRIX"];
-const babylonTransforms = ["world", "view", "projection", "worldView", "worldViewProjection", "mBones"];
+const BabylonTransforms = ["world", "view", "projection", "worldView", "worldViewProjection", "mBones"];
+// eslint-disable-next-line @typescript-eslint/naming-convention
 const glTFAnimationPaths = ["translation", "rotation", "scale"];
-const babylonAnimationPaths = ["position", "rotationQuaternion", "scaling"];
+const BabylonAnimationPaths = ["position", "rotationQuaternion", "scaling"];
 /**
  * Parse
  * @param parsedBuffers
  * @param gltfRuntime
  */
-const parseBuffers = (parsedBuffers, gltfRuntime) => {
+const ParseBuffers = (parsedBuffers, gltfRuntime) => {
     for (const buf in parsedBuffers) {
         const parsedBuffer = parsedBuffers[buf];
         gltfRuntime.buffers[buf] = parsedBuffer;
         gltfRuntime.buffersCount++;
     }
 };
-const parseShaders = (parsedShaders, gltfRuntime) => {
+const ParseShaders = (parsedShaders, gltfRuntime) => {
     for (const sha in parsedShaders) {
         const parsedShader = parsedShaders[sha];
         gltfRuntime.shaders[sha] = parsedShader;
         gltfRuntime.shaderscount++;
     }
 };
-const parseObject = (parsedObjects, runtimeProperty, gltfRuntime) => {
+const ParseObject = (parsedObjects, runtimeProperty, gltfRuntime) => {
     for (const object in parsedObjects) {
         const parsedObject = parsedObjects[object];
         gltfRuntime[runtimeProperty][object] = parsedObject;
@@ -111,7 +114,7 @@ const parseObject = (parsedObjects, runtimeProperty, gltfRuntime) => {
  * Utils
  * @param buffer
  */
-const normalizeUVs = (buffer) => {
+const NormalizeUVs = (buffer) => {
     if (!buffer) {
         return;
     }
@@ -119,7 +122,7 @@ const normalizeUVs = (buffer) => {
         buffer[i * 2 + 1] = 1.0 - buffer[i * 2 + 1];
     }
 };
-const getAttribute = (attributeParameter) => {
+const GetAttribute = (attributeParameter) => {
     if (attributeParameter.semantic === "NORMAL") {
         return "normal";
     }
@@ -145,7 +148,7 @@ const getAttribute = (attributeParameter) => {
  * Loads and creates animations
  * @param gltfRuntime
  */
-const loadAnimations = (gltfRuntime) => {
+const LoadAnimations = (gltfRuntime) => {
     for (const anim in gltfRuntime.animations) {
         const animation = gltfRuntime.animations[anim];
         if (!animation.channels || !animation.samplers) {
@@ -185,7 +188,7 @@ const loadAnimations = (gltfRuntime) => {
             let targetPath = channel.target.path;
             const targetPathIndex = glTFAnimationPaths.indexOf(targetPath);
             if (targetPathIndex !== -1) {
-                targetPath = babylonAnimationPaths[targetPathIndex];
+                targetPath = BabylonAnimationPaths[targetPathIndex];
             }
             // Determine animation type
             let animationType = Animation.ANIMATIONTYPE_MATRIX;
@@ -272,7 +275,7 @@ const loadAnimations = (gltfRuntime) => {
  * @returns the bones transformation matrix
  * @param node
  */
-const configureBoneTransformation = (node) => {
+const ConfigureBoneTransformation = (node) => {
     let mat = null;
     if (node.translation || node.rotation || node.scale) {
         const scale = Vector3.FromArray(node.scale || [1, 1, 1]);
@@ -293,7 +296,7 @@ const configureBoneTransformation = (node) => {
  * @param newSkeleton
  * @returns the parent bone
  */
-const getParentBone = (gltfRuntime, skins, jointName, newSkeleton) => {
+const GetParentBone = (gltfRuntime, skins, jointName, newSkeleton) => {
     // Try to find
     for (let i = 0; i < newSkeleton.bones.length; i++) {
         if (newSkeleton.bones[i].name === jointName) {
@@ -314,8 +317,8 @@ const getParentBone = (gltfRuntime, skins, jointName, newSkeleton) => {
                 continue;
             }
             if (child.jointName === jointName) {
-                const mat = configureBoneTransformation(node);
-                const 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;
             }
@@ -329,7 +332,7 @@ const getParentBone = (gltfRuntime, skins, jointName, newSkeleton) => {
  * @param id
  * @returns the root node
  */
-const getNodeToRoot = (nodesToRoot, id) => {
+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++) {
@@ -347,7 +350,7 @@ const getNodeToRoot = (nodesToRoot, id) => {
  * @param jointName
  * @returns the node with the joint name
  */
-const getJointNode = (gltfRuntime, jointName) => {
+const GetJointNode = (gltfRuntime, jointName) => {
     const nodes = gltfRuntime.nodes;
     let node = nodes[jointName];
     if (node) {
@@ -373,7 +376,7 @@ const getJointNode = (gltfRuntime, jointName) => {
  * @param id
  * @returns true if the node is in joints, else false
  */
-const nodeIsInJoints = (skins, id) => {
+const NodeIsInJoints = (skins, id) => {
     for (let i = 0; i < skins.jointNames.length; i++) {
         if (skins.jointNames[i] === id) {
             return true;
@@ -388,16 +391,16 @@ const nodeIsInJoints = (skins, id) => {
  * @param skins
  * @param nodesToRoot
  */
-const getNodesToRoot = (gltfRuntime, newSkeleton, skins, nodesToRoot) => {
+const GetNodesToRoot = (gltfRuntime, newSkeleton, skins, nodesToRoot) => {
     // Creates nodes for root
     for (const nde in gltfRuntime.nodes) {
         const node = gltfRuntime.nodes[nde];
         const id = nde;
-        if (!node.jointName || nodeIsInJoints(skins, node.jointName)) {
+        if (!node.jointName || NodeIsInJoints(skins, node.jointName)) {
             continue;
         }
         // Create node to root bone
-        const mat = configureBoneTransformation(node);
+        const mat = ConfigureBoneTransformation(node);
         const bone = new Bone(node.name || "", newSkeleton, null, mat);
         bone.id = id;
         nodesToRoot.push({ bone: bone, node: node, id: id });
@@ -429,7 +432,7 @@ const getNodesToRoot = (gltfRuntime, newSkeleton, skins, nodesToRoot) => {
  * @param newSkeleton
  * @returns the bone name
  */
-const importSkeleton = (gltfRuntime, skins, mesh, newSkeleton) => {
+const ImportSkeleton = (gltfRuntime, skins, mesh, newSkeleton) => {
     if (!newSkeleton) {
         newSkeleton = new Skeleton(skins.name || "", "", gltfRuntime.scene);
     }
@@ -439,11 +442,11 @@ const importSkeleton = (gltfRuntime, skins, mesh, newSkeleton) => {
     // Find the root bones
     const nodesToRoot = [];
     const nodesToRootToAdd = [];
-    getNodesToRoot(gltfRuntime, newSkeleton, skins, nodesToRoot);
+    GetNodesToRoot(gltfRuntime, newSkeleton, skins, nodesToRoot);
     newSkeleton.bones = [];
     // Joints
     for (let i = 0; i < skins.jointNames.length; i++) {
-        const jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
+        const jointNode = GetJointNode(gltfRuntime, skins.jointNames[i]);
         if (!jointNode) {
             continue;
         }
@@ -463,7 +466,7 @@ const importSkeleton = (gltfRuntime, skins, mesh, newSkeleton) => {
         let foundBone = false;
         let parentBone = null;
         for (let j = 0; j < i; j++) {
-            const jointNode = getJointNode(gltfRuntime, skins.jointNames[j]);
+            const jointNode = GetJointNode(gltfRuntime, skins.jointNames[j]);
             if (!jointNode) {
                 continue;
             }
@@ -479,7 +482,7 @@ const importSkeleton = (gltfRuntime, skins, mesh, newSkeleton) => {
             foundBone = false;
             for (let k = 0; k < children.length; k++) {
                 if (children[k] === id) {
-                    parentBone = getParentBone(gltfRuntime, skins, skins.jointNames[j], newSkeleton);
+                    parentBone = GetParentBone(gltfRuntime, skins, skins.jointNames[j], newSkeleton);
                     foundBone = true;
                     break;
                 }
@@ -489,9 +492,9 @@ const importSkeleton = (gltfRuntime, skins, mesh, newSkeleton) => {
             }
         }
         // Create bone
-        const mat = configureBoneTransformation(node);
+        const mat = ConfigureBoneTransformation(node);
         if (!parentBone && nodesToRoot.length > 0) {
-            parentBone = getNodeToRoot(nodesToRoot, id);
+            parentBone = GetNodeToRoot(nodesToRoot, id);
             if (parentBone) {
                 if (nodesToRootToAdd.indexOf(parentBone) === -1) {
                     nodesToRootToAdd.push(parentBone);
@@ -505,7 +508,7 @@ const importSkeleton = (gltfRuntime, skins, mesh, newSkeleton) => {
     const bones = newSkeleton.bones;
     newSkeleton.bones = [];
     for (let i = 0; i < skins.jointNames.length; i++) {
-        const jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
+        const jointNode = GetJointNode(gltfRuntime, skins.jointNames[i]);
         if (!jointNode) {
             continue;
         }
@@ -532,7 +535,7 @@ const importSkeleton = (gltfRuntime, skins, mesh, newSkeleton) => {
  * @param newMesh
  * @returns the new mesh
  */
-const importMesh = (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);
@@ -595,7 +598,7 @@ const importMesh = (gltfRuntime, node, meshes, id, newMesh) => {
                     const uvKind = VertexBuffer.UVKind + (channel === 0 ? "" : channel + 1);
                     const uvs = new Float32Array(buffer.length);
                     uvs.set(buffer);
-                    normalizeUVs(uvs);
+                    NormalizeUVs(uvs);
                     tempVertexData.set(uvs, uvKind);
                 }
                 else if (semantic === "JOINT") {
@@ -689,7 +692,7 @@ const importMesh = (gltfRuntime, node, meshes, id, newMesh) => {
  * @param rotation
  * @param scaling
  */
-const configureNode = (newNode, position, rotation, scaling) => {
+const ConfigureNode = (newNode, position, rotation, scaling) => {
     if (newNode.position) {
         newNode.position = position;
     }
@@ -705,17 +708,17 @@ const configureNode = (newNode, position, rotation, scaling) => {
  * @param newNode
  * @param node
  */
-const configureNodeFromMatrix = (newNode, node) => {
+const ConfigureNodeFromMatrix = (newNode, node) => {
     if (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);
+        ConfigureNode(newNode, position, rotation, scaling);
     }
     else if (node.translation && node.rotation && node.scale) {
-        configureNode(newNode, Vector3.FromArray(node.translation), Quaternion.FromArray(node.rotation), Vector3.FromArray(node.scale));
+        ConfigureNode(newNode, Vector3.FromArray(node.translation), Quaternion.FromArray(node.rotation), Vector3.FromArray(node.scale));
     }
     newNode.computeWorldMatrix(true);
 };
@@ -726,7 +729,7 @@ const configureNodeFromMatrix = (newNode, node) => {
  * @param id
  * @returns the newly imported node
  */
-const importNode = (gltfRuntime, node, id) => {
+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) {
@@ -737,10 +740,10 @@ const importNode = (gltfRuntime, node, id) => {
     if (node.skin) {
         if (node.meshes) {
             const skin = gltfRuntime.skins[node.skin];
-            const newMesh = importMesh(gltfRuntime, node, node.meshes, id, node.babylonNode);
+            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);
+                newMesh.skeleton = ImportSkeleton(gltfRuntime, skin, newMesh, skin.babylonSkeleton);
                 if (!skin.babylonSkeleton) {
                     skin.babylonSkeleton = newMesh.skeleton;
                 }
@@ -752,7 +755,7 @@ const importNode = (gltfRuntime, node, id) => {
         /**
          * Improve meshes property
          */
-        const 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
@@ -850,13 +853,13 @@ const importNode = (gltfRuntime, node, id) => {
     }
     if (lastNode !== null) {
         if (node.matrix && lastNode instanceof Mesh) {
-            configureNodeFromMatrix(lastNode, node);
+            ConfigureNodeFromMatrix(lastNode, node);
         }
         else {
             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));
+            ConfigureNode(lastNode, Vector3.FromArray(translation), Quaternion.FromArray(rotation), Vector3.FromArray(scale));
         }
         lastNode.updateCache(true);
         node.babylonNode = lastNode;
@@ -870,7 +873,7 @@ const importNode = (gltfRuntime, node, id) => {
  * @param parent
  * @param meshIncluded
  */
-const traverseNodes = (gltfRuntime, id, parent, meshIncluded = false) => {
+const TraverseNodes = (gltfRuntime, id, parent, meshIncluded = false) => {
     const node = gltfRuntime.nodes[id];
     let newNode = null;
     if (gltfRuntime.importOnlyMeshes && !meshIncluded && gltfRuntime.importMeshesNames) {
@@ -885,7 +888,7 @@ const traverseNodes = (gltfRuntime, id, parent, meshIncluded = false) => {
         meshIncluded = true;
     }
     if (!node.jointName && meshIncluded) {
-        newNode = importNode(gltfRuntime, node, id);
+        newNode = ImportNode(gltfRuntime, node, id);
         if (newNode !== null) {
             newNode.id = id;
             newNode.parent = parent;
@@ -893,7 +896,7 @@ const traverseNodes = (gltfRuntime, id, parent, meshIncluded = false) => {
     }
     if (node.children) {
         for (let i = 0; i < node.children.length; i++) {
-            traverseNodes(gltfRuntime, node.children[i], newNode, meshIncluded);
+            TraverseNodes(gltfRuntime, node.children[i], newNode, meshIncluded);
         }
     }
 };
@@ -901,24 +904,24 @@ const traverseNodes = (gltfRuntime, id, parent, meshIncluded = false) => {
  * do stuff after buffers, shaders are loaded (e.g. hook up materials, load animations, etc.)
  * @param gltfRuntime
  */
-const postLoad = (gltfRuntime) => {
+const PostLoad = (gltfRuntime) => {
     // Nodes
     let currentScene = gltfRuntime.currentScene;
     if (currentScene) {
         for (let i = 0; i < currentScene.nodes.length; i++) {
-            traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+            TraverseNodes(gltfRuntime, currentScene.nodes[i], null);
         }
     }
     else {
         for (const thing in gltfRuntime.scenes) {
             currentScene = gltfRuntime.scenes[thing];
             for (let i = 0; i < currentScene.nodes.length; i++) {
-                traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+                TraverseNodes(gltfRuntime, currentScene.nodes[i], null);
             }
         }
     }
     // Set animations
-    loadAnimations(gltfRuntime);
+    LoadAnimations(gltfRuntime);
     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);
@@ -934,7 +937,7 @@ const postLoad = (gltfRuntime) => {
  * @param material
  * @param onSuccess
  */
-const onBindShaderMaterial = (mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess) => {
+const OnBindShaderMaterial = (mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess) => {
     const materialValues = material.values || technique.parameters;
     for (const unif in unTreatedUniforms) {
         const uniform = unTreatedUniforms[unif];
@@ -981,7 +984,7 @@ const onBindShaderMaterial = (mesh, gltfRuntime, unTreatedUniforms, shaderMateri
  * @param technique
  * @param material
  */
-const prepareShaderMaterialUniforms = (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) => {
+const PrepareShaderMaterialUniforms = (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) => {
     const materialValues = material.values || technique.parameters;
     const techniqueUniforms = technique.uniforms;
     /**
@@ -1027,7 +1030,7 @@ const prepareShaderMaterialUniforms = (gltfRuntime, shaderMaterial, technique, m
  * @param onError
  * @returns callback when shader is compiled
  */
-const onShaderCompileError = (program, shaderMaterial, onError) => {
+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");
@@ -1043,11 +1046,11 @@ const onShaderCompileError = (program, shaderMaterial, onError) => {
  * @param onSuccess
  * @returns callback when shader is compiled
  */
-const onShaderCompileSuccess = (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess) => {
+const OnShaderCompileSuccess = (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess) => {
     return (_) => {
-        prepareShaderMaterialUniforms(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms);
+        PrepareShaderMaterialUniforms(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms);
         shaderMaterial.onBind = (mesh) => {
-            onBindShaderMaterial(mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess);
+            OnBindShaderMaterial(mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess);
         };
     };
 };
@@ -1058,7 +1061,7 @@ const onShaderCompileSuccess = (gltfRuntime, shaderMaterial, technique, material
  * @param unTreatedUniforms
  * @returns the name of the uniform handled by babylon
  */
-const parseShaderUniforms = (tokenizer, technique, unTreatedUniforms) => {
+const ParseShaderUniforms = (tokenizer, technique, unTreatedUniforms) => {
     for (const unif in technique.uniforms) {
         const uniform = technique.uniforms[unif];
         const uniformParameter = technique.parameters[uniform];
@@ -1067,7 +1070,7 @@ const parseShaderUniforms = (tokenizer, technique, unTreatedUniforms) => {
                 const transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
                 if (transformIndex !== -1) {
                     delete unTreatedUniforms[unif];
-                    return babylonTransforms[transformIndex];
+                    return BabylonTransforms[transformIndex];
                 }
             }
         }
@@ -1078,7 +1081,7 @@ const parseShaderUniforms = (tokenizer, technique, unTreatedUniforms) => {
  * All shaders loaded. Create materials one by one
  * @param gltfRuntime
  */
-const importMaterials = (gltfRuntime) => {
+const ImportMaterials = (gltfRuntime) => {
     // Create materials
     for (const mat in gltfRuntime.materials) {
         GLTFLoaderExtension.LoadMaterialAsync(gltfRuntime, mat, () => { }, () => { });
@@ -1123,58 +1126,58 @@ export class GLTFLoaderBase {
         };
         // Parse
         if (parsedData.extensions) {
-            parseObject(parsedData.extensions, "extensions", gltfRuntime);
+            ParseObject(parsedData.extensions, "extensions", gltfRuntime);
         }
         if (parsedData.extensionsUsed) {
-            parseObject(parsedData.extensionsUsed, "extensionsUsed", gltfRuntime);
+            ParseObject(parsedData.extensionsUsed, "extensionsUsed", gltfRuntime);
         }
         if (parsedData.buffers) {
-            parseBuffers(parsedData.buffers, gltfRuntime);
+            ParseBuffers(parsedData.buffers, gltfRuntime);
         }
         if (parsedData.bufferViews) {
-            parseObject(parsedData.bufferViews, "bufferViews", gltfRuntime);
+            ParseObject(parsedData.bufferViews, "bufferViews", gltfRuntime);
         }
         if (parsedData.accessors) {
-            parseObject(parsedData.accessors, "accessors", gltfRuntime);
+            ParseObject(parsedData.accessors, "accessors", gltfRuntime);
         }
         if (parsedData.meshes) {
-            parseObject(parsedData.meshes, "meshes", gltfRuntime);
+            ParseObject(parsedData.meshes, "meshes", gltfRuntime);
         }
         if (parsedData.lights) {
-            parseObject(parsedData.lights, "lights", gltfRuntime);
+            ParseObject(parsedData.lights, "lights", gltfRuntime);
         }
         if (parsedData.cameras) {
-            parseObject(parsedData.cameras, "cameras", gltfRuntime);
+            ParseObject(parsedData.cameras, "cameras", gltfRuntime);
         }
         if (parsedData.nodes) {
-            parseObject(parsedData.nodes, "nodes", gltfRuntime);
+            ParseObject(parsedData.nodes, "nodes", gltfRuntime);
         }
         if (parsedData.images) {
-            parseObject(parsedData.images, "images", gltfRuntime);
+            ParseObject(parsedData.images, "images", gltfRuntime);
         }
         if (parsedData.textures) {
-            parseObject(parsedData.textures, "textures", gltfRuntime);
+            ParseObject(parsedData.textures, "textures", gltfRuntime);
         }
         if (parsedData.shaders) {
-            parseShaders(parsedData.shaders, gltfRuntime);
+            ParseShaders(parsedData.shaders, gltfRuntime);
         }
         if (parsedData.programs) {
-            parseObject(parsedData.programs, "programs", gltfRuntime);
+            ParseObject(parsedData.programs, "programs", gltfRuntime);
         }
         if (parsedData.samplers) {
-            parseObject(parsedData.samplers, "samplers", gltfRuntime);
+            ParseObject(parsedData.samplers, "samplers", gltfRuntime);
         }
         if (parsedData.techniques) {
-            parseObject(parsedData.techniques, "techniques", gltfRuntime);
+            ParseObject(parsedData.techniques, "techniques", gltfRuntime);
         }
         if (parsedData.materials) {
-            parseObject(parsedData.materials, "materials", gltfRuntime);
+            ParseObject(parsedData.materials, "materials", gltfRuntime);
         }
         if (parsedData.animations) {
-            parseObject(parsedData.animations, "animations", gltfRuntime);
+            ParseObject(parsedData.animations, "animations", gltfRuntime);
         }
         if (parsedData.skins) {
-            parseObject(parsedData.skins, "skins", gltfRuntime);
+            ParseObject(parsedData.skins, "skins", gltfRuntime);
         }
         if (parsedData.scenes) {
             gltfRuntime.scenes = parsedData.scenes;
@@ -1184,6 +1187,7 @@ export class GLTFLoaderBase {
         }
         return gltfRuntime;
     }
+    // eslint-disable-next-line no-restricted-syntax
     static LoadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress) {
         const buffer = gltfRuntime.buffers[id];
         if (Tools.IsBase64(buffer.uri)) {
@@ -1197,6 +1201,7 @@ export class GLTFLoaderBase {
             });
         }
     }
+    // eslint-disable-next-line no-restricted-syntax
     static LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError) {
         const texture = gltfRuntime.textures[id];
         if (!texture || !texture.source) {
@@ -1219,6 +1224,7 @@ export class GLTFLoaderBase {
             });
         }
     }
+    // eslint-disable-next-line no-restricted-syntax
     static CreateTextureAsync(gltfRuntime, id, buffer, onSuccess) {
         const texture = gltfRuntime.textures[id];
         if (texture.babylonTexture) {
@@ -1245,6 +1251,7 @@ export class GLTFLoaderBase {
         texture.babylonTexture = newTexture;
         onSuccess(newTexture);
     }
+    // eslint-disable-next-line no-restricted-syntax
     static LoadShaderStringAsync(gltfRuntime, id, onSuccess, onError) {
         const shader = gltfRuntime.shaders[id];
         if (Tools.IsBase64(shader.uri)) {
@@ -1261,6 +1268,7 @@ export class GLTFLoaderBase {
             });
         }
     }
+    // eslint-disable-next-line no-restricted-syntax
     static LoadMaterialAsync(gltfRuntime, id, onSuccess, onError) {
         const material = gltfRuntime.materials[id];
         if (!material.technique) {
@@ -1300,7 +1308,7 @@ export class GLTFLoaderBase {
             if (uniformParameter.semantic && !uniformParameter.node && !uniformParameter.source) {
                 const transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
                 if (transformIndex !== -1) {
-                    uniforms.push(babylonTransforms[transformIndex]);
+                    uniforms.push(BabylonTransforms[transformIndex]);
                     delete unTreatedUniforms[unif];
                 }
                 else {
@@ -1318,7 +1326,7 @@ export class GLTFLoaderBase {
             const attribute = technique.attributes[attr];
             const attributeParameter = technique.parameters[attribute];
             if (attributeParameter.semantic) {
-                const name = getAttribute(attributeParameter);
+                const name = GetAttribute(attributeParameter);
                 if (name) {
                     attributes.push(name);
                 }
@@ -1336,7 +1344,7 @@ export class GLTFLoaderBase {
                 const attribute = technique.attributes[attr];
                 const attributeParameter = technique.parameters[attribute];
                 if (vertexTokenizer.currentIdentifier === attr && attributeParameter.semantic) {
-                    newVertexShader += getAttribute(attributeParameter);
+                    newVertexShader += GetAttribute(attributeParameter);
                     foundAttribute = true;
                     break;
                 }
@@ -1344,7 +1352,7 @@ export class GLTFLoaderBase {
             if (foundAttribute) {
                 continue;
             }
-            newVertexShader += parseShaderUniforms(vertexTokenizer, technique, unTreatedUniforms);
+            newVertexShader += ParseShaderUniforms(vertexTokenizer, technique, unTreatedUniforms);
         }
         // Configure pixel shader
         while (!pixelTokenizer.isEnd() && pixelTokenizer.getNextToken()) {
@@ -1353,7 +1361,7 @@ export class GLTFLoaderBase {
                 newPixelShader += pixelTokenizer.currentString;
                 continue;
             }
-            newPixelShader += parseShaderUniforms(pixelTokenizer, technique, unTreatedUniforms);
+            newPixelShader += ParseShaderUniforms(pixelTokenizer, technique, unTreatedUniforms);
         }
         // Create shader material
         const shaderPath = {
@@ -1369,8 +1377,8 @@ export class GLTFLoaderBase {
         Effect.ShadersStore[program.vertexShader + id + "VertexShader"] = newVertexShader;
         Effect.ShadersStore[program.fragmentShader + id + "PixelShader"] = newPixelShader;
         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.onError = OnShaderCompileError(program, shaderMaterial, onError);
+        shaderMaterial.onCompiled = OnShaderCompileSuccess(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms, onSuccess);
         shaderMaterial.sideOrientation = Material.CounterClockWiseSideOrientation;
         if (states && states.functions) {
             const functions = states.functions;
@@ -1435,6 +1443,7 @@ export class GLTFLoader {
     dispose() {
         // do nothing
     }
+    // eslint-disable-next-line no-restricted-syntax
     _importMeshAsync(meshesNames, scene, data, rootUrl, assetContainer, onSuccess, onProgress, onError) {
         scene.useRightHandedSystem = true;
         GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, (gltfRuntime) => {
@@ -1473,8 +1482,8 @@ export class GLTFLoader {
             // Load buffers, shaders, materials, etc.
             this._loadBuffersAsync(gltfRuntime, () => {
                 this._loadShadersAsync(gltfRuntime, () => {
-                    importMaterials(gltfRuntime);
-                    postLoad(gltfRuntime);
+                    ImportMaterials(gltfRuntime);
+                    PostLoad(gltfRuntime);
                     if (!GLTFFileLoader.IncrementalLoading && onSuccess) {
                         onSuccess(meshes, skeletons);
                     }
@@ -1514,6 +1523,7 @@ export class GLTFLoader {
             });
         });
     }
+    // eslint-disable-next-line no-restricted-syntax
     _loadAsync(scene, data, rootUrl, onSuccess, onProgress, onError) {
         scene.useRightHandedSystem = true;
         GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, (gltfRuntime) => {
@@ -1524,8 +1534,8 @@ export class GLTFLoader {
                 // Load buffers, shaders, materials, etc.
                 this._loadBuffersAsync(gltfRuntime, () => {
                     this._loadShadersAsync(gltfRuntime, () => {
-                        importMaterials(gltfRuntime);
-                        postLoad(gltfRuntime);
+                        ImportMaterials(gltfRuntime);
+                        PostLoad(gltfRuntime);
                         if (!GLTFFileLoader.IncrementalLoading) {
                             onSuccess();
                         }
@@ -1554,6 +1564,7 @@ export class GLTFLoader {
             });
         });
     }
+    // eslint-disable-next-line no-restricted-syntax
     _loadShadersAsync(gltfRuntime, onload) {
         let hasShaders = false;
         const processShader = (sha, shader) => {
@@ -1586,6 +1597,7 @@ export class GLTFLoader {
             onload();
         }
     }
+    // eslint-disable-next-line no-restricted-syntax
     _loadBuffersAsync(gltfRuntime, onLoad) {
         let hasBuffers = false;
         const processBuffer = (buf, buffer) => {
@@ -1623,7 +1635,7 @@ export class GLTFLoader {
         if (currentScene) {
             // Only one scene even if multiple scenes are defined
             for (let i = 0; i < currentScene.nodes.length; i++) {
-                traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+                TraverseNodes(gltfRuntime, currentScene.nodes[i], null);
             }
         }
         else {
@@ -1631,7 +1643,7 @@ export class GLTFLoader {
             for (const thing in gltfRuntime.scenes) {
                 currentScene = gltfRuntime.scenes[thing];
                 for (let i = 0; i < currentScene.nodes.length; i++) {
-                    traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+                    TraverseNodes(gltfRuntime, currentScene.nodes[i], null);
                 }
             }
         }
@@ -1656,6 +1668,7 @@ export class GLTFLoaderExtension {
      * @param onError
      * @returns true to stop further extensions from loading the runtime
      */
+    // eslint-disable-next-line no-restricted-syntax
     loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError) {
         return false;
     }
@@ -1667,6 +1680,7 @@ export class GLTFLoaderExtension {
      * @param onError
      * @returns true to stop further extensions from creating the runtime
      */
+    // eslint-disable-next-line no-restricted-syntax
     loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError) {
         return false;
     }
@@ -1680,6 +1694,8 @@ export class GLTFLoaderExtension {
      * @param onProgress
      * @returns true to stop further extensions from loading this buffer
      */
+    // eslint-disable-next-line no-restricted-syntax
+    // eslint-disable-next-line no-restricted-syntax
     loadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress) {
         return false;
     }
@@ -1692,6 +1708,7 @@ export class GLTFLoaderExtension {
      * @param onError
      * @returns true to stop further extensions from loading this texture data
      */
+    // eslint-disable-next-line no-restricted-syntax
     loadTextureBufferAsync(gltfRuntime, id, onSuccess, onError) {
         return false;
     }
@@ -1705,6 +1722,7 @@ export class GLTFLoaderExtension {
      * @param onError
      * @returns true to stop further extensions from loading this texture
      */
+    // eslint-disable-next-line no-restricted-syntax
     createTextureAsync(gltfRuntime, id, buffer, onSuccess, onError) {
         return false;
     }
@@ -1717,6 +1735,7 @@ export class GLTFLoaderExtension {
      * @param onError
      * @returns true to stop further extensions from loading this shader data
      */
+    // eslint-disable-next-line no-restricted-syntax
     loadShaderStringAsync(gltfRuntime, id, onSuccess, onError) {
         return false;
     }
@@ -1729,12 +1748,14 @@ export class GLTFLoaderExtension {
      * @param onError
      * @returns true to stop further extensions from loading this material
      */
+    // eslint-disable-next-line no-restricted-syntax
     loadMaterialAsync(gltfRuntime, id, onSuccess, onError) {
         return false;
     }
     // ---------
     // Utilities
     // ---------
+    // eslint-disable-next-line no-restricted-syntax
     static LoadRuntimeAsync(scene, data, rootUrl, onSuccess, onError) {
         GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError);
@@ -1747,6 +1768,7 @@ export class GLTFLoaderExtension {
             });
         });
     }
+    // eslint-disable-next-line no-restricted-syntax
     static LoadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError) {
         GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError);
@@ -1756,6 +1778,7 @@ export class GLTFLoaderExtension {
             });
         });
     }
+    // eslint-disable-next-line no-restricted-syntax
     static LoadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress) {
         GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress);
@@ -1763,6 +1786,7 @@ export class GLTFLoaderExtension {
             GLTFLoaderBase.LoadBufferAsync(gltfRuntime, id, onSuccess, onError, onProgress);
         });
     }
+    // eslint-disable-next-line no-restricted-syntax
     static LoadTextureAsync(gltfRuntime, id, onSuccess, onError) {
         GLTFLoaderExtension._LoadTextureBufferAsync(gltfRuntime, id, (buffer) => {
             if (buffer) {
@@ -1770,6 +1794,7 @@ export class GLTFLoaderExtension {
             }
         }, onError);
     }
+    // eslint-disable-next-line no-restricted-syntax
     static LoadShaderStringAsync(gltfRuntime, id, onSuccess, onError) {
         GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadShaderStringAsync(gltfRuntime, id, onSuccess, onError);
@@ -1777,6 +1802,7 @@ export class GLTFLoaderExtension {
             GLTFLoaderBase.LoadShaderStringAsync(gltfRuntime, id, onSuccess, onError);
         });
     }
+    // eslint-disable-next-line no-restricted-syntax
     static LoadMaterialAsync(gltfRuntime, id, onSuccess, onError) {
         GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadMaterialAsync(gltfRuntime, id, onSuccess, onError);
@@ -1784,6 +1810,7 @@ export class GLTFLoaderExtension {
             GLTFLoaderBase.LoadMaterialAsync(gltfRuntime, id, onSuccess, onError);
         });
     }
+    // eslint-disable-next-line no-restricted-syntax
     static _LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError) {
         GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.loadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
@@ -1791,6 +1818,7 @@ export class GLTFLoaderExtension {
             GLTFLoaderBase.LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
         });
     }
+    // eslint-disable-next-line no-restricted-syntax
     static _CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError) {
         GLTFLoaderExtension._ApplyExtensions((loaderExtension) => {
             return loaderExtension.createTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);