@babylonjs/loaders 5.0.0-rc.6 → 5.0.0

package/glTF/1.0/glTFLoader.js

@@ -1,1816 +1,1815 @@
-/* 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 { Tools } from "@babylonjs/core/Misc/tools.js";
-import { Camera } from "@babylonjs/core/Cameras/camera.js";
-import { FreeCamera } from "@babylonjs/core/Cameras/freeCamera.js";
-import { Animation } from "@babylonjs/core/Animations/animation.js";
-import { Bone } from "@babylonjs/core/Bones/bone.js";
-import { Skeleton } from "@babylonjs/core/Bones/skeleton.js";
-import { Effect } from "@babylonjs/core/Materials/effect.js";
-import { Material } from "@babylonjs/core/Materials/material.js";
-import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.js";
-import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial.js";
-import { ShaderMaterial } from "@babylonjs/core/Materials/shaderMaterial.js";
-import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
-import { VertexData } from "@babylonjs/core/Meshes/mesh.vertexData.js";
-import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
-import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
-import { SubMesh } from "@babylonjs/core/Meshes/subMesh.js";
-import { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
-import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
-import { HemisphericLight } from "@babylonjs/core/Lights/hemisphericLight.js";
-import { DirectionalLight } from "@babylonjs/core/Lights/directionalLight.js";
-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";
-/**
- * Tokenizer. Used for shaders compatibility
- * Automatically map world, view, projection, worldViewProjection, attributes and so on
- */
-var ETokenType;
-(function (ETokenType) {
-    ETokenType[ETokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
-    ETokenType[ETokenType["UNKNOWN"] = 2] = "UNKNOWN";
-    ETokenType[ETokenType["END_OF_INPUT"] = 3] = "END_OF_INPUT";
-})(ETokenType || (ETokenType = {}));
-var Tokenizer = /** @class */ (function () {
-    function Tokenizer(toParse) {
-        this._pos = 0;
-        this.currentToken = ETokenType.UNKNOWN;
-        this.currentIdentifier = "";
-        this.currentString = "";
-        this.isLetterOrDigitPattern = /^[a-zA-Z0-9]+$/;
-        this._toParse = toParse;
-        this._maxPos = toParse.length;
-    }
-    Tokenizer.prototype.getNextToken = function () {
-        if (this.isEnd()) {
-            return ETokenType.END_OF_INPUT;
-        }
-        this.currentString = this.read();
-        this.currentToken = ETokenType.UNKNOWN;
-        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 === "_")) {
-                this.currentIdentifier += this.currentString;
-                this.forward();
-            }
-        }
-        return this.currentToken;
-    };
-    Tokenizer.prototype.peek = function () {
-        return this._toParse[this._pos];
-    };
-    Tokenizer.prototype.read = function () {
-        return this._toParse[this._pos++];
-    };
-    Tokenizer.prototype.forward = function () {
-        this._pos++;
-    };
-    Tokenizer.prototype.isEnd = function () {
-        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"];
-/**
- * Parse
- * @param parsedBuffers
- * @param gltfRuntime
- */
-var parseBuffers = function (parsedBuffers, gltfRuntime) {
-    for (var buf in parsedBuffers) {
-        var parsedBuffer = parsedBuffers[buf];
-        gltfRuntime.buffers[buf] = parsedBuffer;
-        gltfRuntime.buffersCount++;
-    }
-};
-var parseShaders = function (parsedShaders, gltfRuntime) {
-    for (var sha in parsedShaders) {
-        var parsedShader = parsedShaders[sha];
-        gltfRuntime.shaders[sha] = parsedShader;
-        gltfRuntime.shaderscount++;
-    }
-};
-var parseObject = function (parsedObjects, runtimeProperty, gltfRuntime) {
-    for (var object in parsedObjects) {
-        var parsedObject = parsedObjects[object];
-        gltfRuntime[runtimeProperty][object] = parsedObject;
-    }
-};
-/**
- * Utils
- * @param buffer
- */
-var normalizeUVs = function (buffer) {
-    if (!buffer) {
-        return;
-    }
-    for (var i = 0; i < buffer.length / 2; i++) {
-        buffer[i * 2 + 1] = 1.0 - buffer[i * 2 + 1];
-    }
-};
-var getAttribute = function (attributeParameter) {
-    if (attributeParameter.semantic === "NORMAL") {
-        return "normal";
-    }
-    else if (attributeParameter.semantic === "POSITION") {
-        return "position";
-    }
-    else if (attributeParameter.semantic === "JOINT") {
-        return "matricesIndices";
-    }
-    else if (attributeParameter.semantic === "WEIGHT") {
-        return "matricesWeights";
-    }
-    else if (attributeParameter.semantic === "COLOR") {
-        return "color";
-    }
-    else if (attributeParameter.semantic && attributeParameter.semantic.indexOf("TEXCOORD_") !== -1) {
-        var channel = Number(attributeParameter.semantic.split("_")[1]);
-        return "uv" + (channel === 0 ? "" : channel + 1);
-    }
-    return null;
-};
-/**
- * Loads and creates animations
- * @param gltfRuntime
- */
-var loadAnimations = function (gltfRuntime) {
-    for (var anim in gltfRuntime.animations) {
-        var animation = gltfRuntime.animations[anim];
-        if (!animation.channels || !animation.samplers) {
-            continue;
-        }
-        var lastAnimation = null;
-        for (var i = 0; i < animation.channels.length; i++) {
-            // Get parameters and load buffers
-            var channel = animation.channels[i];
-            var sampler = animation.samplers[channel.sampler];
-            if (!sampler) {
-                continue;
-            }
-            var inputData = null;
-            var outputData = null;
-            if (animation.parameters) {
-                inputData = animation.parameters[sampler.input];
-                outputData = animation.parameters[sampler.output];
-            }
-            else {
-                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);
-            if (targetNode === null) {
-                targetNode = gltfRuntime.scene.getNodeByName(targetId);
-            }
-            if (targetNode === null) {
-                Tools.Warn("Creating animation named " + anim + ". But cannot find node named " + targetId + " to attach to");
-                continue;
-            }
-            var isBone = targetNode instanceof Bone;
-            // Get target path (position, rotation or scaling)
-            var targetPath = channel.target.path;
-            var targetPathIndex = glTFAnimationPaths.indexOf(targetPath);
-            if (targetPathIndex !== -1) {
-                targetPath = babylonAnimationPaths[targetPathIndex];
-            }
-            // Determine animation type
-            var animationType = Animation.ANIMATIONTYPE_MATRIX;
-            if (!isBone) {
-                if (targetPath === "rotationQuaternion") {
-                    animationType = Animation.ANIMATIONTYPE_QUATERNION;
-                    targetNode.rotationQuaternion = new Quaternion();
-                }
-                else {
-                    animationType = Animation.ANIMATIONTYPE_VECTOR3;
-                }
-            }
-            // Create animation and key frames
-            var babylonAnimation = null;
-            var keys = [];
-            var arrayOffset = 0;
-            var modifyKey = false;
-            if (isBone && lastAnimation && lastAnimation.getKeys().length === bufferInput.length) {
-                babylonAnimation = lastAnimation;
-                modifyKey = true;
-            }
-            if (!modifyKey) {
-                gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
-                babylonAnimation = new Animation(anim, isBone ? "_matrix" : targetPath, 1, animationType, Animation.ANIMATIONLOOPMODE_CYCLE);
-                gltfRuntime.scene._blockEntityCollection = false;
-            }
-            // For each frame
-            for (var j = 0; j < bufferInput.length; j++) {
-                var value = null;
-                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
-                    value = Vector3.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]);
-                    arrayOffset += 3;
-                }
-                if (isBone) {
-                    var bone = targetNode;
-                    var translation = Vector3.Zero();
-                    var rotationQuaternion = new Quaternion();
-                    var scaling = Vector3.Zero();
-                    // Warning on decompose
-                    var mat = bone.getBaseMatrix();
-                    if (modifyKey && lastAnimation) {
-                        mat = lastAnimation.getKeys()[j].value;
-                    }
-                    mat.decompose(scaling, rotationQuaternion, translation);
-                    if (targetPath === "position") {
-                        translation = value;
-                    }
-                    else if (targetPath === "rotationQuaternion") {
-                        rotationQuaternion = value;
-                    }
-                    else {
-                        scaling = value;
-                    }
-                    value = Matrix.Compose(scaling, rotationQuaternion, translation);
-                }
-                if (!modifyKey) {
-                    keys.push({
-                        frame: bufferInput[j],
-                        value: value,
-                    });
-                }
-                else if (lastAnimation) {
-                    lastAnimation.getKeys()[j].value = value;
-                }
-            }
-            // Finish
-            if (!modifyKey && babylonAnimation) {
-                babylonAnimation.setKeys(keys);
-                targetNode.animations.push(babylonAnimation);
-            }
-            lastAnimation = babylonAnimation;
-            gltfRuntime.scene.stopAnimation(targetNode);
-            gltfRuntime.scene.beginAnimation(targetNode, 0, bufferInput[bufferInput.length - 1], true, 1.0);
-        }
-    }
-};
-/**
- * Returns the bones transformation matrix
- * @param node
- */
-var configureBoneTransformation = function (node) {
-    var 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]);
-        mat = Matrix.Compose(scale, rotation, position);
-    }
-    else {
-        mat = Matrix.FromArray(node.matrix);
-    }
-    return mat;
-};
-/**
- * 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++) {
-        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];
-        if (!node.jointName) {
-            continue;
-        }
-        var children = node.children;
-        for (var i = 0; i < children.length; i++) {
-            var 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);
-                bone.id = nde;
-                return bone;
-            }
-        }
-    }
-    return null;
-};
-/**
- * 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];
-        for (var j = 0; j < nodeToRoot.node.children.length; j++) {
-            var child = nodeToRoot.node.children[j];
-            if (child === id) {
-                return nodeToRoot.bone;
-            }
-        }
-    }
-    return null;
-};
-/**
- * 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,
-        };
-    }
-    for (var nde in nodes) {
-        node = nodes[nde];
-        if (node.jointName === jointName) {
-            return {
-                node: node,
-                id: nde,
-            };
-        }
-    }
-    return null;
-};
-/**
- * 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) {
-            return true;
-        }
-    }
-    return false;
-};
-/**
- * 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) {
-        var node = gltfRuntime.nodes[nde];
-        var 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);
-        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++) {
-                if (nodesToRoot[k].id === children[j]) {
-                    child = nodesToRoot[k];
-                    break;
-                }
-            }
-            if (child) {
-                child.bone._parent = nodeToRoot.bone;
-                nodeToRoot.bone.children.push(child.bone);
-            }
-        }
-    }
-};
-/**
- * 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);
-    }
-    if (!skins.babylonSkeleton) {
-        return newSkeleton;
-    }
-    // Find the root bones
-    var nodesToRoot = [];
-    var 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]);
-        if (!jointNode) {
-            continue;
-        }
-        var node = jointNode.node;
-        if (!node) {
-            Tools.Warn("Joint named " + skins.jointNames[i] + " does not exist");
-            continue;
-        }
-        var id = jointNode.id;
-        // Optimize, if the bone already exists...
-        var 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) {
-                continue;
-            }
-            var joint = jointNode_1.node;
-            if (!joint) {
-                Tools.Warn("Joint named " + skins.jointNames[j] + " does not exist when looking for parent");
-                continue;
-            }
-            var children = joint.children;
-            if (!children) {
-                continue;
-            }
-            foundBone = false;
-            for (var k = 0; k < children.length; k++) {
-                if (children[k] === id) {
-                    parentBone = getParentBone(gltfRuntime, skins, skins.jointNames[j], newSkeleton);
-                    foundBone = true;
-                    break;
-                }
-            }
-            if (foundBone) {
-                break;
-            }
-        }
-        // Create bone
-        var mat = configureBoneTransformation(node);
-        if (!parentBone && nodesToRoot.length > 0) {
-            parentBone = getNodeToRoot(nodesToRoot, id);
-            if (parentBone) {
-                if (nodesToRootToAdd.indexOf(parentBone) === -1) {
-                    nodesToRootToAdd.push(parentBone);
-                }
-            }
-        }
-        var bone = new Bone(node.jointName || "", newSkeleton, parentBone, mat);
-        bone.id = id;
-    }
-    // Polish
-    var bones = newSkeleton.bones;
-    newSkeleton.bones = [];
-    for (var i = 0; i < skins.jointNames.length; i++) {
-        var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
-        if (!jointNode) {
-            continue;
-        }
-        for (var j = 0; j < bones.length; j++) {
-            if (bones[j].id === jointNode.id) {
-                newSkeleton.bones.push(bones[j]);
-                break;
-            }
-        }
-    }
-    newSkeleton.prepare();
-    // Finish
-    for (var i = 0; i < nodesToRootToAdd.length; i++) {
-        newSkeleton.bones.push(nodesToRootToAdd[i]);
-    }
-    return newSkeleton;
-};
-/**
- * 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;
-        newMesh = new Mesh(node.name || "", gltfRuntime.scene);
-        newMesh._parentContainer = gltfRuntime.assetContainer;
-        gltfRuntime.scene._blockEntityCollection = false;
-        newMesh.id = id;
-    }
-    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];
-        if (!mesh) {
-            continue;
-        }
-        // Positions, normals and UVs
-        for (var i = 0; i < mesh.primitives.length; i++) {
-            // Temporary vertex data
-            var tempVertexData = new VertexData();
-            var primitive = mesh.primitives[i];
-            if (primitive.mode !== 4) {
-                // continue;
-            }
-            var attributes = primitive.attributes;
-            var accessor = null;
-            var buffer = null;
-            // Set positions, normal and uvs
-            for (var semantic in attributes) {
-                // Link accessor and buffer view
-                accessor = gltfRuntime.accessors[attributes[semantic]];
-                buffer = GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
-                if (semantic === "NORMAL") {
-                    tempVertexData.normals = new Float32Array(buffer.length);
-                    tempVertexData.normals.set(buffer);
-                }
-                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) {
-                            tempVertexData.positions[j] = buffer[j];
-                            tempVertexData.positions[j + 1] = buffer[j + 1];
-                            tempVertexData.positions[j + 2] = buffer[j + 2];
-                        }
-                    }
-                    else {
-                        tempVertexData.positions = new Float32Array(buffer.length);
-                        tempVertexData.positions.set(buffer);
-                    }
-                    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);
-                    uvs.set(buffer);
-                    normalizeUVs(uvs);
-                    tempVertexData.set(uvs, uvKind);
-                }
-                else if (semantic === "JOINT") {
-                    tempVertexData.matricesIndices = new Float32Array(buffer.length);
-                    tempVertexData.matricesIndices.set(buffer);
-                }
-                else if (semantic === "WEIGHT") {
-                    tempVertexData.matricesWeights = new Float32Array(buffer.length);
-                    tempVertexData.matricesWeights.set(buffer);
-                }
-                else if (semantic === "COLOR") {
-                    tempVertexData.colors = new Float32Array(buffer.length);
-                    tempVertexData.colors.set(buffer);
-                }
-            }
-            // Indices
-            accessor = gltfRuntime.accessors[primitive.indices];
-            if (accessor) {
-                buffer = GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
-                tempVertexData.indices = new Int32Array(buffer.length);
-                tempVertexData.indices.set(buffer);
-                indexCounts.push(tempVertexData.indices.length);
-            }
-            else {
-                // Set indices on the fly
-                var indices = [];
-                for (var j = 0; j < tempVertexData.positions.length / 3; j++) {
-                    indices.push(j);
-                }
-                tempVertexData.indices = new Int32Array(indices);
-                indexCounts.push(tempVertexData.indices.length);
-            }
-            if (!vertexData) {
-                vertexData = tempVertexData;
-            }
-            else {
-                vertexData.merge(tempVertexData);
-            }
-            // Sub material
-            var material_1 = gltfRuntime.scene.getMaterialById(primitive.material);
-            subMaterials.push(material_1 === null ? GLTFUtils.GetDefaultMaterial(gltfRuntime.scene) : material_1);
-            // 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;
-    gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
-    if (subMaterials.length > 1) {
-        material = new MultiMaterial("multimat" + id, gltfRuntime.scene);
-        material.subMaterials = subMaterials;
-    }
-    else {
-        material = new StandardMaterial("multimat" + id, gltfRuntime.scene);
-    }
-    if (subMaterials.length === 1) {
-        material = subMaterials[0];
-    }
-    material._parentContainer = gltfRuntime.assetContainer;
-    if (!newMesh.material) {
-        newMesh.material = material;
-    }
-    // Apply geometry
-    new Geometry(id, gltfRuntime.scene, vertexData, false, newMesh);
-    newMesh.computeWorldMatrix(true);
-    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];
-        if (!mesh) {
-            continue;
-        }
-        for (var i = 0; i < mesh.primitives.length; i++) {
-            if (mesh.primitives[i].mode !== 4) {
-                //continue;
-            }
-            SubMesh.AddToMesh(index, verticesStarts[index], verticesCounts[index], indexStarts[index], indexCounts[index], newMesh, newMesh, true);
-            index++;
-        }
-    }
-    // Finish
-    return newMesh;
-};
-/**
- * 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;
-    }
-    if (newNode.rotationQuaternion || newNode.rotation) {
-        newNode.rotationQuaternion = rotation;
-    }
-    if (newNode.scaling) {
-        newNode.scaling = scaling;
-    }
-};
-/**
- * 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();
-        var scaling = new Vector3(0, 0, 0);
-        var mat = Matrix.FromArray(node.matrix);
-        mat.decompose(scaling, rotation, position);
-        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));
-    }
-    newNode.computeWorldMatrix(true);
-};
-/**
- * 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) {
-            return null;
-        }
-    }
-    // Meshes
-    if (node.skin) {
-        if (node.meshes) {
-            var skin = gltfRuntime.skins[node.skin];
-            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);
-                if (!skin.babylonSkeleton) {
-                    skin.babylonSkeleton = newMesh.skeleton;
-                }
-            }
-            lastNode = newMesh;
-        }
-    }
-    else if (node.meshes) {
-        /**
-         * Improve meshes property
-         */
-        var 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];
-        if (light) {
-            if (light.type === "ambient") {
-                var ambienLight = light[light.type];
-                var hemiLight = new HemisphericLight(node.light, Vector3.Zero(), gltfRuntime.scene);
-                hemiLight.name = node.name || "";
-                if (ambienLight.color) {
-                    hemiLight.diffuse = Color3.FromArray(ambienLight.color);
-                }
-                lastNode = hemiLight;
-            }
-            else if (light.type === "directional") {
-                var directionalLight = light[light.type];
-                var dirLight = new DirectionalLight(node.light, Vector3.Zero(), gltfRuntime.scene);
-                dirLight.name = node.name || "";
-                if (directionalLight.color) {
-                    dirLight.diffuse = Color3.FromArray(directionalLight.color);
-                }
-                lastNode = dirLight;
-            }
-            else if (light.type === "point") {
-                var pointLight = light[light.type];
-                var ptLight = new PointLight(node.light, Vector3.Zero(), gltfRuntime.scene);
-                ptLight.name = node.name || "";
-                if (pointLight.color) {
-                    ptLight.diffuse = Color3.FromArray(pointLight.color);
-                }
-                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);
-                spLight.name = node.name || "";
-                if (spotLight.color) {
-                    spLight.diffuse = Color3.FromArray(spotLight.color);
-                }
-                if (spotLight.fallOfAngle) {
-                    spLight.angle = spotLight.fallOfAngle;
-                }
-                if (spotLight.fallOffExponent) {
-                    spLight.exponent = spotLight.fallOffExponent;
-                }
-                lastNode = spLight;
-            }
-        }
-    }
-    // Cameras
-    else if (node.camera && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
-        var 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);
-                orthoCamera.name = node.name || "";
-                orthoCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;
-                orthoCamera.attachControl();
-                lastNode = orthoCamera;
-                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);
-                persCamera.name = node.name || "";
-                persCamera.attachControl();
-                if (!perspectiveCamera.aspectRatio) {
-                    perspectiveCamera.aspectRatio = gltfRuntime.scene.getEngine().getRenderWidth() / gltfRuntime.scene.getEngine().getRenderHeight();
-                }
-                if (perspectiveCamera.znear && perspectiveCamera.zfar) {
-                    persCamera.maxZ = perspectiveCamera.zfar;
-                    persCamera.minZ = perspectiveCamera.znear;
-                }
-                lastNode = persCamera;
-                persCamera._parentContainer = gltfRuntime.assetContainer;
-            }
-            gltfRuntime.scene._blockEntityCollection = false;
-        }
-    }
-    // Empty node
-    if (!node.jointName) {
-        if (node.babylonNode) {
-            return node.babylonNode;
-        }
-        else if (lastNode === null) {
-            gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
-            var dummy = new Mesh(node.name || "", gltfRuntime.scene);
-            dummy._parentContainer = gltfRuntime.assetContainer;
-            gltfRuntime.scene._blockEntityCollection = false;
-            node.babylonNode = dummy;
-            lastNode = dummy;
-        }
-    }
-    if (lastNode !== null) {
-        if (node.matrix && lastNode instanceof Mesh) {
-            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];
-            configureNode(lastNode, Vector3.FromArray(translation), Quaternion.FromArray(rotation), Vector3.FromArray(scale));
-        }
-        lastNode.updateCache(true);
-        node.babylonNode = lastNode;
-    }
-    return lastNode;
-};
-/**
- * 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];
-    var newNode = null;
-    if (gltfRuntime.importOnlyMeshes && !meshIncluded && gltfRuntime.importMeshesNames) {
-        if (gltfRuntime.importMeshesNames.indexOf(node.name || "") !== -1 || gltfRuntime.importMeshesNames.length === 0) {
-            meshIncluded = true;
-        }
-        else {
-            meshIncluded = false;
-        }
-    }
-    else {
-        meshIncluded = true;
-    }
-    if (!node.jointName && meshIncluded) {
-        newNode = importNode(gltfRuntime, node, id);
-        if (newNode !== null) {
-            newNode.id = id;
-            newNode.parent = parent;
-        }
-    }
-    if (node.children) {
-        for (var i = 0; i < node.children.length; i++) {
-            traverseNodes(gltfRuntime, node.children[i], newNode, meshIncluded);
-        }
-    }
-};
-/**
- * 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;
-    if (currentScene) {
-        for (var i = 0; i < currentScene.nodes.length; i++) {
-            traverseNodes(gltfRuntime, currentScene.nodes[i], null);
-        }
-    }
-    else {
-        for (var thing in gltfRuntime.scenes) {
-            currentScene = gltfRuntime.scenes[thing];
-            for (var 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];
-        gltfRuntime.scene.beginAnimation(skeleton, 0, Number.MAX_VALUE, true, 1.0);
-    }
-};
-/**
- * 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) {
-        var uniform = unTreatedUniforms[unif];
-        var 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 || "");
-                if (source === null) {
-                    source = gltfRuntime.scene.getNodeById(uniform.source || uniform.node || "");
-                }
-                if (source === null) {
-                    continue;
-                }
-                GLTFUtils.SetMatrix(gltfRuntime.scene, source, uniform, unif, shaderMaterial.getEffect());
-            }
-        }
-        else {
-            var value = materialValues[technique.uniforms[unif]];
-            if (!value) {
-                continue;
-            }
-            if (type === EParameterType.SAMPLER_2D) {
-                var texture = gltfRuntime.textures[material.values ? value : uniform.value].babylonTexture;
-                if (texture === null || texture === undefined) {
-                    continue;
-                }
-                shaderMaterial.getEffect().setTexture(unif, texture);
-            }
-            else {
-                GLTFUtils.SetUniform(shaderMaterial.getEffect(), unif, value, type);
-            }
-        }
-    }
-    onSuccess(shaderMaterial);
-};
-/**
- * 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;
-    var _loop_1 = function (unif) {
-        var uniform = unTreatedUniforms[unif];
-        var type = uniform.type;
-        var value = materialValues[techniqueUniforms[unif]];
-        if (value === undefined) {
-            // In case the value is the same for all materials
-            value = uniform.value;
-        }
-        if (!value) {
-            return "continue";
-        }
-        var onLoadTexture = function (uniformName) {
-            return function (texture) {
-                if (uniform.value && uniformName) {
-                    // Static uniform
-                    shaderMaterial.setTexture(uniformName, texture);
-                    delete unTreatedUniforms[uniformName];
-                }
-            };
-        };
-        // Texture (sampler2D)
-        if (type === EParameterType.SAMPLER_2D) {
-            GLTFLoaderExtension.LoadTextureAsync(gltfRuntime, material.values ? value : uniform.value, onLoadTexture(unif), function () { return onLoadTexture(null); });
-        }
-        // Others
-        else {
-            if (uniform.value && GLTFUtils.SetUniform(shaderMaterial, unif, material.values ? value : uniform.value, type)) {
-                // Static uniform
-                delete unTreatedUniforms[unif];
-            }
-        }
-    };
-    /**
-     * Prepare values here (not matrices)
-     */
-    for (var unif in unTreatedUniforms) {
-        _loop_1(unif);
-    }
-};
-/**
- * Shader compilation failed
- * @param program
- * @param shaderMaterial
- * @param onError
- */
-var onShaderCompileError = function (program, shaderMaterial, onError) {
-    return function (effect, error) {
-        shaderMaterial.dispose(true);
-        onError("Cannot compile program named " + program.name + ". Error: " + error + ". Default material will be applied");
-    };
-};
-/**
- * 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);
-        shaderMaterial.onBind = function (mesh) {
-            onBindShaderMaterial(mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess);
-        };
-    };
-};
-/**
- * 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];
-        var uniformParameter = technique.parameters[uniform];
-        if (tokenizer.currentIdentifier === unif) {
-            if (uniformParameter.semantic && !uniformParameter.source && !uniformParameter.node) {
-                var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
-                if (transformIndex !== -1) {
-                    delete unTreatedUniforms[unif];
-                    return babylonTransforms[transformIndex];
-                }
-            }
-        }
-    }
-    return tokenizer.currentIdentifier;
-};
-/**
- * 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 () { }, function () { });
-    }
-};
-/**
- * Implementation of the base glTF spec
- * @hidden
- */
-var GLTFLoaderBase = /** @class */ (function () {
-    function GLTFLoaderBase() {
-    }
-    GLTFLoaderBase.CreateRuntime = function (parsedData, scene, rootUrl) {
-        var gltfRuntime = {
-            extensions: {},
-            accessors: {},
-            buffers: {},
-            bufferViews: {},
-            meshes: {},
-            lights: {},
-            cameras: {},
-            nodes: {},
-            images: {},
-            textures: {},
-            shaders: {},
-            programs: {},
-            samplers: {},
-            techniques: {},
-            materials: {},
-            animations: {},
-            skins: {},
-            extensionsUsed: [],
-            scenes: {},
-            buffersCount: 0,
-            shaderscount: 0,
-            scene: scene,
-            rootUrl: rootUrl,
-            loadedBufferCount: 0,
-            loadedBufferViews: {},
-            loadedShaderCount: 0,
-            importOnlyMeshes: false,
-            dummyNodes: [],
-            assetContainer: null,
-        };
-        // Parse
-        if (parsedData.extensions) {
-            parseObject(parsedData.extensions, "extensions", gltfRuntime);
-        }
-        if (parsedData.extensionsUsed) {
-            parseObject(parsedData.extensionsUsed, "extensionsUsed", gltfRuntime);
-        }
-        if (parsedData.buffers) {
-            parseBuffers(parsedData.buffers, gltfRuntime);
-        }
-        if (parsedData.bufferViews) {
-            parseObject(parsedData.bufferViews, "bufferViews", gltfRuntime);
-        }
-        if (parsedData.accessors) {
-            parseObject(parsedData.accessors, "accessors", gltfRuntime);
-        }
-        if (parsedData.meshes) {
-            parseObject(parsedData.meshes, "meshes", gltfRuntime);
-        }
-        if (parsedData.lights) {
-            parseObject(parsedData.lights, "lights", gltfRuntime);
-        }
-        if (parsedData.cameras) {
-            parseObject(parsedData.cameras, "cameras", gltfRuntime);
-        }
-        if (parsedData.nodes) {
-            parseObject(parsedData.nodes, "nodes", gltfRuntime);
-        }
-        if (parsedData.images) {
-            parseObject(parsedData.images, "images", gltfRuntime);
-        }
-        if (parsedData.textures) {
-            parseObject(parsedData.textures, "textures", gltfRuntime);
-        }
-        if (parsedData.shaders) {
-            parseShaders(parsedData.shaders, gltfRuntime);
-        }
-        if (parsedData.programs) {
-            parseObject(parsedData.programs, "programs", gltfRuntime);
-        }
-        if (parsedData.samplers) {
-            parseObject(parsedData.samplers, "samplers", gltfRuntime);
-        }
-        if (parsedData.techniques) {
-            parseObject(parsedData.techniques, "techniques", gltfRuntime);
-        }
-        if (parsedData.materials) {
-            parseObject(parsedData.materials, "materials", gltfRuntime);
-        }
-        if (parsedData.animations) {
-            parseObject(parsedData.animations, "animations", gltfRuntime);
-        }
-        if (parsedData.skins) {
-            parseObject(parsedData.skins, "skins", gltfRuntime);
-        }
-        if (parsedData.scenes) {
-            gltfRuntime.scenes = parsedData.scenes;
-        }
-        if (parsedData.scene && parsedData.scenes) {
-            gltfRuntime.currentScene = parsedData.scenes[parsedData.scene];
-        }
-        return gltfRuntime;
-    };
-    GLTFLoaderBase.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
-        var buffer = gltfRuntime.buffers[id];
-        if (Tools.IsBase64(buffer.uri)) {
-            setTimeout(function () { return 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) {
-                if (request) {
-                    onError(request.status + " " + request.statusText);
-                }
-            });
-        }
-    };
-    GLTFLoaderBase.LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
-        var texture = gltfRuntime.textures[id];
-        if (!texture || !texture.source) {
-            onError("");
-            return;
-        }
-        if (texture.babylonTexture) {
-            onSuccess(null);
-            return;
-        }
-        var source = gltfRuntime.images[texture.source];
-        if (Tools.IsBase64(source.uri)) {
-            setTimeout(function () { return 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) {
-                if (request) {
-                    onError(request.status + " " + request.statusText);
-                }
-            });
-        }
-    };
-    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 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);
-        if (sampler.wrapS !== undefined) {
-            newTexture.wrapU = GLTFUtils.GetWrapMode(sampler.wrapS);
-        }
-        if (sampler.wrapT !== undefined) {
-            newTexture.wrapV = GLTFUtils.GetWrapMode(sampler.wrapT);
-        }
-        newTexture.name = id;
-        texture.babylonTexture = newTexture;
-        onSuccess(newTexture);
-    };
-    GLTFLoaderBase.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
-        var shader = gltfRuntime.shaders[id];
-        if (Tools.IsBase64(shader.uri)) {
-            var shaderString = atob(shader.uri.split(",")[1]);
-            if (onSuccess) {
-                onSuccess(shaderString);
-            }
-        }
-        else {
-            Tools.LoadFile(gltfRuntime.rootUrl + shader.uri, onSuccess, undefined, undefined, false, function (request) {
-                if (request && onError) {
-                    onError(request.status + " " + request.statusText);
-                }
-            });
-        }
-    };
-    GLTFLoaderBase.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
-        var material = gltfRuntime.materials[id];
-        if (!material.technique) {
-            if (onError) {
-                onError("No technique found.");
-            }
-            return;
-        }
-        var technique = gltfRuntime.techniques[material.technique];
-        if (!technique) {
-            gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
-            var defaultMaterial = new StandardMaterial(id, gltfRuntime.scene);
-            defaultMaterial._parentContainer = gltfRuntime.assetContainer;
-            gltfRuntime.scene._blockEntityCollection = false;
-            defaultMaterial.diffuseColor = new Color3(0.5, 0.5, 0.5);
-            defaultMaterial.sideOrientation = Material.CounterClockWiseSideOrientation;
-            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 = [];
-        // Fill uniform, sampler2D and attributes
-        for (var unif in technique.uniforms) {
-            var uniform = technique.uniforms[unif];
-            var uniformParameter = technique.parameters[uniform];
-            unTreatedUniforms[unif] = uniformParameter;
-            if (uniformParameter.semantic && !uniformParameter.node && !uniformParameter.source) {
-                var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
-                if (transformIndex !== -1) {
-                    uniforms.push(babylonTransforms[transformIndex]);
-                    delete unTreatedUniforms[unif];
-                }
-                else {
-                    uniforms.push(unif);
-                }
-            }
-            else if (uniformParameter.type === EParameterType.SAMPLER_2D) {
-                samplers.push(unif);
-            }
-            else {
-                uniforms.push(unif);
-            }
-        }
-        for (var attr in technique.attributes) {
-            var attribute = technique.attributes[attr];
-            var attributeParameter = technique.parameters[attribute];
-            if (attributeParameter.semantic) {
-                var name_1 = getAttribute(attributeParameter);
-                if (name_1) {
-                    attributes.push(name_1);
-                }
-            }
-        }
-        // Configure vertex shader
-        while (!vertexTokenizer.isEnd() && vertexTokenizer.getNextToken()) {
-            var 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];
-                if (vertexTokenizer.currentIdentifier === attr && attributeParameter.semantic) {
-                    newVertexShader += getAttribute(attributeParameter);
-                    foundAttribute = true;
-                    break;
-                }
-            }
-            if (foundAttribute) {
-                continue;
-            }
-            newVertexShader += parseShaderUniforms(vertexTokenizer, technique, unTreatedUniforms);
-        }
-        // Configure pixel shader
-        while (!pixelTokenizer.isEnd() && pixelTokenizer.getNextToken()) {
-            var tokenType = pixelTokenizer.currentToken;
-            if (tokenType !== ETokenType.IDENTIFIER) {
-                newPixelShader += pixelTokenizer.currentString;
-                continue;
-            }
-            newPixelShader += parseShaderUniforms(pixelTokenizer, technique, unTreatedUniforms);
-        }
-        // Create shader material
-        var shaderPath = {
-            vertex: program.vertexShader + id,
-            fragment: program.fragmentShader + id,
-        };
-        var options = {
-            attributes: attributes,
-            uniforms: uniforms,
-            samplers: samplers,
-            needAlphaBlending: states && states.enable && states.enable.indexOf(3042) !== -1,
-        };
-        Effect.ShadersStore[program.vertexShader + id + "VertexShader"] = newVertexShader;
-        Effect.ShadersStore[program.fragmentShader + id + "PixelShader"] = newPixelShader;
-        var 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;
-            if (functions.cullFace && functions.cullFace[0] !== ECullingType.BACK) {
-                shaderMaterial.backFaceCulling = false;
-            }
-            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) {
-                    shaderMaterial.alphaMode = Constants.ALPHA_COMBINE;
-                }
-                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) {
-                    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) {
-                    shaderMaterial.alphaMode = Constants.ALPHA_SUBTRACT;
-                }
-                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) {
-                    shaderMaterial.alphaMode = Constants.ALPHA_MAXIMIZED;
-                }
-            }
-        }
-    };
-    return GLTFLoaderBase;
-}());
-export { GLTFLoaderBase };
-/**
- * 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');
-            return;
-        }
-        GLTFLoader.Extensions[extension.name] = extension;
-    };
-    GLTFLoader.prototype.dispose = function () {
-        // do nothing
-    };
-    GLTFLoader.prototype._importMeshAsync = function (meshesNames, scene, data, rootUrl, assetContainer, onSuccess, onProgress, onError) {
-        var _this = this;
-        scene.useRightHandedSystem = true;
-        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
-            gltfRuntime.assetContainer = assetContainer;
-            gltfRuntime.importOnlyMeshes = true;
-            if (meshesNames === "") {
-                gltfRuntime.importMeshesNames = [];
-            }
-            else if (typeof meshesNames === "string") {
-                gltfRuntime.importMeshesNames = [meshesNames];
-            }
-            else if (meshesNames && !(meshesNames instanceof Array)) {
-                gltfRuntime.importMeshesNames = [meshesNames];
-            }
-            else {
-                gltfRuntime.importMeshesNames = [];
-                Tools.Warn("Argument meshesNames must be of type string or string[]");
-            }
-            // Create nodes
-            _this._createNodes(gltfRuntime);
-            var meshes = new Array();
-            var skeletons = new Array();
-            // Fill arrays of meshes and skeletons
-            for (var nde in gltfRuntime.nodes) {
-                var node = gltfRuntime.nodes[nde];
-                if (node.babylonNode instanceof AbstractMesh) {
-                    meshes.push(node.babylonNode);
-                }
-            }
-            for (var skl in gltfRuntime.skins) {
-                var 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 () {
-                    importMaterials(gltfRuntime);
-                    postLoad(gltfRuntime);
-                    if (!GLTFFileLoader.IncrementalLoading && onSuccess) {
-                        onSuccess(meshes, skeletons);
-                    }
-                });
-            });
-            if (GLTFFileLoader.IncrementalLoading && onSuccess) {
-                onSuccess(meshes, skeletons);
-            }
-        }, 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
-     * @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) {
-            _this._importMeshAsync(meshesNames, scene, data, rootUrl, assetContainer, function (meshes, skeletons) {
-                resolve({
-                    meshes: meshes,
-                    particleSystems: [],
-                    skeletons: skeletons,
-                    animationGroups: [],
-                    lights: [],
-                    transformNodes: [],
-                    geometries: [],
-                });
-            }, onProgress, function (message) {
-                reject(new Error(message));
-            });
-        });
-    };
-    GLTFLoader.prototype._loadAsync = function (scene, data, rootUrl, onSuccess, onProgress, onError) {
-        var _this = this;
-        scene.useRightHandedSystem = true;
-        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
-            // Load runtime extensios
-            GLTFLoaderExtension.LoadRuntimeExtensionsAsync(gltfRuntime, function () {
-                // Create nodes
-                _this._createNodes(gltfRuntime);
-                // Load buffers, shaders, materials, etc.
-                _this._loadBuffersAsync(gltfRuntime, function () {
-                    _this._loadShadersAsync(gltfRuntime, function () {
-                        importMaterials(gltfRuntime);
-                        postLoad(gltfRuntime);
-                        if (!GLTFFileLoader.IncrementalLoading) {
-                            onSuccess();
-                        }
-                    });
-                });
-                if (GLTFFileLoader.IncrementalLoading) {
-                    onSuccess();
-                }
-            }, 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
-     * @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) {
-            _this._loadAsync(scene, data, rootUrl, function () {
-                resolve();
-            }, onProgress, function (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) {
-                if (shaderString instanceof ArrayBuffer) {
-                    return;
-                }
-                gltfRuntime.loadedShaderCount++;
-                if (shaderString) {
-                    Effect.ShadersStore[sha + (shader.type === EShaderType.VERTEX ? "VertexShader" : "PixelShader")] = shaderString;
-                }
-                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) {
-            hasShaders = true;
-            var shader = gltfRuntime.shaders[sha];
-            if (shader) {
-                processShader.bind(this, sha, shader)();
-            }
-            else {
-                Tools.Error("No shader named: " + sha);
-            }
-        }
-        if (!hasShaders) {
-            onload();
-        }
-    };
-    GLTFLoader.prototype._loadBuffersAsync = function (gltfRuntime, onLoad) {
-        var hasBuffers = false;
-        var processBuffer = function (buf, buffer) {
-            GLTFLoaderExtension.LoadBufferAsync(gltfRuntime, buf, function (bufferView) {
-                gltfRuntime.loadedBufferCount++;
-                if (bufferView) {
-                    if (bufferView.byteLength != gltfRuntime.buffers[buf].byteLength) {
-                        Tools.Error("Buffer named " + buf + " is length " + bufferView.byteLength + ". Expected: " + buffer.byteLength); // Improve error message
-                    }
-                    gltfRuntime.loadedBufferViews[buf] = bufferView;
-                }
-                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) {
-            hasBuffers = true;
-            var buffer = gltfRuntime.buffers[buf];
-            if (buffer) {
-                processBuffer.bind(this, buf, buffer)();
-            }
-            else {
-                Tools.Error("No buffer named: " + buf);
-            }
-        }
-        if (!hasBuffers) {
-            onLoad();
-        }
-    };
-    GLTFLoader.prototype._createNodes = function (gltfRuntime) {
-        var currentScene = gltfRuntime.currentScene;
-        if (currentScene) {
-            // Only one scene even if multiple scenes are defined
-            for (var i = 0; i < currentScene.nodes.length; i++) {
-                traverseNodes(gltfRuntime, currentScene.nodes[i], null);
-            }
-        }
-        else {
-            // Load all scenes
-            for (var thing in gltfRuntime.scenes) {
-                currentScene = gltfRuntime.scenes[thing];
-                for (var i = 0; i < currentScene.nodes.length; i++) {
-                    traverseNodes(gltfRuntime, currentScene.nodes[i], null);
-                }
-            }
-        }
-    };
-    GLTFLoader.Extensions = {};
-    return GLTFLoader;
-}());
-export { GLTFLoader };
-/** @hidden */
-var GLTFLoaderExtension = /** @class */ (function () {
-    function GLTFLoaderExtension(name) {
-        this._name = name;
-    }
-    Object.defineProperty(GLTFLoaderExtension.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * 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
-     * @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
-     * @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
-     * @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
-     * @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
-     * @param gltfRuntime
-     * @param id
-     * @param onSuccess
-     * @param onError
-     */
-    GLTFLoaderExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
-        return false;
-    };
-    // ---------
-    // Utilities
-    // ---------
-    GLTFLoaderExtension.LoadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
-        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
-            return loaderExtension.loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError);
-        }, function () {
-            setTimeout(function () {
-                if (!onSuccess) {
-                    return;
-                }
-                onSuccess(GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl));
-            });
-        });
-    };
-    GLTFLoaderExtension.LoadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
-        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
-            return loaderExtension.loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError);
-        }, function () {
-            setTimeout(function () {
-                onSuccess();
-            });
-        });
-    };
-    GLTFLoaderExtension.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
-        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) {
-            if (buffer) {
-                GLTFLoaderExtension._CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
-            }
-        }, onError);
-    };
-    GLTFLoaderExtension.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
-        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) {
-            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) {
-            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) {
-            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];
-            if (func(loaderExtension)) {
-                return;
-            }
-        }
-        defaultFunc();
-    };
-    return GLTFLoaderExtension;
-}());
-export { GLTFLoaderExtension };
-GLTFFileLoader._CreateGLTF1Loader = function () { return new GLTFLoader(); };
+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 { Tools } from "@babylonjs/core/Misc/tools.js";
+import { Camera } from "@babylonjs/core/Cameras/camera.js";
+import { FreeCamera } from "@babylonjs/core/Cameras/freeCamera.js";
+import { Animation } from "@babylonjs/core/Animations/animation.js";
+import { Bone } from "@babylonjs/core/Bones/bone.js";
+import { Skeleton } from "@babylonjs/core/Bones/skeleton.js";
+import { Effect } from "@babylonjs/core/Materials/effect.js";
+import { Material } from "@babylonjs/core/Materials/material.js";
+import { MultiMaterial } from "@babylonjs/core/Materials/multiMaterial.js";
+import { StandardMaterial } from "@babylonjs/core/Materials/standardMaterial.js";
+import { ShaderMaterial } from "@babylonjs/core/Materials/shaderMaterial.js";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+import { VertexData } from "@babylonjs/core/Meshes/mesh.vertexData.js";
+import { VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
+import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
+import { SubMesh } from "@babylonjs/core/Meshes/subMesh.js";
+import { AbstractMesh } from "@babylonjs/core/Meshes/abstractMesh.js";
+import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import { HemisphericLight } from "@babylonjs/core/Lights/hemisphericLight.js";
+import { DirectionalLight } from "@babylonjs/core/Lights/directionalLight.js";
+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";
+/**
+ * Tokenizer. Used for shaders compatibility
+ * Automatically map world, view, projection, worldViewProjection, attributes and so on
+ */
+var ETokenType;
+(function (ETokenType) {
+    ETokenType[ETokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
+    ETokenType[ETokenType["UNKNOWN"] = 2] = "UNKNOWN";
+    ETokenType[ETokenType["END_OF_INPUT"] = 3] = "END_OF_INPUT";
+})(ETokenType || (ETokenType = {}));
+var Tokenizer = /** @class */ (function () {
+    function Tokenizer(toParse) {
+        this._pos = 0;
+        this.currentToken = ETokenType.UNKNOWN;
+        this.currentIdentifier = "";
+        this.currentString = "";
+        this.isLetterOrDigitPattern = /^[a-zA-Z0-9]+$/;
+        this._toParse = toParse;
+        this._maxPos = toParse.length;
+    }
+    Tokenizer.prototype.getNextToken = function () {
+        if (this.isEnd()) {
+            return ETokenType.END_OF_INPUT;
+        }
+        this.currentString = this.read();
+        this.currentToken = ETokenType.UNKNOWN;
+        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 === "_")) {
+                this.currentIdentifier += this.currentString;
+                this.forward();
+            }
+        }
+        return this.currentToken;
+    };
+    Tokenizer.prototype.peek = function () {
+        return this._toParse[this._pos];
+    };
+    Tokenizer.prototype.read = function () {
+        return this._toParse[this._pos++];
+    };
+    Tokenizer.prototype.forward = function () {
+        this._pos++;
+    };
+    Tokenizer.prototype.isEnd = function () {
+        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"];
+/**
+ * Parse
+ * @param parsedBuffers
+ * @param gltfRuntime
+ */
+var parseBuffers = function (parsedBuffers, gltfRuntime) {
+    for (var buf in parsedBuffers) {
+        var parsedBuffer = parsedBuffers[buf];
+        gltfRuntime.buffers[buf] = parsedBuffer;
+        gltfRuntime.buffersCount++;
+    }
+};
+var parseShaders = function (parsedShaders, gltfRuntime) {
+    for (var sha in parsedShaders) {
+        var parsedShader = parsedShaders[sha];
+        gltfRuntime.shaders[sha] = parsedShader;
+        gltfRuntime.shaderscount++;
+    }
+};
+var parseObject = function (parsedObjects, runtimeProperty, gltfRuntime) {
+    for (var object in parsedObjects) {
+        var parsedObject = parsedObjects[object];
+        gltfRuntime[runtimeProperty][object] = parsedObject;
+    }
+};
+/**
+ * Utils
+ * @param buffer
+ */
+var normalizeUVs = function (buffer) {
+    if (!buffer) {
+        return;
+    }
+    for (var i = 0; i < buffer.length / 2; i++) {
+        buffer[i * 2 + 1] = 1.0 - buffer[i * 2 + 1];
+    }
+};
+var getAttribute = function (attributeParameter) {
+    if (attributeParameter.semantic === "NORMAL") {
+        return "normal";
+    }
+    else if (attributeParameter.semantic === "POSITION") {
+        return "position";
+    }
+    else if (attributeParameter.semantic === "JOINT") {
+        return "matricesIndices";
+    }
+    else if (attributeParameter.semantic === "WEIGHT") {
+        return "matricesWeights";
+    }
+    else if (attributeParameter.semantic === "COLOR") {
+        return "color";
+    }
+    else if (attributeParameter.semantic && attributeParameter.semantic.indexOf("TEXCOORD_") !== -1) {
+        var channel = Number(attributeParameter.semantic.split("_")[1]);
+        return "uv" + (channel === 0 ? "" : channel + 1);
+    }
+    return null;
+};
+/**
+ * Loads and creates animations
+ * @param gltfRuntime
+ */
+var loadAnimations = function (gltfRuntime) {
+    for (var anim in gltfRuntime.animations) {
+        var animation = gltfRuntime.animations[anim];
+        if (!animation.channels || !animation.samplers) {
+            continue;
+        }
+        var lastAnimation = null;
+        for (var i = 0; i < animation.channels.length; i++) {
+            // Get parameters and load buffers
+            var channel = animation.channels[i];
+            var sampler = animation.samplers[channel.sampler];
+            if (!sampler) {
+                continue;
+            }
+            var inputData = null;
+            var outputData = null;
+            if (animation.parameters) {
+                inputData = animation.parameters[sampler.input];
+                outputData = animation.parameters[sampler.output];
+            }
+            else {
+                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);
+            if (targetNode === null) {
+                targetNode = gltfRuntime.scene.getNodeByName(targetId);
+            }
+            if (targetNode === null) {
+                Tools.Warn("Creating animation named " + anim + ". But cannot find node named " + targetId + " to attach to");
+                continue;
+            }
+            var isBone = targetNode instanceof Bone;
+            // Get target path (position, rotation or scaling)
+            var targetPath = channel.target.path;
+            var targetPathIndex = glTFAnimationPaths.indexOf(targetPath);
+            if (targetPathIndex !== -1) {
+                targetPath = babylonAnimationPaths[targetPathIndex];
+            }
+            // Determine animation type
+            var animationType = Animation.ANIMATIONTYPE_MATRIX;
+            if (!isBone) {
+                if (targetPath === "rotationQuaternion") {
+                    animationType = Animation.ANIMATIONTYPE_QUATERNION;
+                    targetNode.rotationQuaternion = new Quaternion();
+                }
+                else {
+                    animationType = Animation.ANIMATIONTYPE_VECTOR3;
+                }
+            }
+            // Create animation and key frames
+            var babylonAnimation = null;
+            var keys = [];
+            var arrayOffset = 0;
+            var modifyKey = false;
+            if (isBone && lastAnimation && lastAnimation.getKeys().length === bufferInput.length) {
+                babylonAnimation = lastAnimation;
+                modifyKey = true;
+            }
+            if (!modifyKey) {
+                gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+                babylonAnimation = new Animation(anim, isBone ? "_matrix" : targetPath, 1, animationType, Animation.ANIMATIONLOOPMODE_CYCLE);
+                gltfRuntime.scene._blockEntityCollection = false;
+            }
+            // For each frame
+            for (var j = 0; j < bufferInput.length; j++) {
+                var value = null;
+                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
+                    value = Vector3.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]);
+                    arrayOffset += 3;
+                }
+                if (isBone) {
+                    var bone = targetNode;
+                    var translation = Vector3.Zero();
+                    var rotationQuaternion = new Quaternion();
+                    var scaling = Vector3.Zero();
+                    // Warning on decompose
+                    var mat = bone.getBaseMatrix();
+                    if (modifyKey && lastAnimation) {
+                        mat = lastAnimation.getKeys()[j].value;
+                    }
+                    mat.decompose(scaling, rotationQuaternion, translation);
+                    if (targetPath === "position") {
+                        translation = value;
+                    }
+                    else if (targetPath === "rotationQuaternion") {
+                        rotationQuaternion = value;
+                    }
+                    else {
+                        scaling = value;
+                    }
+                    value = Matrix.Compose(scaling, rotationQuaternion, translation);
+                }
+                if (!modifyKey) {
+                    keys.push({
+                        frame: bufferInput[j],
+                        value: value,
+                    });
+                }
+                else if (lastAnimation) {
+                    lastAnimation.getKeys()[j].value = value;
+                }
+            }
+            // Finish
+            if (!modifyKey && babylonAnimation) {
+                babylonAnimation.setKeys(keys);
+                targetNode.animations.push(babylonAnimation);
+            }
+            lastAnimation = babylonAnimation;
+            gltfRuntime.scene.stopAnimation(targetNode);
+            gltfRuntime.scene.beginAnimation(targetNode, 0, bufferInput[bufferInput.length - 1], true, 1.0);
+        }
+    }
+};
+/**
+ * Returns the bones transformation matrix
+ * @param node
+ */
+var configureBoneTransformation = function (node) {
+    var 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]);
+        mat = Matrix.Compose(scale, rotation, position);
+    }
+    else {
+        mat = Matrix.FromArray(node.matrix);
+    }
+    return mat;
+};
+/**
+ * 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++) {
+        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];
+        if (!node.jointName) {
+            continue;
+        }
+        var children = node.children;
+        for (var i = 0; i < children.length; i++) {
+            var 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);
+                bone.id = nde;
+                return bone;
+            }
+        }
+    }
+    return null;
+};
+/**
+ * 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];
+        for (var j = 0; j < nodeToRoot.node.children.length; j++) {
+            var child = nodeToRoot.node.children[j];
+            if (child === id) {
+                return nodeToRoot.bone;
+            }
+        }
+    }
+    return null;
+};
+/**
+ * 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,
+        };
+    }
+    for (var nde in nodes) {
+        node = nodes[nde];
+        if (node.jointName === jointName) {
+            return {
+                node: node,
+                id: nde,
+            };
+        }
+    }
+    return null;
+};
+/**
+ * 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) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * 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) {
+        var node = gltfRuntime.nodes[nde];
+        var 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);
+        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++) {
+                if (nodesToRoot[k].id === children[j]) {
+                    child = nodesToRoot[k];
+                    break;
+                }
+            }
+            if (child) {
+                child.bone._parent = nodeToRoot.bone;
+                nodeToRoot.bone.children.push(child.bone);
+            }
+        }
+    }
+};
+/**
+ * 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);
+    }
+    if (!skins.babylonSkeleton) {
+        return newSkeleton;
+    }
+    // Find the root bones
+    var nodesToRoot = [];
+    var 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]);
+        if (!jointNode) {
+            continue;
+        }
+        var node = jointNode.node;
+        if (!node) {
+            Tools.Warn("Joint named " + skins.jointNames[i] + " does not exist");
+            continue;
+        }
+        var id = jointNode.id;
+        // Optimize, if the bone already exists...
+        var 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) {
+                continue;
+            }
+            var joint = jointNode_1.node;
+            if (!joint) {
+                Tools.Warn("Joint named " + skins.jointNames[j] + " does not exist when looking for parent");
+                continue;
+            }
+            var children = joint.children;
+            if (!children) {
+                continue;
+            }
+            foundBone = false;
+            for (var k = 0; k < children.length; k++) {
+                if (children[k] === id) {
+                    parentBone = getParentBone(gltfRuntime, skins, skins.jointNames[j], newSkeleton);
+                    foundBone = true;
+                    break;
+                }
+            }
+            if (foundBone) {
+                break;
+            }
+        }
+        // Create bone
+        var mat = configureBoneTransformation(node);
+        if (!parentBone && nodesToRoot.length > 0) {
+            parentBone = getNodeToRoot(nodesToRoot, id);
+            if (parentBone) {
+                if (nodesToRootToAdd.indexOf(parentBone) === -1) {
+                    nodesToRootToAdd.push(parentBone);
+                }
+            }
+        }
+        var bone = new Bone(node.jointName || "", newSkeleton, parentBone, mat);
+        bone.id = id;
+    }
+    // Polish
+    var bones = newSkeleton.bones;
+    newSkeleton.bones = [];
+    for (var i = 0; i < skins.jointNames.length; i++) {
+        var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
+        if (!jointNode) {
+            continue;
+        }
+        for (var j = 0; j < bones.length; j++) {
+            if (bones[j].id === jointNode.id) {
+                newSkeleton.bones.push(bones[j]);
+                break;
+            }
+        }
+    }
+    newSkeleton.prepare();
+    // Finish
+    for (var i = 0; i < nodesToRootToAdd.length; i++) {
+        newSkeleton.bones.push(nodesToRootToAdd[i]);
+    }
+    return newSkeleton;
+};
+/**
+ * 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;
+        newMesh = new Mesh(node.name || "", gltfRuntime.scene);
+        newMesh._parentContainer = gltfRuntime.assetContainer;
+        gltfRuntime.scene._blockEntityCollection = false;
+        newMesh.id = id;
+    }
+    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];
+        if (!mesh) {
+            continue;
+        }
+        // Positions, normals and UVs
+        for (var i = 0; i < mesh.primitives.length; i++) {
+            // Temporary vertex data
+            var tempVertexData = new VertexData();
+            var primitive = mesh.primitives[i];
+            if (primitive.mode !== 4) {
+                // continue;
+            }
+            var attributes = primitive.attributes;
+            var accessor = null;
+            var buffer = null;
+            // Set positions, normal and uvs
+            for (var semantic in attributes) {
+                // Link accessor and buffer view
+                accessor = gltfRuntime.accessors[attributes[semantic]];
+                buffer = GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
+                if (semantic === "NORMAL") {
+                    tempVertexData.normals = new Float32Array(buffer.length);
+                    tempVertexData.normals.set(buffer);
+                }
+                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) {
+                            tempVertexData.positions[j] = buffer[j];
+                            tempVertexData.positions[j + 1] = buffer[j + 1];
+                            tempVertexData.positions[j + 2] = buffer[j + 2];
+                        }
+                    }
+                    else {
+                        tempVertexData.positions = new Float32Array(buffer.length);
+                        tempVertexData.positions.set(buffer);
+                    }
+                    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);
+                    uvs.set(buffer);
+                    normalizeUVs(uvs);
+                    tempVertexData.set(uvs, uvKind);
+                }
+                else if (semantic === "JOINT") {
+                    tempVertexData.matricesIndices = new Float32Array(buffer.length);
+                    tempVertexData.matricesIndices.set(buffer);
+                }
+                else if (semantic === "WEIGHT") {
+                    tempVertexData.matricesWeights = new Float32Array(buffer.length);
+                    tempVertexData.matricesWeights.set(buffer);
+                }
+                else if (semantic === "COLOR") {
+                    tempVertexData.colors = new Float32Array(buffer.length);
+                    tempVertexData.colors.set(buffer);
+                }
+            }
+            // Indices
+            accessor = gltfRuntime.accessors[primitive.indices];
+            if (accessor) {
+                buffer = GLTFUtils.GetBufferFromAccessor(gltfRuntime, accessor);
+                tempVertexData.indices = new Int32Array(buffer.length);
+                tempVertexData.indices.set(buffer);
+                indexCounts.push(tempVertexData.indices.length);
+            }
+            else {
+                // Set indices on the fly
+                var indices = [];
+                for (var j = 0; j < tempVertexData.positions.length / 3; j++) {
+                    indices.push(j);
+                }
+                tempVertexData.indices = new Int32Array(indices);
+                indexCounts.push(tempVertexData.indices.length);
+            }
+            if (!vertexData) {
+                vertexData = tempVertexData;
+            }
+            else {
+                vertexData.merge(tempVertexData);
+            }
+            // Sub material
+            var material_1 = gltfRuntime.scene.getMaterialById(primitive.material);
+            subMaterials.push(material_1 === null ? GLTFUtils.GetDefaultMaterial(gltfRuntime.scene) : material_1);
+            // 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;
+    gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+    if (subMaterials.length > 1) {
+        material = new MultiMaterial("multimat" + id, gltfRuntime.scene);
+        material.subMaterials = subMaterials;
+    }
+    else {
+        material = new StandardMaterial("multimat" + id, gltfRuntime.scene);
+    }
+    if (subMaterials.length === 1) {
+        material = subMaterials[0];
+    }
+    material._parentContainer = gltfRuntime.assetContainer;
+    if (!newMesh.material) {
+        newMesh.material = material;
+    }
+    // Apply geometry
+    new Geometry(id, gltfRuntime.scene, vertexData, false, newMesh);
+    newMesh.computeWorldMatrix(true);
+    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];
+        if (!mesh) {
+            continue;
+        }
+        for (var i = 0; i < mesh.primitives.length; i++) {
+            if (mesh.primitives[i].mode !== 4) {
+                //continue;
+            }
+            SubMesh.AddToMesh(index, verticesStarts[index], verticesCounts[index], indexStarts[index], indexCounts[index], newMesh, newMesh, true);
+            index++;
+        }
+    }
+    // Finish
+    return newMesh;
+};
+/**
+ * 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;
+    }
+    if (newNode.rotationQuaternion || newNode.rotation) {
+        newNode.rotationQuaternion = rotation;
+    }
+    if (newNode.scaling) {
+        newNode.scaling = scaling;
+    }
+};
+/**
+ * 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();
+        var scaling = new Vector3(0, 0, 0);
+        var mat = Matrix.FromArray(node.matrix);
+        mat.decompose(scaling, rotation, position);
+        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));
+    }
+    newNode.computeWorldMatrix(true);
+};
+/**
+ * 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) {
+            return null;
+        }
+    }
+    // Meshes
+    if (node.skin) {
+        if (node.meshes) {
+            var skin = gltfRuntime.skins[node.skin];
+            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);
+                if (!skin.babylonSkeleton) {
+                    skin.babylonSkeleton = newMesh.skeleton;
+                }
+            }
+            lastNode = newMesh;
+        }
+    }
+    else if (node.meshes) {
+        /**
+         * Improve meshes property
+         */
+        var 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];
+        if (light) {
+            if (light.type === "ambient") {
+                var ambienLight = light[light.type];
+                var hemiLight = new HemisphericLight(node.light, Vector3.Zero(), gltfRuntime.scene);
+                hemiLight.name = node.name || "";
+                if (ambienLight.color) {
+                    hemiLight.diffuse = Color3.FromArray(ambienLight.color);
+                }
+                lastNode = hemiLight;
+            }
+            else if (light.type === "directional") {
+                var directionalLight = light[light.type];
+                var dirLight = new DirectionalLight(node.light, Vector3.Zero(), gltfRuntime.scene);
+                dirLight.name = node.name || "";
+                if (directionalLight.color) {
+                    dirLight.diffuse = Color3.FromArray(directionalLight.color);
+                }
+                lastNode = dirLight;
+            }
+            else if (light.type === "point") {
+                var pointLight = light[light.type];
+                var ptLight = new PointLight(node.light, Vector3.Zero(), gltfRuntime.scene);
+                ptLight.name = node.name || "";
+                if (pointLight.color) {
+                    ptLight.diffuse = Color3.FromArray(pointLight.color);
+                }
+                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);
+                spLight.name = node.name || "";
+                if (spotLight.color) {
+                    spLight.diffuse = Color3.FromArray(spotLight.color);
+                }
+                if (spotLight.fallOfAngle) {
+                    spLight.angle = spotLight.fallOfAngle;
+                }
+                if (spotLight.fallOffExponent) {
+                    spLight.exponent = spotLight.fallOffExponent;
+                }
+                lastNode = spLight;
+            }
+        }
+    }
+    // Cameras
+    else if (node.camera && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
+        var 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);
+                orthoCamera.name = node.name || "";
+                orthoCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;
+                orthoCamera.attachControl();
+                lastNode = orthoCamera;
+                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);
+                persCamera.name = node.name || "";
+                persCamera.attachControl();
+                if (!perspectiveCamera.aspectRatio) {
+                    perspectiveCamera.aspectRatio = gltfRuntime.scene.getEngine().getRenderWidth() / gltfRuntime.scene.getEngine().getRenderHeight();
+                }
+                if (perspectiveCamera.znear && perspectiveCamera.zfar) {
+                    persCamera.maxZ = perspectiveCamera.zfar;
+                    persCamera.minZ = perspectiveCamera.znear;
+                }
+                lastNode = persCamera;
+                persCamera._parentContainer = gltfRuntime.assetContainer;
+            }
+            gltfRuntime.scene._blockEntityCollection = false;
+        }
+    }
+    // Empty node
+    if (!node.jointName) {
+        if (node.babylonNode) {
+            return node.babylonNode;
+        }
+        else if (lastNode === null) {
+            gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+            var dummy = new Mesh(node.name || "", gltfRuntime.scene);
+            dummy._parentContainer = gltfRuntime.assetContainer;
+            gltfRuntime.scene._blockEntityCollection = false;
+            node.babylonNode = dummy;
+            lastNode = dummy;
+        }
+    }
+    if (lastNode !== null) {
+        if (node.matrix && lastNode instanceof Mesh) {
+            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];
+            configureNode(lastNode, Vector3.FromArray(translation), Quaternion.FromArray(rotation), Vector3.FromArray(scale));
+        }
+        lastNode.updateCache(true);
+        node.babylonNode = lastNode;
+    }
+    return lastNode;
+};
+/**
+ * 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];
+    var newNode = null;
+    if (gltfRuntime.importOnlyMeshes && !meshIncluded && gltfRuntime.importMeshesNames) {
+        if (gltfRuntime.importMeshesNames.indexOf(node.name || "") !== -1 || gltfRuntime.importMeshesNames.length === 0) {
+            meshIncluded = true;
+        }
+        else {
+            meshIncluded = false;
+        }
+    }
+    else {
+        meshIncluded = true;
+    }
+    if (!node.jointName && meshIncluded) {
+        newNode = importNode(gltfRuntime, node, id);
+        if (newNode !== null) {
+            newNode.id = id;
+            newNode.parent = parent;
+        }
+    }
+    if (node.children) {
+        for (var i = 0; i < node.children.length; i++) {
+            traverseNodes(gltfRuntime, node.children[i], newNode, meshIncluded);
+        }
+    }
+};
+/**
+ * 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;
+    if (currentScene) {
+        for (var i = 0; i < currentScene.nodes.length; i++) {
+            traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+        }
+    }
+    else {
+        for (var thing in gltfRuntime.scenes) {
+            currentScene = gltfRuntime.scenes[thing];
+            for (var 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];
+        gltfRuntime.scene.beginAnimation(skeleton, 0, Number.MAX_VALUE, true, 1.0);
+    }
+};
+/**
+ * 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) {
+        var uniform = unTreatedUniforms[unif];
+        var 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 || "");
+                if (source === null) {
+                    source = gltfRuntime.scene.getNodeById(uniform.source || uniform.node || "");
+                }
+                if (source === null) {
+                    continue;
+                }
+                GLTFUtils.SetMatrix(gltfRuntime.scene, source, uniform, unif, shaderMaterial.getEffect());
+            }
+        }
+        else {
+            var value = materialValues[technique.uniforms[unif]];
+            if (!value) {
+                continue;
+            }
+            if (type === EParameterType.SAMPLER_2D) {
+                var texture = gltfRuntime.textures[material.values ? value : uniform.value].babylonTexture;
+                if (texture === null || texture === undefined) {
+                    continue;
+                }
+                shaderMaterial.getEffect().setTexture(unif, texture);
+            }
+            else {
+                GLTFUtils.SetUniform(shaderMaterial.getEffect(), unif, value, type);
+            }
+        }
+    }
+    onSuccess(shaderMaterial);
+};
+/**
+ * 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;
+    var _loop_1 = function (unif) {
+        var uniform = unTreatedUniforms[unif];
+        var type = uniform.type;
+        var value = materialValues[techniqueUniforms[unif]];
+        if (value === undefined) {
+            // In case the value is the same for all materials
+            value = uniform.value;
+        }
+        if (!value) {
+            return "continue";
+        }
+        var onLoadTexture = function (uniformName) {
+            return function (texture) {
+                if (uniform.value && uniformName) {
+                    // Static uniform
+                    shaderMaterial.setTexture(uniformName, texture);
+                    delete unTreatedUniforms[uniformName];
+                }
+            };
+        };
+        // Texture (sampler2D)
+        if (type === EParameterType.SAMPLER_2D) {
+            GLTFLoaderExtension.LoadTextureAsync(gltfRuntime, material.values ? value : uniform.value, onLoadTexture(unif), function () { return onLoadTexture(null); });
+        }
+        // Others
+        else {
+            if (uniform.value && GLTFUtils.SetUniform(shaderMaterial, unif, material.values ? value : uniform.value, type)) {
+                // Static uniform
+                delete unTreatedUniforms[unif];
+            }
+        }
+    };
+    /**
+     * Prepare values here (not matrices)
+     */
+    for (var unif in unTreatedUniforms) {
+        _loop_1(unif);
+    }
+};
+/**
+ * Shader compilation failed
+ * @param program
+ * @param shaderMaterial
+ * @param onError
+ */
+var onShaderCompileError = function (program, shaderMaterial, onError) {
+    return function (effect, error) {
+        shaderMaterial.dispose(true);
+        onError("Cannot compile program named " + program.name + ". Error: " + error + ". Default material will be applied");
+    };
+};
+/**
+ * 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);
+        shaderMaterial.onBind = function (mesh) {
+            onBindShaderMaterial(mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material, onSuccess);
+        };
+    };
+};
+/**
+ * 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];
+        var uniformParameter = technique.parameters[uniform];
+        if (tokenizer.currentIdentifier === unif) {
+            if (uniformParameter.semantic && !uniformParameter.source && !uniformParameter.node) {
+                var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
+                if (transformIndex !== -1) {
+                    delete unTreatedUniforms[unif];
+                    return babylonTransforms[transformIndex];
+                }
+            }
+        }
+    }
+    return tokenizer.currentIdentifier;
+};
+/**
+ * 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 () { }, function () { });
+    }
+};
+/**
+ * Implementation of the base glTF spec
+ * @hidden
+ */
+var GLTFLoaderBase = /** @class */ (function () {
+    function GLTFLoaderBase() {
+    }
+    GLTFLoaderBase.CreateRuntime = function (parsedData, scene, rootUrl) {
+        var gltfRuntime = {
+            extensions: {},
+            accessors: {},
+            buffers: {},
+            bufferViews: {},
+            meshes: {},
+            lights: {},
+            cameras: {},
+            nodes: {},
+            images: {},
+            textures: {},
+            shaders: {},
+            programs: {},
+            samplers: {},
+            techniques: {},
+            materials: {},
+            animations: {},
+            skins: {},
+            extensionsUsed: [],
+            scenes: {},
+            buffersCount: 0,
+            shaderscount: 0,
+            scene: scene,
+            rootUrl: rootUrl,
+            loadedBufferCount: 0,
+            loadedBufferViews: {},
+            loadedShaderCount: 0,
+            importOnlyMeshes: false,
+            dummyNodes: [],
+            assetContainer: null,
+        };
+        // Parse
+        if (parsedData.extensions) {
+            parseObject(parsedData.extensions, "extensions", gltfRuntime);
+        }
+        if (parsedData.extensionsUsed) {
+            parseObject(parsedData.extensionsUsed, "extensionsUsed", gltfRuntime);
+        }
+        if (parsedData.buffers) {
+            parseBuffers(parsedData.buffers, gltfRuntime);
+        }
+        if (parsedData.bufferViews) {
+            parseObject(parsedData.bufferViews, "bufferViews", gltfRuntime);
+        }
+        if (parsedData.accessors) {
+            parseObject(parsedData.accessors, "accessors", gltfRuntime);
+        }
+        if (parsedData.meshes) {
+            parseObject(parsedData.meshes, "meshes", gltfRuntime);
+        }
+        if (parsedData.lights) {
+            parseObject(parsedData.lights, "lights", gltfRuntime);
+        }
+        if (parsedData.cameras) {
+            parseObject(parsedData.cameras, "cameras", gltfRuntime);
+        }
+        if (parsedData.nodes) {
+            parseObject(parsedData.nodes, "nodes", gltfRuntime);
+        }
+        if (parsedData.images) {
+            parseObject(parsedData.images, "images", gltfRuntime);
+        }
+        if (parsedData.textures) {
+            parseObject(parsedData.textures, "textures", gltfRuntime);
+        }
+        if (parsedData.shaders) {
+            parseShaders(parsedData.shaders, gltfRuntime);
+        }
+        if (parsedData.programs) {
+            parseObject(parsedData.programs, "programs", gltfRuntime);
+        }
+        if (parsedData.samplers) {
+            parseObject(parsedData.samplers, "samplers", gltfRuntime);
+        }
+        if (parsedData.techniques) {
+            parseObject(parsedData.techniques, "techniques", gltfRuntime);
+        }
+        if (parsedData.materials) {
+            parseObject(parsedData.materials, "materials", gltfRuntime);
+        }
+        if (parsedData.animations) {
+            parseObject(parsedData.animations, "animations", gltfRuntime);
+        }
+        if (parsedData.skins) {
+            parseObject(parsedData.skins, "skins", gltfRuntime);
+        }
+        if (parsedData.scenes) {
+            gltfRuntime.scenes = parsedData.scenes;
+        }
+        if (parsedData.scene && parsedData.scenes) {
+            gltfRuntime.currentScene = parsedData.scenes[parsedData.scene];
+        }
+        return gltfRuntime;
+    };
+    GLTFLoaderBase.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
+        var buffer = gltfRuntime.buffers[id];
+        if (Tools.IsBase64(buffer.uri)) {
+            setTimeout(function () { return 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) {
+                if (request) {
+                    onError(request.status + " " + request.statusText);
+                }
+            });
+        }
+    };
+    GLTFLoaderBase.LoadTextureBufferAsync = function (gltfRuntime, id, onSuccess, onError) {
+        var texture = gltfRuntime.textures[id];
+        if (!texture || !texture.source) {
+            onError("");
+            return;
+        }
+        if (texture.babylonTexture) {
+            onSuccess(null);
+            return;
+        }
+        var source = gltfRuntime.images[texture.source];
+        if (Tools.IsBase64(source.uri)) {
+            setTimeout(function () { return 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) {
+                if (request) {
+                    onError(request.status + " " + request.statusText);
+                }
+            });
+        }
+    };
+    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 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);
+        if (sampler.wrapS !== undefined) {
+            newTexture.wrapU = GLTFUtils.GetWrapMode(sampler.wrapS);
+        }
+        if (sampler.wrapT !== undefined) {
+            newTexture.wrapV = GLTFUtils.GetWrapMode(sampler.wrapT);
+        }
+        newTexture.name = id;
+        texture.babylonTexture = newTexture;
+        onSuccess(newTexture);
+    };
+    GLTFLoaderBase.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
+        var shader = gltfRuntime.shaders[id];
+        if (Tools.IsBase64(shader.uri)) {
+            var shaderString = atob(shader.uri.split(",")[1]);
+            if (onSuccess) {
+                onSuccess(shaderString);
+            }
+        }
+        else {
+            Tools.LoadFile(gltfRuntime.rootUrl + shader.uri, onSuccess, undefined, undefined, false, function (request) {
+                if (request && onError) {
+                    onError(request.status + " " + request.statusText);
+                }
+            });
+        }
+    };
+    GLTFLoaderBase.LoadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
+        var material = gltfRuntime.materials[id];
+        if (!material.technique) {
+            if (onError) {
+                onError("No technique found.");
+            }
+            return;
+        }
+        var technique = gltfRuntime.techniques[material.technique];
+        if (!technique) {
+            gltfRuntime.scene._blockEntityCollection = !!gltfRuntime.assetContainer;
+            var defaultMaterial = new StandardMaterial(id, gltfRuntime.scene);
+            defaultMaterial._parentContainer = gltfRuntime.assetContainer;
+            gltfRuntime.scene._blockEntityCollection = false;
+            defaultMaterial.diffuseColor = new Color3(0.5, 0.5, 0.5);
+            defaultMaterial.sideOrientation = Material.CounterClockWiseSideOrientation;
+            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 = [];
+        // Fill uniform, sampler2D and attributes
+        for (var unif in technique.uniforms) {
+            var uniform = technique.uniforms[unif];
+            var uniformParameter = technique.parameters[uniform];
+            unTreatedUniforms[unif] = uniformParameter;
+            if (uniformParameter.semantic && !uniformParameter.node && !uniformParameter.source) {
+                var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
+                if (transformIndex !== -1) {
+                    uniforms.push(babylonTransforms[transformIndex]);
+                    delete unTreatedUniforms[unif];
+                }
+                else {
+                    uniforms.push(unif);
+                }
+            }
+            else if (uniformParameter.type === EParameterType.SAMPLER_2D) {
+                samplers.push(unif);
+            }
+            else {
+                uniforms.push(unif);
+            }
+        }
+        for (var attr in technique.attributes) {
+            var attribute = technique.attributes[attr];
+            var attributeParameter = technique.parameters[attribute];
+            if (attributeParameter.semantic) {
+                var name_1 = getAttribute(attributeParameter);
+                if (name_1) {
+                    attributes.push(name_1);
+                }
+            }
+        }
+        // Configure vertex shader
+        while (!vertexTokenizer.isEnd() && vertexTokenizer.getNextToken()) {
+            var 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];
+                if (vertexTokenizer.currentIdentifier === attr && attributeParameter.semantic) {
+                    newVertexShader += getAttribute(attributeParameter);
+                    foundAttribute = true;
+                    break;
+                }
+            }
+            if (foundAttribute) {
+                continue;
+            }
+            newVertexShader += parseShaderUniforms(vertexTokenizer, technique, unTreatedUniforms);
+        }
+        // Configure pixel shader
+        while (!pixelTokenizer.isEnd() && pixelTokenizer.getNextToken()) {
+            var tokenType = pixelTokenizer.currentToken;
+            if (tokenType !== ETokenType.IDENTIFIER) {
+                newPixelShader += pixelTokenizer.currentString;
+                continue;
+            }
+            newPixelShader += parseShaderUniforms(pixelTokenizer, technique, unTreatedUniforms);
+        }
+        // Create shader material
+        var shaderPath = {
+            vertex: program.vertexShader + id,
+            fragment: program.fragmentShader + id,
+        };
+        var options = {
+            attributes: attributes,
+            uniforms: uniforms,
+            samplers: samplers,
+            needAlphaBlending: states && states.enable && states.enable.indexOf(3042) !== -1,
+        };
+        Effect.ShadersStore[program.vertexShader + id + "VertexShader"] = newVertexShader;
+        Effect.ShadersStore[program.fragmentShader + id + "PixelShader"] = newPixelShader;
+        var 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;
+            if (functions.cullFace && functions.cullFace[0] !== ECullingType.BACK) {
+                shaderMaterial.backFaceCulling = false;
+            }
+            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) {
+                    shaderMaterial.alphaMode = Constants.ALPHA_COMBINE;
+                }
+                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) {
+                    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) {
+                    shaderMaterial.alphaMode = Constants.ALPHA_SUBTRACT;
+                }
+                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) {
+                    shaderMaterial.alphaMode = Constants.ALPHA_MAXIMIZED;
+                }
+            }
+        }
+    };
+    return GLTFLoaderBase;
+}());
+export { GLTFLoaderBase };
+/**
+ * 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');
+            return;
+        }
+        GLTFLoader.Extensions[extension.name] = extension;
+    };
+    GLTFLoader.prototype.dispose = function () {
+        // do nothing
+    };
+    GLTFLoader.prototype._importMeshAsync = function (meshesNames, scene, data, rootUrl, assetContainer, onSuccess, onProgress, onError) {
+        var _this = this;
+        scene.useRightHandedSystem = true;
+        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
+            gltfRuntime.assetContainer = assetContainer;
+            gltfRuntime.importOnlyMeshes = true;
+            if (meshesNames === "") {
+                gltfRuntime.importMeshesNames = [];
+            }
+            else if (typeof meshesNames === "string") {
+                gltfRuntime.importMeshesNames = [meshesNames];
+            }
+            else if (meshesNames && !(meshesNames instanceof Array)) {
+                gltfRuntime.importMeshesNames = [meshesNames];
+            }
+            else {
+                gltfRuntime.importMeshesNames = [];
+                Tools.Warn("Argument meshesNames must be of type string or string[]");
+            }
+            // Create nodes
+            _this._createNodes(gltfRuntime);
+            var meshes = new Array();
+            var skeletons = new Array();
+            // Fill arrays of meshes and skeletons
+            for (var nde in gltfRuntime.nodes) {
+                var node = gltfRuntime.nodes[nde];
+                if (node.babylonNode instanceof AbstractMesh) {
+                    meshes.push(node.babylonNode);
+                }
+            }
+            for (var skl in gltfRuntime.skins) {
+                var 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 () {
+                    importMaterials(gltfRuntime);
+                    postLoad(gltfRuntime);
+                    if (!GLTFFileLoader.IncrementalLoading && onSuccess) {
+                        onSuccess(meshes, skeletons);
+                    }
+                });
+            });
+            if (GLTFFileLoader.IncrementalLoading && onSuccess) {
+                onSuccess(meshes, skeletons);
+            }
+        }, 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
+     * @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) {
+            _this._importMeshAsync(meshesNames, scene, data, rootUrl, assetContainer, function (meshes, skeletons) {
+                resolve({
+                    meshes: meshes,
+                    particleSystems: [],
+                    skeletons: skeletons,
+                    animationGroups: [],
+                    lights: [],
+                    transformNodes: [],
+                    geometries: [],
+                });
+            }, onProgress, function (message) {
+                reject(new Error(message));
+            });
+        });
+    };
+    GLTFLoader.prototype._loadAsync = function (scene, data, rootUrl, onSuccess, onProgress, onError) {
+        var _this = this;
+        scene.useRightHandedSystem = true;
+        GLTFLoaderExtension.LoadRuntimeAsync(scene, data, rootUrl, function (gltfRuntime) {
+            // Load runtime extensios
+            GLTFLoaderExtension.LoadRuntimeExtensionsAsync(gltfRuntime, function () {
+                // Create nodes
+                _this._createNodes(gltfRuntime);
+                // Load buffers, shaders, materials, etc.
+                _this._loadBuffersAsync(gltfRuntime, function () {
+                    _this._loadShadersAsync(gltfRuntime, function () {
+                        importMaterials(gltfRuntime);
+                        postLoad(gltfRuntime);
+                        if (!GLTFFileLoader.IncrementalLoading) {
+                            onSuccess();
+                        }
+                    });
+                });
+                if (GLTFFileLoader.IncrementalLoading) {
+                    onSuccess();
+                }
+            }, 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
+     * @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) {
+            _this._loadAsync(scene, data, rootUrl, function () {
+                resolve();
+            }, onProgress, function (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) {
+                if (shaderString instanceof ArrayBuffer) {
+                    return;
+                }
+                gltfRuntime.loadedShaderCount++;
+                if (shaderString) {
+                    Effect.ShadersStore[sha + (shader.type === EShaderType.VERTEX ? "VertexShader" : "PixelShader")] = shaderString;
+                }
+                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) {
+            hasShaders = true;
+            var shader = gltfRuntime.shaders[sha];
+            if (shader) {
+                processShader.bind(this, sha, shader)();
+            }
+            else {
+                Tools.Error("No shader named: " + sha);
+            }
+        }
+        if (!hasShaders) {
+            onload();
+        }
+    };
+    GLTFLoader.prototype._loadBuffersAsync = function (gltfRuntime, onLoad) {
+        var hasBuffers = false;
+        var processBuffer = function (buf, buffer) {
+            GLTFLoaderExtension.LoadBufferAsync(gltfRuntime, buf, function (bufferView) {
+                gltfRuntime.loadedBufferCount++;
+                if (bufferView) {
+                    if (bufferView.byteLength != gltfRuntime.buffers[buf].byteLength) {
+                        Tools.Error("Buffer named " + buf + " is length " + bufferView.byteLength + ". Expected: " + buffer.byteLength); // Improve error message
+                    }
+                    gltfRuntime.loadedBufferViews[buf] = bufferView;
+                }
+                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) {
+            hasBuffers = true;
+            var buffer = gltfRuntime.buffers[buf];
+            if (buffer) {
+                processBuffer.bind(this, buf, buffer)();
+            }
+            else {
+                Tools.Error("No buffer named: " + buf);
+            }
+        }
+        if (!hasBuffers) {
+            onLoad();
+        }
+    };
+    GLTFLoader.prototype._createNodes = function (gltfRuntime) {
+        var currentScene = gltfRuntime.currentScene;
+        if (currentScene) {
+            // Only one scene even if multiple scenes are defined
+            for (var i = 0; i < currentScene.nodes.length; i++) {
+                traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+            }
+        }
+        else {
+            // Load all scenes
+            for (var thing in gltfRuntime.scenes) {
+                currentScene = gltfRuntime.scenes[thing];
+                for (var i = 0; i < currentScene.nodes.length; i++) {
+                    traverseNodes(gltfRuntime, currentScene.nodes[i], null);
+                }
+            }
+        }
+    };
+    GLTFLoader.Extensions = {};
+    return GLTFLoader;
+}());
+export { GLTFLoader };
+/** @hidden */
+var GLTFLoaderExtension = /** @class */ (function () {
+    function GLTFLoaderExtension(name) {
+        this._name = name;
+    }
+    Object.defineProperty(GLTFLoaderExtension.prototype, "name", {
+        get: function () {
+            return this._name;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * 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
+     * @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
+     * @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
+     * @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
+     * @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
+     * @param gltfRuntime
+     * @param id
+     * @param onSuccess
+     * @param onError
+     */
+    GLTFLoaderExtension.prototype.loadMaterialAsync = function (gltfRuntime, id, onSuccess, onError) {
+        return false;
+    };
+    // ---------
+    // Utilities
+    // ---------
+    GLTFLoaderExtension.LoadRuntimeAsync = function (scene, data, rootUrl, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+            return loaderExtension.loadRuntimeAsync(scene, data, rootUrl, onSuccess, onError);
+        }, function () {
+            setTimeout(function () {
+                if (!onSuccess) {
+                    return;
+                }
+                onSuccess(GLTFLoaderBase.CreateRuntime(data.json, scene, rootUrl));
+            });
+        });
+    };
+    GLTFLoaderExtension.LoadRuntimeExtensionsAsync = function (gltfRuntime, onSuccess, onError) {
+        GLTFLoaderExtension._ApplyExtensions(function (loaderExtension) {
+            return loaderExtension.loadRuntimeExtensionsAsync(gltfRuntime, onSuccess, onError);
+        }, function () {
+            setTimeout(function () {
+                onSuccess();
+            });
+        });
+    };
+    GLTFLoaderExtension.LoadBufferAsync = function (gltfRuntime, id, onSuccess, onError, onProgress) {
+        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) {
+            if (buffer) {
+                GLTFLoaderExtension._CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
+            }
+        }, onError);
+    };
+    GLTFLoaderExtension.LoadShaderStringAsync = function (gltfRuntime, id, onSuccess, onError) {
+        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) {
+            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) {
+            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) {
+            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];
+            if (func(loaderExtension)) {
+                return;
+            }
+        }
+        defaultFunc();
+    };
+    return GLTFLoaderExtension;
+}());
+export { GLTFLoaderExtension };
+GLTFFileLoader._CreateGLTF1Loader = function () { return new GLTFLoader(); };
 //# sourceMappingURL=glTFLoader.js.map