@babylonjs/loaders 5.0.0-rc.7 → 5.0.1

package/glTF/2.0/glTFLoader.js

@@ -1,2367 +1,2367 @@
-import { Deferred } from "@babylonjs/core/Misc/deferred.js";
-import { Quaternion, Vector3, Matrix, TmpVectors } 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 { AnimationGroup } from "@babylonjs/core/Animations/animationGroup.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 { Material } from "@babylonjs/core/Materials/material.js";
-import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
-import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
-import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
-import { Buffer, VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
-import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
-import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
-import { MorphTarget } from "@babylonjs/core/Morph/morphTarget.js";
-import { MorphTargetManager } from "@babylonjs/core/Morph/morphTargetManager.js";
-import { GLTFFileLoader, GLTFLoaderState, GLTFLoaderCoordinateSystemMode, GLTFLoaderAnimationStartMode } from "../glTFFileLoader.js";
-import { AnimationKeyInterpolation } from "@babylonjs/core/Animations/animationKey.js";
-import { DecodeBase64UrlToBinary, IsBase64DataUrl, LoadFileError } from "@babylonjs/core/Misc/fileTools.js";
-import { Logger } from "@babylonjs/core/Misc/logger.js";
-import { BoundingInfo } from "@babylonjs/core/Culling/boundingInfo.js";
-import { StringTools } from "@babylonjs/core/Misc/stringTools.js";
-/**
- * Helper class for working with arrays when loading the glTF asset
- */
-var ArrayItem = /** @class */ (function () {
-    function ArrayItem() {
-    }
-    /**
-     * Gets an item from the given array.
-     * @param context The context when loading the asset
-     * @param array The array to get the item from
-     * @param index The index to the array
-     * @returns The array item
-     */
-    ArrayItem.Get = function (context, array, index) {
-        if (!array || index == undefined || !array[index]) {
-            throw new Error("".concat(context, ": Failed to find index (").concat(index, ")"));
-        }
-        return array[index];
-    };
-    /**
-     * Assign an `index` field to each item of the given array.
-     * @param array The array of items
-     */
-    ArrayItem.Assign = function (array) {
-        if (array) {
-            for (var index = 0; index < array.length; index++) {
-                array[index].index = index;
-            }
-        }
-    };
-    return ArrayItem;
-}());
-export { ArrayItem };
-/**
- * The glTF 2.0 loader
- */
-var GLTFLoader = /** @class */ (function () {
-    /**
-     * @param parent
-     * @hidden
-     */
-    function GLTFLoader(parent) {
-        /** @hidden */
-        this._completePromises = new Array();
-        /** @hidden */
-        this._assetContainer = null;
-        /** Storage */
-        this._babylonLights = [];
-        /** @hidden */
-        this._disableInstancedMesh = 0;
-        this._extensions = new Array();
-        this._disposed = false;
-        this._rootUrl = null;
-        this._fileName = null;
-        this._uniqueRootUrl = null;
-        this._bin = null;
-        this._rootBabylonMesh = null;
-        this._defaultBabylonMaterialData = {};
-        this._postSceneLoadActions = new Array();
-        this._parent = parent;
-    }
-    /**
-     * Registers a loader extension.
-     * @param name The name of the loader extension.
-     * @param factory The factory function that creates the loader extension.
-     */
-    GLTFLoader.RegisterExtension = function (name, factory) {
-        if (GLTFLoader.UnregisterExtension(name)) {
-            Logger.Warn("Extension with the name '".concat(name, "' already exists"));
-        }
-        GLTFLoader._RegisteredExtensions[name] = {
-            factory: factory,
-        };
-    };
-    /**
-     * Unregisters a loader extension.
-     * @param name The name of the loader extension.
-     * @returns A boolean indicating whether the extension has been unregistered
-     */
-    GLTFLoader.UnregisterExtension = function (name) {
-        if (!GLTFLoader._RegisteredExtensions[name]) {
-            return false;
-        }
-        delete GLTFLoader._RegisteredExtensions[name];
-        return true;
-    };
-    Object.defineProperty(GLTFLoader.prototype, "gltf", {
-        /**
-         * The object that represents the glTF JSON.
-         */
-        get: function () {
-            if (!this._gltf) {
-                throw new Error("glTF JSON is not available");
-            }
-            return this._gltf;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFLoader.prototype, "bin", {
-        /**
-         * The BIN chunk of a binary glTF.
-         */
-        get: function () {
-            return this._bin;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFLoader.prototype, "parent", {
-        /**
-         * The parent file loader.
-         */
-        get: function () {
-            return this._parent;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFLoader.prototype, "babylonScene", {
-        /**
-         * The Babylon scene when loading the asset.
-         */
-        get: function () {
-            if (!this._babylonScene) {
-                throw new Error("Scene is not available");
-            }
-            return this._babylonScene;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFLoader.prototype, "rootBabylonMesh", {
-        /**
-         * The root Babylon mesh when loading the asset.
-         */
-        get: function () {
-            return this._rootBabylonMesh;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /** @hidden */
-    GLTFLoader.prototype.dispose = function () {
-        if (this._disposed) {
-            return;
-        }
-        this._disposed = true;
-        this._completePromises.length = 0;
-        this._extensions.forEach(function (extension) { return extension.dispose && extension.dispose(); });
-        this._extensions.length = 0;
-        this._gltf = null; // TODO
-        this._bin = null;
-        this._babylonScene = null; // TODO
-        this._rootBabylonMesh = null;
-        this._defaultBabylonMaterialData = {};
-        this._postSceneLoadActions.length = 0;
-        this._parent.dispose();
-    };
-    /**
-     * @param meshesNames
-     * @param scene
-     * @param container
-     * @param data
-     * @param rootUrl
-     * @param onProgress
-     * @param fileName
-     * @hidden
-     */
-    GLTFLoader.prototype.importMeshAsync = function (meshesNames, scene, container, data, rootUrl, onProgress, fileName) {
-        var _this = this;
-        if (fileName === void 0) { fileName = ""; }
-        return Promise.resolve().then(function () {
-            _this._babylonScene = scene;
-            _this._assetContainer = container;
-            _this._loadData(data);
-            var nodes = null;
-            if (meshesNames) {
-                var nodeMap_1 = {};
-                if (_this._gltf.nodes) {
-                    for (var _i = 0, _a = _this._gltf.nodes; _i < _a.length; _i++) {
-                        var node = _a[_i];
-                        if (node.name) {
-                            nodeMap_1[node.name] = node.index;
-                        }
-                    }
-                }
-                var names = meshesNames instanceof Array ? meshesNames : [meshesNames];
-                nodes = names.map(function (name) {
-                    var node = nodeMap_1[name];
-                    if (node === undefined) {
-                        throw new Error("Failed to find node '".concat(name, "'"));
-                    }
-                    return node;
-                });
-            }
-            return _this._loadAsync(rootUrl, fileName, nodes, function () {
-                return {
-                    meshes: _this._getMeshes(),
-                    particleSystems: [],
-                    skeletons: _this._getSkeletons(),
-                    animationGroups: _this._getAnimationGroups(),
-                    lights: _this._babylonLights,
-                    transformNodes: _this._getTransformNodes(),
-                    geometries: _this._getGeometries(),
-                };
-            });
-        });
-    };
-    /**
-     * @param scene
-     * @param data
-     * @param rootUrl
-     * @param onProgress
-     * @param fileName
-     * @hidden
-     */
-    GLTFLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress, fileName) {
-        var _this = this;
-        if (fileName === void 0) { fileName = ""; }
-        return Promise.resolve().then(function () {
-            _this._babylonScene = scene;
-            _this._loadData(data);
-            return _this._loadAsync(rootUrl, fileName, null, function () { return undefined; });
-        });
-    };
-    GLTFLoader.prototype._loadAsync = function (rootUrl, fileName, nodes, resultFunc) {
-        var _this = this;
-        return Promise.resolve()
-            .then(function () {
-            _this._rootUrl = rootUrl;
-            _this._uniqueRootUrl = !StringTools.StartsWith(rootUrl, "file:") && fileName ? rootUrl : "".concat(rootUrl).concat(Date.now(), "/");
-            _this._fileName = fileName;
-            _this._loadExtensions();
-            _this._checkExtensions();
-            var loadingToReadyCounterName = "".concat(GLTFLoaderState[GLTFLoaderState.LOADING], " => ").concat(GLTFLoaderState[GLTFLoaderState.READY]);
-            var loadingToCompleteCounterName = "".concat(GLTFLoaderState[GLTFLoaderState.LOADING], " => ").concat(GLTFLoaderState[GLTFLoaderState.COMPLETE]);
-            _this._parent._startPerformanceCounter(loadingToReadyCounterName);
-            _this._parent._startPerformanceCounter(loadingToCompleteCounterName);
-            _this._parent._setState(GLTFLoaderState.LOADING);
-            _this._extensionsOnLoading();
-            var promises = new Array();
-            // Block the marking of materials dirty until the scene is loaded.
-            var oldBlockMaterialDirtyMechanism = _this._babylonScene.blockMaterialDirtyMechanism;
-            _this._babylonScene.blockMaterialDirtyMechanism = true;
-            if (!_this.parent.loadOnlyMaterials) {
-                if (nodes) {
-                    promises.push(_this.loadSceneAsync("/nodes", { nodes: nodes, index: -1 }));
-                }
-                else if (_this._gltf.scene != undefined || (_this._gltf.scenes && _this._gltf.scenes[0])) {
-                    var scene = ArrayItem.Get("/scene", _this._gltf.scenes, _this._gltf.scene || 0);
-                    promises.push(_this.loadSceneAsync("/scenes/".concat(scene.index), scene));
-                }
-            }
-            if (!_this.parent.skipMaterials && _this.parent.loadAllMaterials && _this._gltf.materials) {
-                for (var m = 0; m < _this._gltf.materials.length; ++m) {
-                    var material = _this._gltf.materials[m];
-                    var context_1 = "/materials/" + m;
-                    var babylonDrawMode = Material.TriangleFillMode;
-                    promises.push(_this._loadMaterialAsync(context_1, material, null, babylonDrawMode, function () { }));
-                }
-            }
-            // Restore the blocking of material dirty.
-            _this._babylonScene.blockMaterialDirtyMechanism = oldBlockMaterialDirtyMechanism;
-            if (_this._parent.compileMaterials) {
-                promises.push(_this._compileMaterialsAsync());
-            }
-            if (_this._parent.compileShadowGenerators) {
-                promises.push(_this._compileShadowGeneratorsAsync());
-            }
-            var resultPromise = Promise.all(promises).then(function () {
-                if (_this._rootBabylonMesh) {
-                    _this._rootBabylonMesh.setEnabled(true);
-                }
-                _this._extensionsOnReady();
-                _this._parent._setState(GLTFLoaderState.READY);
-                _this._startAnimations();
-                return resultFunc();
-            });
-            return resultPromise.then(function (result) {
-                _this._parent._endPerformanceCounter(loadingToReadyCounterName);
-                Tools.SetImmediate(function () {
-                    if (!_this._disposed) {
-                        Promise.all(_this._completePromises).then(function () {
-                            _this._parent._endPerformanceCounter(loadingToCompleteCounterName);
-                            _this._parent._setState(GLTFLoaderState.COMPLETE);
-                            _this._parent.onCompleteObservable.notifyObservers(undefined);
-                            _this._parent.onCompleteObservable.clear();
-                            _this.dispose();
-                        }, function (error) {
-                            _this._parent.onErrorObservable.notifyObservers(error);
-                            _this._parent.onErrorObservable.clear();
-                            _this.dispose();
-                        });
-                    }
-                });
-                return result;
-            });
-        })
-            .catch(function (error) {
-            if (!_this._disposed) {
-                _this._parent.onErrorObservable.notifyObservers(error);
-                _this._parent.onErrorObservable.clear();
-                _this.dispose();
-            }
-            throw error;
-        });
-    };
-    GLTFLoader.prototype._loadData = function (data) {
-        this._gltf = data.json;
-        this._setupData();
-        if (data.bin) {
-            var buffers = this._gltf.buffers;
-            if (buffers && buffers[0] && !buffers[0].uri) {
-                var binaryBuffer = buffers[0];
-                if (binaryBuffer.byteLength < data.bin.byteLength - 3 || binaryBuffer.byteLength > data.bin.byteLength) {
-                    Logger.Warn("Binary buffer length (".concat(binaryBuffer.byteLength, ") from JSON does not match chunk length (").concat(data.bin.byteLength, ")"));
-                }
-                this._bin = data.bin;
-            }
-            else {
-                Logger.Warn("Unexpected BIN chunk");
-            }
-        }
-    };
-    GLTFLoader.prototype._setupData = function () {
-        ArrayItem.Assign(this._gltf.accessors);
-        ArrayItem.Assign(this._gltf.animations);
-        ArrayItem.Assign(this._gltf.buffers);
-        ArrayItem.Assign(this._gltf.bufferViews);
-        ArrayItem.Assign(this._gltf.cameras);
-        ArrayItem.Assign(this._gltf.images);
-        ArrayItem.Assign(this._gltf.materials);
-        ArrayItem.Assign(this._gltf.meshes);
-        ArrayItem.Assign(this._gltf.nodes);
-        ArrayItem.Assign(this._gltf.samplers);
-        ArrayItem.Assign(this._gltf.scenes);
-        ArrayItem.Assign(this._gltf.skins);
-        ArrayItem.Assign(this._gltf.textures);
-        if (this._gltf.nodes) {
-            var nodeParents = {};
-            for (var _i = 0, _a = this._gltf.nodes; _i < _a.length; _i++) {
-                var node = _a[_i];
-                if (node.children) {
-                    for (var _b = 0, _c = node.children; _b < _c.length; _b++) {
-                        var index = _c[_b];
-                        nodeParents[index] = node.index;
-                    }
-                }
-            }
-            var rootNode = this._createRootNode();
-            for (var _d = 0, _e = this._gltf.nodes; _d < _e.length; _d++) {
-                var node = _e[_d];
-                var parentIndex = nodeParents[node.index];
-                node.parent = parentIndex === undefined ? rootNode : this._gltf.nodes[parentIndex];
-            }
-        }
-    };
-    GLTFLoader.prototype._loadExtensions = function () {
-        for (var name_1 in GLTFLoader._RegisteredExtensions) {
-            var extension = GLTFLoader._RegisteredExtensions[name_1].factory(this);
-            if (extension.name !== name_1) {
-                Logger.Warn("The name of the glTF loader extension instance does not match the registered name: ".concat(extension.name, " !== ").concat(name_1));
-            }
-            this._extensions.push(extension);
-            this._parent.onExtensionLoadedObservable.notifyObservers(extension);
-        }
-        this._extensions.sort(function (a, b) { return (a.order || Number.MAX_VALUE) - (b.order || Number.MAX_VALUE); });
-        this._parent.onExtensionLoadedObservable.clear();
-    };
-    GLTFLoader.prototype._checkExtensions = function () {
-        if (this._gltf.extensionsRequired) {
-            var _loop_1 = function (name_2) {
-                var available = this_1._extensions.some(function (extension) { return extension.name === name_2 && extension.enabled; });
-                if (!available) {
-                    throw new Error("Require extension ".concat(name_2, " is not available"));
-                }
-            };
-            var this_1 = this;
-            for (var _i = 0, _a = this._gltf.extensionsRequired; _i < _a.length; _i++) {
-                var name_2 = _a[_i];
-                _loop_1(name_2);
-            }
-        }
-    };
-    GLTFLoader.prototype._createRootNode = function () {
-        this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        this._rootBabylonMesh = new Mesh("__root__", this._babylonScene);
-        this._rootBabylonMesh._parentContainer = this._assetContainer;
-        this._babylonScene._blockEntityCollection = false;
-        this._rootBabylonMesh.setEnabled(false);
-        var rootNode = {
-            _babylonTransformNode: this._rootBabylonMesh,
-            index: -1,
-        };
-        switch (this._parent.coordinateSystemMode) {
-            case GLTFLoaderCoordinateSystemMode.AUTO: {
-                if (!this._babylonScene.useRightHandedSystem) {
-                    rootNode.rotation = [0, 1, 0, 0];
-                    rootNode.scale = [1, 1, -1];
-                    GLTFLoader._LoadTransform(rootNode, this._rootBabylonMesh);
-                }
-                break;
-            }
-            case GLTFLoaderCoordinateSystemMode.FORCE_RIGHT_HANDED: {
-                this._babylonScene.useRightHandedSystem = true;
-                break;
-            }
-            default: {
-                throw new Error("Invalid coordinate system mode (".concat(this._parent.coordinateSystemMode, ")"));
-            }
-        }
-        this._parent.onMeshLoadedObservable.notifyObservers(this._rootBabylonMesh);
-        return rootNode;
-    };
-    /**
-     * Loads a glTF scene.
-     * @param context The context when loading the asset
-     * @param scene The glTF scene property
-     * @returns A promise that resolves when the load is complete
-     */
-    GLTFLoader.prototype.loadSceneAsync = function (context, scene) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadSceneAsync(context, scene);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        var promises = new Array();
-        this.logOpen("".concat(context, " ").concat(scene.name || ""));
-        if (scene.nodes) {
-            for (var _i = 0, _a = scene.nodes; _i < _a.length; _i++) {
-                var index = _a[_i];
-                var node = ArrayItem.Get("".concat(context, "/nodes/").concat(index), this._gltf.nodes, index);
-                promises.push(this.loadNodeAsync("/nodes/".concat(node.index), node, function (babylonMesh) {
-                    babylonMesh.parent = _this._rootBabylonMesh;
-                }));
-            }
-        }
-        for (var _b = 0, _c = this._postSceneLoadActions; _b < _c.length; _b++) {
-            var action = _c[_b];
-            action();
-        }
-        promises.push(this._loadAnimationsAsync());
-        this.logClose();
-        return Promise.all(promises).then(function () { });
-    };
-    GLTFLoader.prototype._forEachPrimitive = function (node, callback) {
-        if (node._primitiveBabylonMeshes) {
-            for (var _i = 0, _a = node._primitiveBabylonMeshes; _i < _a.length; _i++) {
-                var babylonMesh = _a[_i];
-                callback(babylonMesh);
-            }
-        }
-    };
-    GLTFLoader.prototype._getGeometries = function () {
-        var geometries = new Array();
-        var nodes = this._gltf.nodes;
-        if (nodes) {
-            for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
-                var node = nodes_1[_i];
-                this._forEachPrimitive(node, function (babylonMesh) {
-                    var geometry = babylonMesh.geometry;
-                    if (geometry && geometries.indexOf(geometry) === -1) {
-                        geometries.push(geometry);
-                    }
-                });
-            }
-        }
-        return geometries;
-    };
-    GLTFLoader.prototype._getMeshes = function () {
-        var meshes = new Array();
-        // Root mesh is always first, if available.
-        if (this._rootBabylonMesh) {
-            meshes.push(this._rootBabylonMesh);
-        }
-        var nodes = this._gltf.nodes;
-        if (nodes) {
-            for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
-                var node = nodes_2[_i];
-                this._forEachPrimitive(node, function (babylonMesh) {
-                    meshes.push(babylonMesh);
-                });
-            }
-        }
-        return meshes;
-    };
-    GLTFLoader.prototype._getTransformNodes = function () {
-        var transformNodes = new Array();
-        var nodes = this._gltf.nodes;
-        if (nodes) {
-            for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
-                var node = nodes_3[_i];
-                if (node._babylonTransformNode && node._babylonTransformNode.getClassName() === "TransformNode") {
-                    transformNodes.push(node._babylonTransformNode);
-                }
-                if (node._babylonTransformNodeForSkin) {
-                    transformNodes.push(node._babylonTransformNodeForSkin);
-                }
-            }
-        }
-        return transformNodes;
-    };
-    GLTFLoader.prototype._getSkeletons = function () {
-        var skeletons = new Array();
-        var skins = this._gltf.skins;
-        if (skins) {
-            for (var _i = 0, skins_1 = skins; _i < skins_1.length; _i++) {
-                var skin = skins_1[_i];
-                if (skin._data) {
-                    skeletons.push(skin._data.babylonSkeleton);
-                }
-            }
-        }
-        return skeletons;
-    };
-    GLTFLoader.prototype._getAnimationGroups = function () {
-        var animationGroups = new Array();
-        var animations = this._gltf.animations;
-        if (animations) {
-            for (var _i = 0, animations_1 = animations; _i < animations_1.length; _i++) {
-                var animation = animations_1[_i];
-                if (animation._babylonAnimationGroup) {
-                    animationGroups.push(animation._babylonAnimationGroup);
-                }
-            }
-        }
-        return animationGroups;
-    };
-    GLTFLoader.prototype._startAnimations = function () {
-        switch (this._parent.animationStartMode) {
-            case GLTFLoaderAnimationStartMode.NONE: {
-                // do nothing
-                break;
-            }
-            case GLTFLoaderAnimationStartMode.FIRST: {
-                var babylonAnimationGroups = this._getAnimationGroups();
-                if (babylonAnimationGroups.length !== 0) {
-                    babylonAnimationGroups[0].start(true);
-                }
-                break;
-            }
-            case GLTFLoaderAnimationStartMode.ALL: {
-                var babylonAnimationGroups = this._getAnimationGroups();
-                for (var _i = 0, babylonAnimationGroups_1 = babylonAnimationGroups; _i < babylonAnimationGroups_1.length; _i++) {
-                    var babylonAnimationGroup = babylonAnimationGroups_1[_i];
-                    babylonAnimationGroup.start(true);
-                }
-                break;
-            }
-            default: {
-                Logger.Error("Invalid animation start mode (".concat(this._parent.animationStartMode, ")"));
-                return;
-            }
-        }
-    };
-    /**
-     * Loads a glTF node.
-     * @param context The context when loading the asset
-     * @param node The glTF node property
-     * @param assign A function called synchronously after parsing the glTF properties
-     * @returns A promise that resolves with the loaded Babylon mesh when the load is complete
-     */
-    GLTFLoader.prototype.loadNodeAsync = function (context, node, assign) {
-        var _this = this;
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadNodeAsync(context, node, assign);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        if (node._babylonTransformNode) {
-            throw new Error("".concat(context, ": Invalid recursive node hierarchy"));
-        }
-        var promises = new Array();
-        this.logOpen("".concat(context, " ").concat(node.name || ""));
-        var loadNode = function (babylonTransformNode) {
-            GLTFLoader.AddPointerMetadata(babylonTransformNode, context);
-            GLTFLoader._LoadTransform(node, babylonTransformNode);
-            if (node.camera != undefined) {
-                var camera = ArrayItem.Get("".concat(context, "/camera"), _this._gltf.cameras, node.camera);
-                promises.push(_this.loadCameraAsync("/cameras/".concat(camera.index), camera, function (babylonCamera) {
-                    babylonCamera.parent = babylonTransformNode;
-                }));
-            }
-            if (node.children) {
-                for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
-                    var index = _a[_i];
-                    var childNode = ArrayItem.Get("".concat(context, "/children/").concat(index), _this._gltf.nodes, index);
-                    promises.push(_this.loadNodeAsync("/nodes/".concat(childNode.index), childNode, function (childBabylonMesh) {
-                        childBabylonMesh.parent = babylonTransformNode;
-                    }));
-                }
-            }
-            assign(babylonTransformNode);
-        };
-        if (node.mesh == undefined || node.skin != undefined) {
-            var nodeName = node.name || "node".concat(node.index);
-            this._babylonScene._blockEntityCollection = !!this._assetContainer;
-            var transformNode = new TransformNode(nodeName, this._babylonScene);
-            transformNode._parentContainer = this._assetContainer;
-            this._babylonScene._blockEntityCollection = false;
-            if (node.mesh == undefined) {
-                node._babylonTransformNode = transformNode;
-            }
-            else {
-                node._babylonTransformNodeForSkin = transformNode;
-            }
-            loadNode(transformNode);
-        }
-        if (node.mesh != undefined) {
-            if (node.skin == undefined) {
-                var mesh = ArrayItem.Get("".concat(context, "/mesh"), this._gltf.meshes, node.mesh);
-                promises.push(this._loadMeshAsync("/meshes/".concat(mesh.index), node, mesh, loadNode));
-            }
-            else {
-                // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
-                // This code path will place the skinned mesh as a sibling of the skeleton root node without loading the
-                // transform, which effectively ignores the transform of the skinned mesh, as per spec.
-                var mesh = ArrayItem.Get("".concat(context, "/mesh"), this._gltf.meshes, node.mesh);
-                promises.push(this._loadMeshAsync("/meshes/".concat(mesh.index), node, mesh, function (babylonTransformNode) {
-                    // Duplicate the metadata from the skin node to the skinned mesh in case any loader extension added metadata.
-                    babylonTransformNode.metadata = node._babylonTransformNodeForSkin.metadata;
-                    var skin = ArrayItem.Get("".concat(context, "/skin"), _this._gltf.skins, node.skin);
-                    promises.push(_this._loadSkinAsync("/skins/".concat(skin.index), node, skin, function (babylonSkeleton) {
-                        _this._forEachPrimitive(node, function (babylonMesh) {
-                            babylonMesh.skeleton = babylonSkeleton;
-                        });
-                        // Wait until the scene is loaded to ensure the skeleton root node has been loaded.
-                        _this._postSceneLoadActions.push(function () {
-                            if (skin.skeleton != undefined) {
-                                // Place the skinned mesh node as a sibling of the skeleton root node.
-                                var skeletonRootNode = ArrayItem.Get("/skins/".concat(skin.index, "/skeleton"), _this._gltf.nodes, skin.skeleton);
-                                babylonTransformNode.parent = skeletonRootNode.parent._babylonTransformNode;
-                            }
-                            else {
-                                babylonTransformNode.parent = _this._rootBabylonMesh;
-                            }
-                        });
-                    }));
-                }));
-            }
-        }
-        this.logClose();
-        return Promise.all(promises).then(function () {
-            _this._forEachPrimitive(node, function (babylonMesh) {
-                if (babylonMesh.geometry && babylonMesh.geometry.useBoundingInfoFromGeometry) {
-                    // simply apply the world matrices to the bounding info - the extends are already ok
-                    babylonMesh._updateBoundingInfo();
-                }
-                else {
-                    babylonMesh.refreshBoundingInfo(true);
-                }
-            });
-            return node._babylonTransformNode;
-        });
-    };
-    GLTFLoader.prototype._loadMeshAsync = function (context, node, mesh, assign) {
-        var primitives = mesh.primitives;
-        if (!primitives || !primitives.length) {
-            throw new Error("".concat(context, ": Primitives are missing"));
-        }
-        if (primitives[0].index == undefined) {
-            ArrayItem.Assign(primitives);
-        }
-        var promises = new Array();
-        this.logOpen("".concat(context, " ").concat(mesh.name || ""));
-        var name = node.name || "node".concat(node.index);
-        if (primitives.length === 1) {
-            var primitive = mesh.primitives[0];
-            promises.push(this._loadMeshPrimitiveAsync("".concat(context, "/primitives/").concat(primitive.index), name, node, mesh, primitive, function (babylonMesh) {
-                node._babylonTransformNode = babylonMesh;
-                node._primitiveBabylonMeshes = [babylonMesh];
-            }));
-        }
-        else {
-            this._babylonScene._blockEntityCollection = !!this._assetContainer;
-            node._babylonTransformNode = new TransformNode(name, this._babylonScene);
-            node._babylonTransformNode._parentContainer = this._assetContainer;
-            this._babylonScene._blockEntityCollection = false;
-            node._primitiveBabylonMeshes = [];
-            for (var _i = 0, primitives_1 = primitives; _i < primitives_1.length; _i++) {
-                var primitive = primitives_1[_i];
-                promises.push(this._loadMeshPrimitiveAsync("".concat(context, "/primitives/").concat(primitive.index), "".concat(name, "_primitive").concat(primitive.index), node, mesh, primitive, function (babylonMesh) {
-                    babylonMesh.parent = node._babylonTransformNode;
-                    node._primitiveBabylonMeshes.push(babylonMesh);
-                }));
-            }
-        }
-        assign(node._babylonTransformNode);
-        this.logClose();
-        return Promise.all(promises).then(function () {
-            return node._babylonTransformNode;
-        });
-    };
-    /**
-     * @hidden Define this method to modify the default behavior when loading data for mesh primitives.
-     * @param context The context when loading the asset
-     * @param name The mesh name when loading the asset
-     * @param node The glTF node when loading the asset
-     * @param mesh The glTF mesh when loading the asset
-     * @param primitive The glTF mesh primitive property
-     * @param assign A function called synchronously after parsing the glTF properties
-     * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled
-     */
-    GLTFLoader.prototype._loadMeshPrimitiveAsync = function (context, name, node, mesh, primitive, assign) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        this.logOpen("".concat(context));
-        var shouldInstance = this._disableInstancedMesh === 0 && this._parent.createInstances && node.skin == undefined && !mesh.primitives[0].targets;
-        var babylonAbstractMesh;
-        var promise;
-        if (shouldInstance && primitive._instanceData) {
-            this._babylonScene._blockEntityCollection = !!this._assetContainer;
-            babylonAbstractMesh = primitive._instanceData.babylonSourceMesh.createInstance(name);
-            babylonAbstractMesh._parentContainer = this._assetContainer;
-            this._babylonScene._blockEntityCollection = false;
-            promise = primitive._instanceData.promise;
-        }
-        else {
-            var promises = new Array();
-            this._babylonScene._blockEntityCollection = !!this._assetContainer;
-            var babylonMesh_1 = new Mesh(name, this._babylonScene);
-            babylonMesh_1._parentContainer = this._assetContainer;
-            this._babylonScene._blockEntityCollection = false;
-            babylonMesh_1.overrideMaterialSideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
-            this._createMorphTargets(context, node, mesh, primitive, babylonMesh_1);
-            promises.push(this._loadVertexDataAsync(context, primitive, babylonMesh_1).then(function (babylonGeometry) {
-                return _this._loadMorphTargetsAsync(context, primitive, babylonMesh_1, babylonGeometry).then(function () {
-                    _this._babylonScene._blockEntityCollection = !!_this._assetContainer;
-                    babylonGeometry.applyToMesh(babylonMesh_1);
-                    babylonGeometry._parentContainer = _this._assetContainer;
-                    _this._babylonScene._blockEntityCollection = false;
-                });
-            }));
-            var babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);
-            if (primitive.material == undefined) {
-                var babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];
-                if (!babylonMaterial) {
-                    babylonMaterial = this._createDefaultMaterial("__GLTFLoader._default", babylonDrawMode);
-                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
-                    this._defaultBabylonMaterialData[babylonDrawMode] = babylonMaterial;
-                }
-                babylonMesh_1.material = babylonMaterial;
-            }
-            else if (!this.parent.skipMaterials) {
-                var material = ArrayItem.Get("".concat(context, "/material"), this._gltf.materials, primitive.material);
-                promises.push(this._loadMaterialAsync("/materials/".concat(material.index), material, babylonMesh_1, babylonDrawMode, function (babylonMaterial) {
-                    babylonMesh_1.material = babylonMaterial;
-                }));
-            }
-            promise = Promise.all(promises);
-            if (shouldInstance) {
-                primitive._instanceData = {
-                    babylonSourceMesh: babylonMesh_1,
-                    promise: promise,
-                };
-            }
-            babylonAbstractMesh = babylonMesh_1;
-        }
-        GLTFLoader.AddPointerMetadata(babylonAbstractMesh, context);
-        this._parent.onMeshLoadedObservable.notifyObservers(babylonAbstractMesh);
-        assign(babylonAbstractMesh);
-        this.logClose();
-        return promise.then(function () {
-            return babylonAbstractMesh;
-        });
-    };
-    GLTFLoader.prototype._loadVertexDataAsync = function (context, primitive, babylonMesh) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadVertexDataAsync(context, primitive, babylonMesh);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        var attributes = primitive.attributes;
-        if (!attributes) {
-            throw new Error("".concat(context, ": Attributes are missing"));
-        }
-        var promises = new Array();
-        var babylonGeometry = new Geometry(babylonMesh.name, this._babylonScene);
-        if (primitive.indices == undefined) {
-            babylonMesh.isUnIndexed = true;
-        }
-        else {
-            var accessor = ArrayItem.Get("".concat(context, "/indices"), this._gltf.accessors, primitive.indices);
-            promises.push(this._loadIndicesAccessorAsync("/accessors/".concat(accessor.index), accessor).then(function (data) {
-                babylonGeometry.setIndices(data);
-            }));
-        }
-        var loadAttribute = function (attribute, kind, callback) {
-            if (attributes[attribute] == undefined) {
-                return;
-            }
-            babylonMesh._delayInfo = babylonMesh._delayInfo || [];
-            if (babylonMesh._delayInfo.indexOf(kind) === -1) {
-                babylonMesh._delayInfo.push(kind);
-            }
-            var accessor = ArrayItem.Get("".concat(context, "/attributes/").concat(attribute), _this._gltf.accessors, attributes[attribute]);
-            promises.push(_this._loadVertexAccessorAsync("/accessors/".concat(accessor.index), accessor, kind).then(function (babylonVertexBuffer) {
-                if (babylonVertexBuffer.getKind() === VertexBuffer.PositionKind && !_this.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton) {
-                    var mmin = accessor.min, mmax = accessor.max;
-                    if (mmin !== undefined && mmax !== undefined) {
-                        if (accessor.normalized && accessor.componentType !== 5126 /* FLOAT */) {
-                            var divider = 1;
-                            switch (accessor.componentType) {
-                                case 5120 /* BYTE */:
-                                    divider = 127.0;
-                                    break;
-                                case 5121 /* UNSIGNED_BYTE */:
-                                    divider = 255.0;
-                                    break;
-                                case 5122 /* SHORT */:
-                                    divider = 32767.0;
-                                    break;
-                                case 5123 /* UNSIGNED_SHORT */:
-                                    divider = 65535.0;
-                                    break;
-                            }
-                            for (var i = 0; i < 3; ++i) {
-                                mmin[i] = Math.max(mmin[i] / divider, -1.0);
-                                mmax[i] = Math.max(mmax[i] / divider, -1.0);
-                            }
-                        }
-                        var min = TmpVectors.Vector3[0], max = TmpVectors.Vector3[1];
-                        min.copyFromFloats.apply(min, mmin);
-                        max.copyFromFloats.apply(max, mmax);
-                        babylonGeometry._boundingInfo = new BoundingInfo(min, max);
-                        babylonGeometry.useBoundingInfoFromGeometry = true;
-                    }
-                }
-                babylonGeometry.setVerticesBuffer(babylonVertexBuffer, accessor.count);
-            }));
-            if (kind == VertexBuffer.MatricesIndicesExtraKind) {
-                babylonMesh.numBoneInfluencers = 8;
-            }
-            if (callback) {
-                callback(accessor);
-            }
-        };
-        loadAttribute("POSITION", VertexBuffer.PositionKind);
-        loadAttribute("NORMAL", VertexBuffer.NormalKind);
-        loadAttribute("TANGENT", VertexBuffer.TangentKind);
-        loadAttribute("TEXCOORD_0", VertexBuffer.UVKind);
-        loadAttribute("TEXCOORD_1", VertexBuffer.UV2Kind);
-        loadAttribute("TEXCOORD_2", VertexBuffer.UV3Kind);
-        loadAttribute("TEXCOORD_3", VertexBuffer.UV4Kind);
-        loadAttribute("TEXCOORD_4", VertexBuffer.UV5Kind);
-        loadAttribute("TEXCOORD_5", VertexBuffer.UV6Kind);
-        loadAttribute("JOINTS_0", VertexBuffer.MatricesIndicesKind);
-        loadAttribute("WEIGHTS_0", VertexBuffer.MatricesWeightsKind);
-        loadAttribute("JOINTS_1", VertexBuffer.MatricesIndicesExtraKind);
-        loadAttribute("WEIGHTS_1", VertexBuffer.MatricesWeightsExtraKind);
-        loadAttribute("COLOR_0", VertexBuffer.ColorKind, function (accessor) {
-            if (accessor.type === "VEC4" /* VEC4 */) {
-                babylonMesh.hasVertexAlpha = true;
-            }
-        });
-        return Promise.all(promises).then(function () {
-            return babylonGeometry;
-        });
-    };
-    GLTFLoader.prototype._createMorphTargets = function (context, node, mesh, primitive, babylonMesh) {
-        if (!primitive.targets) {
-            return;
-        }
-        if (node._numMorphTargets == undefined) {
-            node._numMorphTargets = primitive.targets.length;
-        }
-        else if (primitive.targets.length !== node._numMorphTargets) {
-            throw new Error("".concat(context, ": Primitives do not have the same number of targets"));
-        }
-        var targetNames = mesh.extras ? mesh.extras.targetNames : null;
-        babylonMesh.morphTargetManager = new MorphTargetManager(babylonMesh.getScene());
-        babylonMesh.morphTargetManager.areUpdatesFrozen = true;
-        for (var index = 0; index < primitive.targets.length; index++) {
-            var weight = node.weights ? node.weights[index] : mesh.weights ? mesh.weights[index] : 0;
-            var name_3 = targetNames ? targetNames[index] : "morphTarget".concat(index);
-            babylonMesh.morphTargetManager.addTarget(new MorphTarget(name_3, weight, babylonMesh.getScene()));
-            // TODO: tell the target whether it has positions, normals, tangents
-        }
-    };
-    GLTFLoader.prototype._loadMorphTargetsAsync = function (context, primitive, babylonMesh, babylonGeometry) {
-        if (!primitive.targets) {
-            return Promise.resolve();
-        }
-        var promises = new Array();
-        var morphTargetManager = babylonMesh.morphTargetManager;
-        for (var index = 0; index < morphTargetManager.numTargets; index++) {
-            var babylonMorphTarget = morphTargetManager.getTarget(index);
-            promises.push(this._loadMorphTargetVertexDataAsync("".concat(context, "/targets/").concat(index), babylonGeometry, primitive.targets[index], babylonMorphTarget));
-        }
-        return Promise.all(promises).then(function () {
-            morphTargetManager.areUpdatesFrozen = false;
-        });
-    };
-    GLTFLoader.prototype._loadMorphTargetVertexDataAsync = function (context, babylonGeometry, attributes, babylonMorphTarget) {
-        var _this = this;
-        var promises = new Array();
-        var loadAttribute = function (attribute, kind, setData) {
-            if (attributes[attribute] == undefined) {
-                return;
-            }
-            var babylonVertexBuffer = babylonGeometry.getVertexBuffer(kind);
-            if (!babylonVertexBuffer) {
-                return;
-            }
-            var accessor = ArrayItem.Get("".concat(context, "/").concat(attribute), _this._gltf.accessors, attributes[attribute]);
-            promises.push(_this._loadFloatAccessorAsync("/accessors/".concat(accessor.index), accessor).then(function (data) {
-                setData(babylonVertexBuffer, data);
-            }));
-        };
-        loadAttribute("POSITION", VertexBuffer.PositionKind, function (babylonVertexBuffer, data) {
-            var positions = new Float32Array(data.length);
-            babylonVertexBuffer.forEach(data.length, function (value, index) {
-                positions[index] = data[index] + value;
-            });
-            babylonMorphTarget.setPositions(positions);
-        });
-        loadAttribute("NORMAL", VertexBuffer.NormalKind, function (babylonVertexBuffer, data) {
-            var normals = new Float32Array(data.length);
-            babylonVertexBuffer.forEach(normals.length, function (value, index) {
-                normals[index] = data[index] + value;
-            });
-            babylonMorphTarget.setNormals(normals);
-        });
-        loadAttribute("TANGENT", VertexBuffer.TangentKind, function (babylonVertexBuffer, data) {
-            var tangents = new Float32Array((data.length / 3) * 4);
-            var dataIndex = 0;
-            babylonVertexBuffer.forEach((data.length / 3) * 4, function (value, index) {
-                // Tangent data for morph targets is stored as xyz delta.
-                // The vertexData.tangent is stored as xyzw.
-                // So we need to skip every fourth vertexData.tangent.
-                if ((index + 1) % 4 !== 0) {
-                    tangents[dataIndex] = data[dataIndex] + value;
-                    dataIndex++;
-                }
-            });
-            babylonMorphTarget.setTangents(tangents);
-        });
-        return Promise.all(promises).then(function () { });
-    };
-    GLTFLoader._LoadTransform = function (node, babylonNode) {
-        // Ignore the TRS of skinned nodes.
-        // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
-        if (node.skin != undefined) {
-            return;
-        }
-        var position = Vector3.Zero();
-        var rotation = Quaternion.Identity();
-        var scaling = Vector3.One();
-        if (node.matrix) {
-            var matrix = Matrix.FromArray(node.matrix);
-            matrix.decompose(scaling, rotation, position);
-        }
-        else {
-            if (node.translation) {
-                position = Vector3.FromArray(node.translation);
-            }
-            if (node.rotation) {
-                rotation = Quaternion.FromArray(node.rotation);
-            }
-            if (node.scale) {
-                scaling = Vector3.FromArray(node.scale);
-            }
-        }
-        babylonNode.position = position;
-        babylonNode.rotationQuaternion = rotation;
-        babylonNode.scaling = scaling;
-    };
-    GLTFLoader.prototype._loadSkinAsync = function (context, node, skin, assign) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadSkinAsync(context, node, skin);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        if (skin._data) {
-            assign(skin._data.babylonSkeleton);
-            return skin._data.promise;
-        }
-        var skeletonId = "skeleton".concat(skin.index);
-        this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var babylonSkeleton = new Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);
-        babylonSkeleton._parentContainer = this._assetContainer;
-        this._babylonScene._blockEntityCollection = false;
-        this._loadBones(context, skin, babylonSkeleton);
-        var promise = this._loadSkinInverseBindMatricesDataAsync(context, skin).then(function (inverseBindMatricesData) {
-            _this._updateBoneMatrices(babylonSkeleton, inverseBindMatricesData);
-        });
-        skin._data = {
-            babylonSkeleton: babylonSkeleton,
-            promise: promise,
-        };
-        assign(babylonSkeleton);
-        return promise;
-    };
-    GLTFLoader.prototype._loadBones = function (context, skin, babylonSkeleton) {
-        if (skin.skeleton == undefined || this._parent.alwaysComputeSkeletonRootNode) {
-            var rootNode = this._findSkeletonRootNode("".concat(context, "/joints"), skin.joints);
-            if (rootNode) {
-                if (skin.skeleton === undefined) {
-                    skin.skeleton = rootNode.index;
-                }
-                else {
-                    var isParent = function (a, b) {
-                        for (; b.parent; b = b.parent) {
-                            if (b.parent === a) {
-                                return true;
-                            }
-                        }
-                        return false;
-                    };
-                    var skeletonNode = ArrayItem.Get("".concat(context, "/skeleton"), this._gltf.nodes, skin.skeleton);
-                    if (skeletonNode !== rootNode && !isParent(skeletonNode, rootNode)) {
-                        Logger.Warn("".concat(context, "/skeleton: Overriding with nearest common ancestor as skeleton node is not a common root"));
-                        skin.skeleton = rootNode.index;
-                    }
-                }
-            }
-            else {
-                Logger.Warn("".concat(context, ": Failed to find common root"));
-            }
-        }
-        var babylonBones = {};
-        for (var _i = 0, _a = skin.joints; _i < _a.length; _i++) {
-            var index = _a[_i];
-            var node = ArrayItem.Get("".concat(context, "/joints/").concat(index), this._gltf.nodes, index);
-            this._loadBone(node, skin, babylonSkeleton, babylonBones);
-        }
-    };
-    GLTFLoader.prototype._findSkeletonRootNode = function (context, joints) {
-        if (joints.length === 0) {
-            return null;
-        }
-        var paths = {};
-        for (var _i = 0, joints_1 = joints; _i < joints_1.length; _i++) {
-            var index = joints_1[_i];
-            var path = new Array();
-            var node = ArrayItem.Get("".concat(context, "/").concat(index), this._gltf.nodes, index);
-            while (node.index !== -1) {
-                path.unshift(node);
-                node = node.parent;
-            }
-            paths[index] = path;
-        }
-        var rootNode = null;
-        for (var i = 0;; ++i) {
-            var path = paths[joints[0]];
-            if (i >= path.length) {
-                return rootNode;
-            }
-            var node = path[i];
-            for (var j = 1; j < joints.length; ++j) {
-                path = paths[joints[j]];
-                if (i >= path.length || node !== path[i]) {
-                    return rootNode;
-                }
-            }
-            rootNode = node;
-        }
-    };
-    GLTFLoader.prototype._loadBone = function (node, skin, babylonSkeleton, babylonBones) {
-        var babylonBone = babylonBones[node.index];
-        if (babylonBone) {
-            return babylonBone;
-        }
-        var parentBabylonBone = null;
-        if (node.index !== skin.skeleton) {
-            if (node.parent && node.parent.index !== -1) {
-                parentBabylonBone = this._loadBone(node.parent, skin, babylonSkeleton, babylonBones);
-            }
-            else if (skin.skeleton !== undefined) {
-                Logger.Warn("/skins/".concat(skin.index, "/skeleton: Skeleton node is not a common root"));
-            }
-        }
-        var boneIndex = skin.joints.indexOf(node.index);
-        babylonBone = new Bone(node.name || "joint".concat(node.index), babylonSkeleton, parentBabylonBone, this._getNodeMatrix(node), null, null, boneIndex);
-        babylonBones[node.index] = babylonBone;
-        // Wait until the scene is loaded to ensure the transform nodes are loaded.
-        this._postSceneLoadActions.push(function () {
-            // Link the Babylon bone with the corresponding Babylon transform node.
-            // A glTF joint is a pointer to a glTF node in the glTF node hierarchy similar to Unity3D.
-            babylonBone.linkTransformNode(node._babylonTransformNode);
-        });
-        return babylonBone;
-    };
-    GLTFLoader.prototype._loadSkinInverseBindMatricesDataAsync = function (context, skin) {
-        if (skin.inverseBindMatrices == undefined) {
-            return Promise.resolve(null);
-        }
-        var accessor = ArrayItem.Get("".concat(context, "/inverseBindMatrices"), this._gltf.accessors, skin.inverseBindMatrices);
-        return this._loadFloatAccessorAsync("/accessors/".concat(accessor.index), accessor);
-    };
-    GLTFLoader.prototype._updateBoneMatrices = function (babylonSkeleton, inverseBindMatricesData) {
-        for (var _i = 0, _a = babylonSkeleton.bones; _i < _a.length; _i++) {
-            var babylonBone = _a[_i];
-            var baseMatrix = Matrix.Identity();
-            var boneIndex = babylonBone._index;
-            if (inverseBindMatricesData && boneIndex !== -1) {
-                Matrix.FromArrayToRef(inverseBindMatricesData, boneIndex * 16, baseMatrix);
-                baseMatrix.invertToRef(baseMatrix);
-            }
-            var babylonParentBone = babylonBone.getParent();
-            if (babylonParentBone) {
-                baseMatrix.multiplyToRef(babylonParentBone.getInvertedAbsoluteTransform(), baseMatrix);
-            }
-            babylonBone.updateMatrix(baseMatrix, false, false);
-            babylonBone._updateDifferenceMatrix(undefined, false);
-        }
-    };
-    GLTFLoader.prototype._getNodeMatrix = function (node) {
-        return node.matrix
-            ? Matrix.FromArray(node.matrix)
-            : Matrix.Compose(node.scale ? Vector3.FromArray(node.scale) : Vector3.One(), node.rotation ? Quaternion.FromArray(node.rotation) : Quaternion.Identity(), node.translation ? Vector3.FromArray(node.translation) : Vector3.Zero());
-    };
-    /**
-     * Loads a glTF camera.
-     * @param context The context when loading the asset
-     * @param camera The glTF camera property
-     * @param assign A function called synchronously after parsing the glTF properties
-     * @returns A promise that resolves with the loaded Babylon camera when the load is complete
-     */
-    GLTFLoader.prototype.loadCameraAsync = function (context, camera, assign) {
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadCameraAsync(context, camera, assign);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        var promises = new Array();
-        this.logOpen("".concat(context, " ").concat(camera.name || ""));
-        this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var babylonCamera = new FreeCamera(camera.name || "camera".concat(camera.index), Vector3.Zero(), this._babylonScene, false);
-        babylonCamera._parentContainer = this._assetContainer;
-        this._babylonScene._blockEntityCollection = false;
-        babylonCamera.ignoreParentScaling = true;
-        babylonCamera.rotation = new Vector3(0, Math.PI, 0);
-        switch (camera.type) {
-            case "perspective" /* PERSPECTIVE */: {
-                var perspective = camera.perspective;
-                if (!perspective) {
-                    throw new Error("".concat(context, ": Camera perspective properties are missing"));
-                }
-                babylonCamera.fov = perspective.yfov;
-                babylonCamera.minZ = perspective.znear;
-                babylonCamera.maxZ = perspective.zfar || 0;
-                break;
-            }
-            case "orthographic" /* ORTHOGRAPHIC */: {
-                if (!camera.orthographic) {
-                    throw new Error("".concat(context, ": Camera orthographic properties are missing"));
-                }
-                babylonCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;
-                babylonCamera.orthoLeft = -camera.orthographic.xmag;
-                babylonCamera.orthoRight = camera.orthographic.xmag;
-                babylonCamera.orthoBottom = -camera.orthographic.ymag;
-                babylonCamera.orthoTop = camera.orthographic.ymag;
-                babylonCamera.minZ = camera.orthographic.znear;
-                babylonCamera.maxZ = camera.orthographic.zfar;
-                break;
-            }
-            default: {
-                throw new Error("".concat(context, ": Invalid camera type (").concat(camera.type, ")"));
-            }
-        }
-        GLTFLoader.AddPointerMetadata(babylonCamera, context);
-        this._parent.onCameraLoadedObservable.notifyObservers(babylonCamera);
-        assign(babylonCamera);
-        this.logClose();
-        return Promise.all(promises).then(function () {
-            return babylonCamera;
-        });
-    };
-    GLTFLoader.prototype._loadAnimationsAsync = function () {
-        var animations = this._gltf.animations;
-        if (!animations) {
-            return Promise.resolve();
-        }
-        var promises = new Array();
-        for (var index = 0; index < animations.length; index++) {
-            var animation = animations[index];
-            promises.push(this.loadAnimationAsync("/animations/".concat(animation.index), animation).then(function (animationGroup) {
-                // Delete the animation group if it ended up not having any animations in it.
-                if (animationGroup.targetedAnimations.length === 0) {
-                    animationGroup.dispose();
-                }
-            }));
-        }
-        return Promise.all(promises).then(function () { });
-    };
-    /**
-     * Loads a glTF animation.
-     * @param context The context when loading the asset
-     * @param animation The glTF animation property
-     * @returns A promise that resolves with the loaded Babylon animation group when the load is complete
-     */
-    GLTFLoader.prototype.loadAnimationAsync = function (context, animation) {
-        var promise = this._extensionsLoadAnimationAsync(context, animation);
-        if (promise) {
-            return promise;
-        }
-        this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var babylonAnimationGroup = new AnimationGroup(animation.name || "animation".concat(animation.index), this._babylonScene);
-        babylonAnimationGroup._parentContainer = this._assetContainer;
-        this._babylonScene._blockEntityCollection = false;
-        animation._babylonAnimationGroup = babylonAnimationGroup;
-        var promises = new Array();
-        ArrayItem.Assign(animation.channels);
-        ArrayItem.Assign(animation.samplers);
-        for (var _i = 0, _a = animation.channels; _i < _a.length; _i++) {
-            var channel = _a[_i];
-            promises.push(this._loadAnimationChannelAsync("".concat(context, "/channels/").concat(channel.index), context, animation, channel, babylonAnimationGroup));
-        }
-        return Promise.all(promises).then(function () {
-            babylonAnimationGroup.normalize(0);
-            return babylonAnimationGroup;
-        });
-    };
-    /**
-     * @hidden Loads a glTF animation channel.
-     * @param context The context when loading the asset
-     * @param animationContext The context of the animation when loading the asset
-     * @param animation The glTF animation property
-     * @param channel The glTF animation channel property
-     * @param babylonAnimationGroup The babylon animation group property
-     * @param animationTargetOverride The babylon animation channel target override property. My be null.
-     * @returns A void promise when the channel load is complete
-     */
-    GLTFLoader.prototype._loadAnimationChannelAsync = function (context, animationContext, animation, channel, babylonAnimationGroup, animationTargetOverride) {
-        var _this = this;
-        if (animationTargetOverride === void 0) { animationTargetOverride = null; }
-        if (channel.target.node == undefined) {
-            return Promise.resolve();
-        }
-        var targetNode = ArrayItem.Get("".concat(context, "/target/node"), this._gltf.nodes, channel.target.node);
-        // Ignore animations that have no animation targets.
-        if ((channel.target.path === "weights" /* WEIGHTS */ && !targetNode._numMorphTargets) ||
-            (channel.target.path !== "weights" /* WEIGHTS */ && !targetNode._babylonTransformNode)) {
-            return Promise.resolve();
-        }
-        var sampler = ArrayItem.Get("".concat(context, "/sampler"), animation.samplers, channel.sampler);
-        return this._loadAnimationSamplerAsync("".concat(animationContext, "/samplers/").concat(channel.sampler), sampler).then(function (data) {
-            var targetPath;
-            var animationType;
-            switch (channel.target.path) {
-                case "translation" /* TRANSLATION */: {
-                    targetPath = "position";
-                    animationType = Animation.ANIMATIONTYPE_VECTOR3;
-                    break;
-                }
-                case "rotation" /* ROTATION */: {
-                    targetPath = "rotationQuaternion";
-                    animationType = Animation.ANIMATIONTYPE_QUATERNION;
-                    break;
-                }
-                case "scale" /* SCALE */: {
-                    targetPath = "scaling";
-                    animationType = Animation.ANIMATIONTYPE_VECTOR3;
-                    break;
-                }
-                case "weights" /* WEIGHTS */: {
-                    targetPath = "influence";
-                    animationType = Animation.ANIMATIONTYPE_FLOAT;
-                    break;
-                }
-                default: {
-                    throw new Error("".concat(context, "/target/path: Invalid value (").concat(channel.target.path, ")"));
-                }
-            }
-            var outputBufferOffset = 0;
-            var getNextOutputValue;
-            switch (targetPath) {
-                case "position": {
-                    getNextOutputValue = function (scale) {
-                        var value = Vector3.FromArray(data.output, outputBufferOffset).scaleInPlace(scale);
-                        outputBufferOffset += 3;
-                        return value;
-                    };
-                    break;
-                }
-                case "rotationQuaternion": {
-                    getNextOutputValue = function (scale) {
-                        var value = Quaternion.FromArray(data.output, outputBufferOffset).scaleInPlace(scale);
-                        outputBufferOffset += 4;
-                        return value;
-                    };
-                    break;
-                }
-                case "scaling": {
-                    getNextOutputValue = function (scale) {
-                        var value = Vector3.FromArray(data.output, outputBufferOffset).scaleInPlace(scale);
-                        outputBufferOffset += 3;
-                        return value;
-                    };
-                    break;
-                }
-                case "influence": {
-                    getNextOutputValue = function (scale) {
-                        var value = new Array(targetNode._numMorphTargets);
-                        for (var i = 0; i < targetNode._numMorphTargets; i++) {
-                            value[i] = data.output[outputBufferOffset++] * scale;
-                        }
-                        return value;
-                    };
-                    break;
-                }
-            }
-            var getNextKey;
-            switch (data.interpolation) {
-                case "STEP" /* STEP */: {
-                    getNextKey = function (frameIndex) { return ({
-                        frame: data.input[frameIndex] * _this.parent.targetFps,
-                        value: getNextOutputValue(1),
-                        interpolation: AnimationKeyInterpolation.STEP,
-                    }); };
-                    break;
-                }
-                case "LINEAR" /* LINEAR */: {
-                    getNextKey = function (frameIndex) { return ({
-                        frame: data.input[frameIndex] * _this.parent.targetFps,
-                        value: getNextOutputValue(1),
-                    }); };
-                    break;
-                }
-                case "CUBICSPLINE" /* CUBICSPLINE */: {
-                    var invTargetFps_1 = 1 / _this.parent.targetFps;
-                    getNextKey = function (frameIndex) { return ({
-                        frame: data.input[frameIndex] * _this.parent.targetFps,
-                        inTangent: getNextOutputValue(invTargetFps_1),
-                        value: getNextOutputValue(1),
-                        outTangent: getNextOutputValue(invTargetFps_1),
-                    }); };
-                    break;
-                }
-            }
-            var keys = new Array(data.input.length);
-            for (var frameIndex = 0; frameIndex < data.input.length; frameIndex++) {
-                keys[frameIndex] = getNextKey(frameIndex);
-            }
-            if (targetPath === "influence") {
-                var _loop_2 = function (targetIndex) {
-                    var animationName = "".concat(babylonAnimationGroup.name, "_channel").concat(babylonAnimationGroup.targetedAnimations.length);
-                    var babylonAnimation = new Animation(animationName, targetPath, _this.parent.targetFps, animationType);
-                    babylonAnimation.setKeys(keys.map(function (key) { return ({
-                        frame: key.frame,
-                        inTangent: key.inTangent ? key.inTangent[targetIndex] : undefined,
-                        value: key.value[targetIndex],
-                        outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined,
-                    }); }));
-                    _this._forEachPrimitive(targetNode, function (babylonAbstractMesh) {
-                        var babylonMesh = babylonAbstractMesh;
-                        var morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);
-                        var babylonAnimationClone = babylonAnimation.clone();
-                        morphTarget.animations.push(babylonAnimationClone);
-                        babylonAnimationGroup.addTargetedAnimation(babylonAnimationClone, morphTarget);
-                    });
-                };
-                for (var targetIndex = 0; targetIndex < targetNode._numMorphTargets; targetIndex++) {
-                    _loop_2(targetIndex);
-                }
-            }
-            else {
-                var animationName = "".concat(babylonAnimationGroup.name, "_channel").concat(babylonAnimationGroup.targetedAnimations.length);
-                var babylonAnimation = new Animation(animationName, targetPath, _this.parent.targetFps, animationType);
-                babylonAnimation.setKeys(keys);
-                if (animationTargetOverride != null && animationTargetOverride.animations != null) {
-                    animationTargetOverride.animations.push(babylonAnimation);
-                    babylonAnimationGroup.addTargetedAnimation(babylonAnimation, animationTargetOverride);
-                }
-                else {
-                    targetNode._babylonTransformNode.animations.push(babylonAnimation);
-                    babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonTransformNode);
-                }
-            }
-        });
-    };
-    GLTFLoader.prototype._loadAnimationSamplerAsync = function (context, sampler) {
-        if (sampler._data) {
-            return sampler._data;
-        }
-        var interpolation = sampler.interpolation || "LINEAR" /* LINEAR */;
-        switch (interpolation) {
-            case "STEP" /* STEP */:
-            case "LINEAR" /* LINEAR */:
-            case "CUBICSPLINE" /* CUBICSPLINE */: {
-                break;
-            }
-            default: {
-                throw new Error("".concat(context, "/interpolation: Invalid value (").concat(sampler.interpolation, ")"));
-            }
-        }
-        var inputAccessor = ArrayItem.Get("".concat(context, "/input"), this._gltf.accessors, sampler.input);
-        var outputAccessor = ArrayItem.Get("".concat(context, "/output"), this._gltf.accessors, sampler.output);
-        sampler._data = Promise.all([
-            this._loadFloatAccessorAsync("/accessors/".concat(inputAccessor.index), inputAccessor),
-            this._loadFloatAccessorAsync("/accessors/".concat(outputAccessor.index), outputAccessor),
-        ]).then(function (_a) {
-            var inputData = _a[0], outputData = _a[1];
-            return {
-                input: inputData,
-                interpolation: interpolation,
-                output: outputData,
-            };
-        });
-        return sampler._data;
-    };
-    /**
-     * Loads a glTF buffer.
-     * @param context The context when loading the asset
-     * @param buffer The glTF buffer property
-     * @param byteOffset The byte offset to use
-     * @param byteLength The byte length to use
-     * @returns A promise that resolves with the loaded data when the load is complete
-     */
-    GLTFLoader.prototype.loadBufferAsync = function (context, buffer, byteOffset, byteLength) {
-        var extensionPromise = this._extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        if (!buffer._data) {
-            if (buffer.uri) {
-                buffer._data = this.loadUriAsync("".concat(context, "/uri"), buffer, buffer.uri);
-            }
-            else {
-                if (!this._bin) {
-                    throw new Error("".concat(context, ": Uri is missing or the binary glTF is missing its binary chunk"));
-                }
-                buffer._data = this._bin.readAsync(0, buffer.byteLength);
-            }
-        }
-        return buffer._data.then(function (data) {
-            try {
-                return new Uint8Array(data.buffer, data.byteOffset + byteOffset, byteLength);
-            }
-            catch (e) {
-                throw new Error("".concat(context, ": ").concat(e.message));
-            }
-        });
-    };
-    /**
-     * Loads a glTF buffer view.
-     * @param context The context when loading the asset
-     * @param bufferView The glTF buffer view property
-     * @returns A promise that resolves with the loaded data when the load is complete
-     */
-    GLTFLoader.prototype.loadBufferViewAsync = function (context, bufferView) {
-        var extensionPromise = this._extensionsLoadBufferViewAsync(context, bufferView);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        if (bufferView._data) {
-            return bufferView._data;
-        }
-        var buffer = ArrayItem.Get("".concat(context, "/buffer"), this._gltf.buffers, bufferView.buffer);
-        bufferView._data = this.loadBufferAsync("/buffers/".concat(buffer.index), buffer, bufferView.byteOffset || 0, bufferView.byteLength);
-        return bufferView._data;
-    };
-    GLTFLoader.prototype._loadAccessorAsync = function (context, accessor, constructor) {
-        var _this = this;
-        if (accessor._data) {
-            return accessor._data;
-        }
-        var numComponents = GLTFLoader._GetNumComponents(context, accessor.type);
-        var byteStride = numComponents * VertexBuffer.GetTypeByteLength(accessor.componentType);
-        var length = numComponents * accessor.count;
-        if (accessor.bufferView == undefined) {
-            accessor._data = Promise.resolve(new constructor(length));
-        }
-        else {
-            var bufferView_1 = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, accessor.bufferView);
-            accessor._data = this.loadBufferViewAsync("/bufferViews/".concat(bufferView_1.index), bufferView_1).then(function (data) {
-                if (accessor.componentType === 5126 /* FLOAT */ && !accessor.normalized && (!bufferView_1.byteStride || bufferView_1.byteStride === byteStride)) {
-                    return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, length);
-                }
-                else {
-                    var typedArray_1 = new constructor(length);
-                    VertexBuffer.ForEach(data, accessor.byteOffset || 0, bufferView_1.byteStride || byteStride, numComponents, accessor.componentType, typedArray_1.length, accessor.normalized || false, function (value, index) {
-                        typedArray_1[index] = value;
-                    });
-                    return typedArray_1;
-                }
-            });
-        }
-        if (accessor.sparse) {
-            var sparse_1 = accessor.sparse;
-            accessor._data = accessor._data.then(function (data) {
-                var typedArray = data;
-                var indicesBufferView = ArrayItem.Get("".concat(context, "/sparse/indices/bufferView"), _this._gltf.bufferViews, sparse_1.indices.bufferView);
-                var valuesBufferView = ArrayItem.Get("".concat(context, "/sparse/values/bufferView"), _this._gltf.bufferViews, sparse_1.values.bufferView);
-                return Promise.all([
-                    _this.loadBufferViewAsync("/bufferViews/".concat(indicesBufferView.index), indicesBufferView),
-                    _this.loadBufferViewAsync("/bufferViews/".concat(valuesBufferView.index), valuesBufferView),
-                ]).then(function (_a) {
-                    var indicesData = _a[0], valuesData = _a[1];
-                    var indices = GLTFLoader._GetTypedArray("".concat(context, "/sparse/indices"), sparse_1.indices.componentType, indicesData, sparse_1.indices.byteOffset, sparse_1.count);
-                    var sparseLength = numComponents * sparse_1.count;
-                    var values;
-                    if (accessor.componentType === 5126 /* FLOAT */ && !accessor.normalized) {
-                        values = GLTFLoader._GetTypedArray("".concat(context, "/sparse/values"), accessor.componentType, valuesData, sparse_1.values.byteOffset, sparseLength);
-                    }
-                    else {
-                        var sparseData = GLTFLoader._GetTypedArray("".concat(context, "/sparse/values"), accessor.componentType, valuesData, sparse_1.values.byteOffset, sparseLength);
-                        values = new constructor(sparseLength);
-                        VertexBuffer.ForEach(sparseData, 0, byteStride, numComponents, accessor.componentType, values.length, accessor.normalized || false, function (value, index) {
-                            values[index] = value;
-                        });
-                    }
-                    var valuesIndex = 0;
-                    for (var indicesIndex = 0; indicesIndex < indices.length; indicesIndex++) {
-                        var dataIndex = indices[indicesIndex] * numComponents;
-                        for (var componentIndex = 0; componentIndex < numComponents; componentIndex++) {
-                            typedArray[dataIndex++] = values[valuesIndex++];
-                        }
-                    }
-                    return typedArray;
-                });
-            });
-        }
-        return accessor._data;
-    };
-    /**
-     * @param context
-     * @param accessor
-     * @hidden
-     */
-    GLTFLoader.prototype._loadFloatAccessorAsync = function (context, accessor) {
-        return this._loadAccessorAsync(context, accessor, Float32Array);
-    };
-    GLTFLoader.prototype._loadIndicesAccessorAsync = function (context, accessor) {
-        if (accessor.type !== "SCALAR" /* SCALAR */) {
-            throw new Error("".concat(context, "/type: Invalid value ").concat(accessor.type));
-        }
-        if (accessor.componentType !== 5121 /* UNSIGNED_BYTE */ &&
-            accessor.componentType !== 5123 /* UNSIGNED_SHORT */ &&
-            accessor.componentType !== 5125 /* UNSIGNED_INT */) {
-            throw new Error("".concat(context, "/componentType: Invalid value ").concat(accessor.componentType));
-        }
-        if (accessor._data) {
-            return accessor._data;
-        }
-        if (accessor.sparse) {
-            var constructor = GLTFLoader._GetTypedArrayConstructor("".concat(context, "/componentType"), accessor.componentType);
-            accessor._data = this._loadAccessorAsync(context, accessor, constructor);
-        }
-        else {
-            var bufferView = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, accessor.bufferView);
-            accessor._data = this.loadBufferViewAsync("/bufferViews/".concat(bufferView.index), bufferView).then(function (data) {
-                return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, accessor.count);
-            });
-        }
-        return accessor._data;
-    };
-    GLTFLoader.prototype._loadVertexBufferViewAsync = function (bufferView) {
-        var _this = this;
-        if (bufferView._babylonBuffer) {
-            return bufferView._babylonBuffer;
-        }
-        bufferView._babylonBuffer = this.loadBufferViewAsync("/bufferViews/".concat(bufferView.index), bufferView).then(function (data) {
-            return new Buffer(_this._babylonScene.getEngine(), data, false);
-        });
-        return bufferView._babylonBuffer;
-    };
-    GLTFLoader.prototype._loadVertexAccessorAsync = function (context, accessor, kind) {
-        var _this = this;
-        var _a;
-        if ((_a = accessor._babylonVertexBuffer) === null || _a === void 0 ? void 0 : _a[kind]) {
-            return accessor._babylonVertexBuffer[kind];
-        }
-        if (!accessor._babylonVertexBuffer) {
-            accessor._babylonVertexBuffer = {};
-        }
-        if (accessor.sparse) {
-            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then(function (data) {
-                return new VertexBuffer(_this._babylonScene.getEngine(), data, kind, false);
-            });
-        }
-        // Load joint indices as a float array since the shaders expect float data but glTF uses unsigned byte/short.
-        // This prevents certain platforms (e.g. D3D) from having to convert the data to float on the fly.
-        else if (kind === VertexBuffer.MatricesIndicesKind || kind === VertexBuffer.MatricesIndicesExtraKind) {
-            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then(function (data) {
-                return new VertexBuffer(_this._babylonScene.getEngine(), data, kind, false);
-            });
-        }
-        else {
-            var bufferView_2 = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, accessor.bufferView);
-            accessor._babylonVertexBuffer[kind] = this._loadVertexBufferViewAsync(bufferView_2).then(function (babylonBuffer) {
-                var size = GLTFLoader._GetNumComponents(context, accessor.type);
-                return new VertexBuffer(_this._babylonScene.getEngine(), babylonBuffer, kind, false, false, bufferView_2.byteStride, false, accessor.byteOffset, size, accessor.componentType, accessor.normalized, true, 1, true);
-            });
-        }
-        return accessor._babylonVertexBuffer[kind];
-    };
-    GLTFLoader.prototype._loadMaterialMetallicRoughnessPropertiesAsync = function (context, properties, babylonMaterial) {
-        if (!(babylonMaterial instanceof PBRMaterial)) {
-            throw new Error("".concat(context, ": Material type not supported"));
-        }
-        var promises = new Array();
-        if (properties) {
-            if (properties.baseColorFactor) {
-                babylonMaterial.albedoColor = Color3.FromArray(properties.baseColorFactor);
-                babylonMaterial.alpha = properties.baseColorFactor[3];
-            }
-            else {
-                babylonMaterial.albedoColor = Color3.White();
-            }
-            babylonMaterial.metallic = properties.metallicFactor == undefined ? 1 : properties.metallicFactor;
-            babylonMaterial.roughness = properties.roughnessFactor == undefined ? 1 : properties.roughnessFactor;
-            if (properties.baseColorTexture) {
-                promises.push(this.loadTextureInfoAsync("".concat(context, "/baseColorTexture"), properties.baseColorTexture, function (texture) {
-                    texture.name = "".concat(babylonMaterial.name, " (Base Color)");
-                    babylonMaterial.albedoTexture = texture;
-                }));
-            }
-            if (properties.metallicRoughnessTexture) {
-                properties.metallicRoughnessTexture.nonColorData = true;
-                promises.push(this.loadTextureInfoAsync("".concat(context, "/metallicRoughnessTexture"), properties.metallicRoughnessTexture, function (texture) {
-                    texture.name = "".concat(babylonMaterial.name, " (Metallic Roughness)");
-                    babylonMaterial.metallicTexture = texture;
-                }));
-                babylonMaterial.useMetallnessFromMetallicTextureBlue = true;
-                babylonMaterial.useRoughnessFromMetallicTextureGreen = true;
-                babylonMaterial.useRoughnessFromMetallicTextureAlpha = false;
-            }
-        }
-        return Promise.all(promises).then(function () { });
-    };
-    /**
-     * @param context
-     * @param material
-     * @param babylonMesh
-     * @param babylonDrawMode
-     * @param assign
-     * @hidden
-     */
-    GLTFLoader.prototype._loadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        material._data = material._data || {};
-        var babylonData = material._data[babylonDrawMode];
-        if (!babylonData) {
-            this.logOpen("".concat(context, " ").concat(material.name || ""));
-            var babylonMaterial = this.createMaterial(context, material, babylonDrawMode);
-            babylonData = {
-                babylonMaterial: babylonMaterial,
-                babylonMeshes: [],
-                promise: this.loadMaterialPropertiesAsync(context, material, babylonMaterial),
-            };
-            material._data[babylonDrawMode] = babylonData;
-            GLTFLoader.AddPointerMetadata(babylonMaterial, context);
-            this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
-            this.logClose();
-        }
-        if (babylonMesh) {
-            babylonData.babylonMeshes.push(babylonMesh);
-            babylonMesh.onDisposeObservable.addOnce(function () {
-                var index = babylonData.babylonMeshes.indexOf(babylonMesh);
-                if (index !== -1) {
-                    babylonData.babylonMeshes.splice(index, 1);
-                }
-            });
-        }
-        assign(babylonData.babylonMaterial);
-        return babylonData.promise.then(function () {
-            return babylonData.babylonMaterial;
-        });
-    };
-    GLTFLoader.prototype._createDefaultMaterial = function (name, babylonDrawMode) {
-        this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var babylonMaterial = new PBRMaterial(name, this._babylonScene);
-        babylonMaterial._parentContainer = this._assetContainer;
-        this._babylonScene._blockEntityCollection = false;
-        // Moved to mesh so user can change materials on gltf meshes: babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
-        babylonMaterial.fillMode = babylonDrawMode;
-        babylonMaterial.enableSpecularAntiAliasing = true;
-        babylonMaterial.useRadianceOverAlpha = !this._parent.transparencyAsCoverage;
-        babylonMaterial.useSpecularOverAlpha = !this._parent.transparencyAsCoverage;
-        babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;
-        babylonMaterial.metallic = 1;
-        babylonMaterial.roughness = 1;
-        return babylonMaterial;
-    };
-    /**
-     * Creates a Babylon material from a glTF material.
-     * @param context The context when loading the asset
-     * @param material The glTF material property
-     * @param babylonDrawMode The draw mode for the Babylon material
-     * @returns The Babylon material
-     */
-    GLTFLoader.prototype.createMaterial = function (context, material, babylonDrawMode) {
-        var extensionPromise = this._extensionsCreateMaterial(context, material, babylonDrawMode);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        var name = material.name || "material".concat(material.index);
-        var babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode);
-        return babylonMaterial;
-    };
-    /**
-     * Loads properties from a glTF material into a Babylon material.
-     * @param context The context when loading the asset
-     * @param material The glTF material property
-     * @param babylonMaterial The Babylon material
-     * @returns A promise that resolves when the load is complete
-     */
-    GLTFLoader.prototype.loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
-        var extensionPromise = this._extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        var promises = new Array();
-        promises.push(this.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
-        if (material.pbrMetallicRoughness) {
-            promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync("".concat(context, "/pbrMetallicRoughness"), material.pbrMetallicRoughness, babylonMaterial));
-        }
-        this.loadMaterialAlphaProperties(context, material, babylonMaterial);
-        return Promise.all(promises).then(function () { });
-    };
-    /**
-     * Loads the normal, occlusion, and emissive properties from a glTF material into a Babylon material.
-     * @param context The context when loading the asset
-     * @param material The glTF material property
-     * @param babylonMaterial The Babylon material
-     * @returns A promise that resolves when the load is complete
-     */
-    GLTFLoader.prototype.loadMaterialBasePropertiesAsync = function (context, material, babylonMaterial) {
-        if (!(babylonMaterial instanceof PBRMaterial)) {
-            throw new Error("".concat(context, ": Material type not supported"));
-        }
-        var promises = new Array();
-        babylonMaterial.emissiveColor = material.emissiveFactor ? Color3.FromArray(material.emissiveFactor) : new Color3(0, 0, 0);
-        if (material.doubleSided) {
-            babylonMaterial.backFaceCulling = false;
-            babylonMaterial.twoSidedLighting = true;
-        }
-        if (material.normalTexture) {
-            material.normalTexture.nonColorData = true;
-            promises.push(this.loadTextureInfoAsync("".concat(context, "/normalTexture"), material.normalTexture, function (texture) {
-                texture.name = "".concat(babylonMaterial.name, " (Normal)");
-                babylonMaterial.bumpTexture = texture;
-            }));
-            babylonMaterial.invertNormalMapX = !this._babylonScene.useRightHandedSystem;
-            babylonMaterial.invertNormalMapY = this._babylonScene.useRightHandedSystem;
-            if (material.normalTexture.scale != undefined) {
-                babylonMaterial.bumpTexture.level = material.normalTexture.scale;
-            }
-            babylonMaterial.forceIrradianceInFragment = true;
-        }
-        if (material.occlusionTexture) {
-            material.occlusionTexture.nonColorData = true;
-            promises.push(this.loadTextureInfoAsync("".concat(context, "/occlusionTexture"), material.occlusionTexture, function (texture) {
-                texture.name = "".concat(babylonMaterial.name, " (Occlusion)");
-                babylonMaterial.ambientTexture = texture;
-            }));
-            babylonMaterial.useAmbientInGrayScale = true;
-            if (material.occlusionTexture.strength != undefined) {
-                babylonMaterial.ambientTextureStrength = material.occlusionTexture.strength;
-            }
-        }
-        if (material.emissiveTexture) {
-            promises.push(this.loadTextureInfoAsync("".concat(context, "/emissiveTexture"), material.emissiveTexture, function (texture) {
-                texture.name = "".concat(babylonMaterial.name, " (Emissive)");
-                babylonMaterial.emissiveTexture = texture;
-            }));
-        }
-        return Promise.all(promises).then(function () { });
-    };
-    /**
-     * Loads the alpha properties from a glTF material into a Babylon material.
-     * Must be called after the setting the albedo texture of the Babylon material when the material has an albedo texture.
-     * @param context The context when loading the asset
-     * @param material The glTF material property
-     * @param babylonMaterial The Babylon material
-     */
-    GLTFLoader.prototype.loadMaterialAlphaProperties = function (context, material, babylonMaterial) {
-        if (!(babylonMaterial instanceof PBRMaterial)) {
-            throw new Error("".concat(context, ": Material type not supported"));
-        }
-        var alphaMode = material.alphaMode || "OPAQUE" /* OPAQUE */;
-        switch (alphaMode) {
-            case "OPAQUE" /* OPAQUE */: {
-                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;
-                break;
-            }
-            case "MASK" /* MASK */: {
-                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHATEST;
-                babylonMaterial.alphaCutOff = material.alphaCutoff == undefined ? 0.5 : material.alphaCutoff;
-                if (babylonMaterial.albedoTexture) {
-                    babylonMaterial.albedoTexture.hasAlpha = true;
-                }
-                break;
-            }
-            case "BLEND" /* BLEND */: {
-                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHABLEND;
-                if (babylonMaterial.albedoTexture) {
-                    babylonMaterial.albedoTexture.hasAlpha = true;
-                    babylonMaterial.useAlphaFromAlbedoTexture = true;
-                }
-                break;
-            }
-            default: {
-                throw new Error("".concat(context, "/alphaMode: Invalid value (").concat(material.alphaMode, ")"));
-            }
-        }
-    };
-    /**
-     * Loads a glTF texture info.
-     * @param context The context when loading the asset
-     * @param textureInfo The glTF texture info property
-     * @param assign A function called synchronously after parsing the glTF properties
-     * @returns A promise that resolves with the loaded Babylon texture when the load is complete
-     */
-    GLTFLoader.prototype.loadTextureInfoAsync = function (context, textureInfo, assign) {
-        var _this = this;
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadTextureInfoAsync(context, textureInfo, assign);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        this.logOpen("".concat(context));
-        if (textureInfo.texCoord >= 6) {
-            throw new Error("".concat(context, "/texCoord: Invalid value (").concat(textureInfo.texCoord, ")"));
-        }
-        var texture = ArrayItem.Get("".concat(context, "/index"), this._gltf.textures, textureInfo.index);
-        texture._textureInfo = textureInfo;
-        var promise = this._loadTextureAsync("/textures/".concat(textureInfo.index), texture, function (babylonTexture) {
-            babylonTexture.coordinatesIndex = textureInfo.texCoord || 0;
-            GLTFLoader.AddPointerMetadata(babylonTexture, context);
-            _this._parent.onTextureLoadedObservable.notifyObservers(babylonTexture);
-            assign(babylonTexture);
-        });
-        this.logClose();
-        return promise;
-    };
-    /**
-     * @param context
-     * @param texture
-     * @param assign
-     * @hidden
-     */
-    GLTFLoader.prototype._loadTextureAsync = function (context, texture, assign) {
-        if (assign === void 0) { assign = function () { }; }
-        var extensionPromise = this._extensionsLoadTextureAsync(context, texture, assign);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        this.logOpen("".concat(context, " ").concat(texture.name || ""));
-        var sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get("".concat(context, "/sampler"), this._gltf.samplers, texture.sampler);
-        var image = ArrayItem.Get("".concat(context, "/source"), this._gltf.images, texture.source);
-        var promise = this._createTextureAsync(context, sampler, image, assign, undefined, !texture._textureInfo.nonColorData);
-        this.logClose();
-        return promise;
-    };
-    /**
-     * @param context
-     * @param sampler
-     * @param image
-     * @param assign
-     * @param textureLoaderOptions
-     * @param useSRGBBuffer
-     * @hidden
-     */
-    GLTFLoader.prototype._createTextureAsync = function (context, sampler, image, assign, textureLoaderOptions, useSRGBBuffer) {
-        var _this = this;
-        if (assign === void 0) { assign = function () { }; }
-        var samplerData = this._loadSampler("/samplers/".concat(sampler.index), sampler);
-        var promises = new Array();
-        var deferred = new Deferred();
-        this._babylonScene._blockEntityCollection = !!this._assetContainer;
-        var textureCreationOptions = {
-            noMipmap: samplerData.noMipMaps,
-            invertY: false,
-            samplingMode: samplerData.samplingMode,
-            onLoad: function () {
-                if (!_this._disposed) {
-                    deferred.resolve();
-                }
-            },
-            onError: function (message, exception) {
-                if (!_this._disposed) {
-                    deferred.reject(new Error("".concat(context, ": ").concat(exception && exception.message ? exception.message : message || "Failed to load texture")));
-                }
-            },
-            mimeType: image.mimeType,
-            loaderOptions: textureLoaderOptions,
-            useSRGBBuffer: !!useSRGBBuffer && this._parent.useSRGBBuffers,
-        };
-        var babylonTexture = new Texture(null, this._babylonScene, textureCreationOptions);
-        babylonTexture._parentContainer = this._assetContainer;
-        this._babylonScene._blockEntityCollection = false;
-        promises.push(deferred.promise);
-        promises.push(this.loadImageAsync("/images/".concat(image.index), image).then(function (data) {
-            var name = image.uri || "".concat(_this._fileName, "#image").concat(image.index);
-            var dataUrl = "data:".concat(_this._uniqueRootUrl).concat(name);
-            babylonTexture.updateURL(dataUrl, data);
-        }));
-        babylonTexture.wrapU = samplerData.wrapU;
-        babylonTexture.wrapV = samplerData.wrapV;
-        assign(babylonTexture);
-        return Promise.all(promises).then(function () {
-            return babylonTexture;
-        });
-    };
-    GLTFLoader.prototype._loadSampler = function (context, sampler) {
-        if (!sampler._data) {
-            sampler._data = {
-                noMipMaps: sampler.minFilter === 9728 /* NEAREST */ || sampler.minFilter === 9729 /* LINEAR */,
-                samplingMode: GLTFLoader._GetTextureSamplingMode(context, sampler),
-                wrapU: GLTFLoader._GetTextureWrapMode("".concat(context, "/wrapS"), sampler.wrapS),
-                wrapV: GLTFLoader._GetTextureWrapMode("".concat(context, "/wrapT"), sampler.wrapT),
-            };
-        }
-        return sampler._data;
-    };
-    /**
-     * Loads a glTF image.
-     * @param context The context when loading the asset
-     * @param image The glTF image property
-     * @returns A promise that resolves with the loaded data when the load is complete
-     */
-    GLTFLoader.prototype.loadImageAsync = function (context, image) {
-        if (!image._data) {
-            this.logOpen("".concat(context, " ").concat(image.name || ""));
-            if (image.uri) {
-                image._data = this.loadUriAsync("".concat(context, "/uri"), image, image.uri);
-            }
-            else {
-                var bufferView = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, image.bufferView);
-                image._data = this.loadBufferViewAsync("/bufferViews/".concat(bufferView.index), bufferView);
-            }
-            this.logClose();
-        }
-        return image._data;
-    };
-    /**
-     * Loads a glTF uri.
-     * @param context The context when loading the asset
-     * @param property The glTF property associated with the uri
-     * @param uri The base64 or relative uri
-     * @returns A promise that resolves with the loaded data when the load is complete
-     */
-    GLTFLoader.prototype.loadUriAsync = function (context, property, uri) {
-        var _this = this;
-        var extensionPromise = this._extensionsLoadUriAsync(context, property, uri);
-        if (extensionPromise) {
-            return extensionPromise;
-        }
-        if (!GLTFLoader._ValidateUri(uri)) {
-            throw new Error("".concat(context, ": '").concat(uri, "' is invalid"));
-        }
-        if (IsBase64DataUrl(uri)) {
-            var data = new Uint8Array(DecodeBase64UrlToBinary(uri));
-            this.log("".concat(context, ": Decoded ").concat(uri.substr(0, 64), "... (").concat(data.length, " bytes)"));
-            return Promise.resolve(data);
-        }
-        this.log("".concat(context, ": Loading ").concat(uri));
-        return this._parent.preprocessUrlAsync(this._rootUrl + uri).then(function (url) {
-            return new Promise(function (resolve, reject) {
-                _this._parent._loadFile(_this._babylonScene, url, function (data) {
-                    if (!_this._disposed) {
-                        _this.log("".concat(context, ": Loaded ").concat(uri, " (").concat(data.byteLength, " bytes)"));
-                        resolve(new Uint8Array(data));
-                    }
-                }, true, function (request) {
-                    reject(new LoadFileError("".concat(context, ": Failed to load '").concat(uri, "'").concat(request ? ": " + request.status + " " + request.statusText : ""), request));
-                });
-            });
-        });
-    };
-    /**
-     * Adds a JSON pointer to the metadata of the Babylon object at `<object>.metadata.gltf.pointers`.
-     * @param babylonObject the Babylon object with metadata
-     * @param babylonObject.metadata
-     * @param pointer the JSON pointer
-     */
-    GLTFLoader.AddPointerMetadata = function (babylonObject, pointer) {
-        var metadata = (babylonObject.metadata = babylonObject.metadata || {});
-        var gltf = (metadata.gltf = metadata.gltf || {});
-        var pointers = (gltf.pointers = gltf.pointers || []);
-        pointers.push(pointer);
-    };
-    GLTFLoader._GetTextureWrapMode = function (context, mode) {
-        // Set defaults if undefined
-        mode = mode == undefined ? 10497 /* REPEAT */ : mode;
-        switch (mode) {
-            case 33071 /* CLAMP_TO_EDGE */:
-                return Texture.CLAMP_ADDRESSMODE;
-            case 33648 /* MIRRORED_REPEAT */:
-                return Texture.MIRROR_ADDRESSMODE;
-            case 10497 /* REPEAT */:
-                return Texture.WRAP_ADDRESSMODE;
-            default:
-                Logger.Warn("".concat(context, ": Invalid value (").concat(mode, ")"));
-                return Texture.WRAP_ADDRESSMODE;
-        }
-    };
-    GLTFLoader._GetTextureSamplingMode = function (context, sampler) {
-        // Set defaults if undefined
-        var magFilter = sampler.magFilter == undefined ? 9729 /* LINEAR */ : sampler.magFilter;
-        var minFilter = sampler.minFilter == undefined ? 9987 /* LINEAR_MIPMAP_LINEAR */ : sampler.minFilter;
-        if (magFilter === 9729 /* LINEAR */) {
-            switch (minFilter) {
-                case 9728 /* NEAREST */:
-                    return Texture.LINEAR_NEAREST;
-                case 9729 /* LINEAR */:
-                    return Texture.LINEAR_LINEAR;
-                case 9984 /* NEAREST_MIPMAP_NEAREST */:
-                    return Texture.LINEAR_NEAREST_MIPNEAREST;
-                case 9985 /* LINEAR_MIPMAP_NEAREST */:
-                    return Texture.LINEAR_LINEAR_MIPNEAREST;
-                case 9986 /* NEAREST_MIPMAP_LINEAR */:
-                    return Texture.LINEAR_NEAREST_MIPLINEAR;
-                case 9987 /* LINEAR_MIPMAP_LINEAR */:
-                    return Texture.LINEAR_LINEAR_MIPLINEAR;
-                default:
-                    Logger.Warn("".concat(context, "/minFilter: Invalid value (").concat(minFilter, ")"));
-                    return Texture.LINEAR_LINEAR_MIPLINEAR;
-            }
-        }
-        else {
-            if (magFilter !== 9728 /* NEAREST */) {
-                Logger.Warn("".concat(context, "/magFilter: Invalid value (").concat(magFilter, ")"));
-            }
-            switch (minFilter) {
-                case 9728 /* NEAREST */:
-                    return Texture.NEAREST_NEAREST;
-                case 9729 /* LINEAR */:
-                    return Texture.NEAREST_LINEAR;
-                case 9984 /* NEAREST_MIPMAP_NEAREST */:
-                    return Texture.NEAREST_NEAREST_MIPNEAREST;
-                case 9985 /* LINEAR_MIPMAP_NEAREST */:
-                    return Texture.NEAREST_LINEAR_MIPNEAREST;
-                case 9986 /* NEAREST_MIPMAP_LINEAR */:
-                    return Texture.NEAREST_NEAREST_MIPLINEAR;
-                case 9987 /* LINEAR_MIPMAP_LINEAR */:
-                    return Texture.NEAREST_LINEAR_MIPLINEAR;
-                default:
-                    Logger.Warn("".concat(context, "/minFilter: Invalid value (").concat(minFilter, ")"));
-                    return Texture.NEAREST_NEAREST_MIPNEAREST;
-            }
-        }
-    };
-    GLTFLoader._GetTypedArrayConstructor = function (context, componentType) {
-        switch (componentType) {
-            case 5120 /* BYTE */:
-                return Int8Array;
-            case 5121 /* UNSIGNED_BYTE */:
-                return Uint8Array;
-            case 5122 /* SHORT */:
-                return Int16Array;
-            case 5123 /* UNSIGNED_SHORT */:
-                return Uint16Array;
-            case 5125 /* UNSIGNED_INT */:
-                return Uint32Array;
-            case 5126 /* FLOAT */:
-                return Float32Array;
-            default:
-                throw new Error("".concat(context, ": Invalid component type ").concat(componentType));
-        }
-    };
-    GLTFLoader._GetTypedArray = function (context, componentType, bufferView, byteOffset, length) {
-        var buffer = bufferView.buffer;
-        byteOffset = bufferView.byteOffset + (byteOffset || 0);
-        var constructor = GLTFLoader._GetTypedArrayConstructor("".concat(context, "/componentType"), componentType);
-        var componentTypeLength = VertexBuffer.GetTypeByteLength(componentType);
-        if (byteOffset % componentTypeLength !== 0) {
-            // HACK: Copy the buffer if byte offset is not a multiple of component type byte length.
-            Logger.Warn("".concat(context, ": Copying buffer as byte offset (").concat(byteOffset, ") is not a multiple of component type byte length (").concat(componentTypeLength, ")"));
-            return new constructor(buffer.slice(byteOffset, byteOffset + length * componentTypeLength), 0);
-        }
-        return new constructor(buffer, byteOffset, length);
-    };
-    GLTFLoader._GetNumComponents = function (context, type) {
-        switch (type) {
-            case "SCALAR":
-                return 1;
-            case "VEC2":
-                return 2;
-            case "VEC3":
-                return 3;
-            case "VEC4":
-                return 4;
-            case "MAT2":
-                return 4;
-            case "MAT3":
-                return 9;
-            case "MAT4":
-                return 16;
-        }
-        throw new Error("".concat(context, ": Invalid type (").concat(type, ")"));
-    };
-    GLTFLoader._ValidateUri = function (uri) {
-        return Tools.IsBase64(uri) || uri.indexOf("..") === -1;
-    };
-    /**
-     * @param context
-     * @param mode
-     * @hidden
-     */
-    GLTFLoader._GetDrawMode = function (context, mode) {
-        if (mode == undefined) {
-            mode = 4 /* TRIANGLES */;
-        }
-        switch (mode) {
-            case 0 /* POINTS */:
-                return Material.PointListDrawMode;
-            case 1 /* LINES */:
-                return Material.LineListDrawMode;
-            case 2 /* LINE_LOOP */:
-                return Material.LineLoopDrawMode;
-            case 3 /* LINE_STRIP */:
-                return Material.LineStripDrawMode;
-            case 4 /* TRIANGLES */:
-                return Material.TriangleFillMode;
-            case 5 /* TRIANGLE_STRIP */:
-                return Material.TriangleStripDrawMode;
-            case 6 /* TRIANGLE_FAN */:
-                return Material.TriangleFanDrawMode;
-        }
-        throw new Error("".concat(context, ": Invalid mesh primitive mode (").concat(mode, ")"));
-    };
-    GLTFLoader.prototype._compileMaterialsAsync = function () {
-        var _this = this;
-        this._parent._startPerformanceCounter("Compile materials");
-        var promises = new Array();
-        if (this._gltf.materials) {
-            for (var _i = 0, _a = this._gltf.materials; _i < _a.length; _i++) {
-                var material = _a[_i];
-                if (material._data) {
-                    for (var babylonDrawMode in material._data) {
-                        var babylonData = material._data[babylonDrawMode];
-                        for (var _b = 0, _c = babylonData.babylonMeshes; _b < _c.length; _b++) {
-                            var babylonMesh = _c[_b];
-                            // Ensure nonUniformScaling is set if necessary.
-                            babylonMesh.computeWorldMatrix(true);
-                            var babylonMaterial = babylonData.babylonMaterial;
-                            promises.push(babylonMaterial.forceCompilationAsync(babylonMesh));
-                            promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { useInstances: true }));
-                            if (this._parent.useClipPlane) {
-                                promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true }));
-                                promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true, useInstances: true }));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return Promise.all(promises).then(function () {
-            _this._parent._endPerformanceCounter("Compile materials");
-        });
-    };
-    GLTFLoader.prototype._compileShadowGeneratorsAsync = function () {
-        var _this = this;
-        this._parent._startPerformanceCounter("Compile shadow generators");
-        var promises = new Array();
-        var lights = this._babylonScene.lights;
-        for (var _i = 0, lights_1 = lights; _i < lights_1.length; _i++) {
-            var light = lights_1[_i];
-            var generator = light.getShadowGenerator();
-            if (generator) {
-                promises.push(generator.forceCompilationAsync());
-            }
-        }
-        return Promise.all(promises).then(function () {
-            _this._parent._endPerformanceCounter("Compile shadow generators");
-        });
-    };
-    GLTFLoader.prototype._forEachExtensions = function (action) {
-        for (var _i = 0, _a = this._extensions; _i < _a.length; _i++) {
-            var extension = _a[_i];
-            if (extension.enabled) {
-                action(extension);
-            }
-        }
-    };
-    GLTFLoader.prototype._applyExtensions = function (property, functionName, actionAsync) {
-        for (var _i = 0, _a = this._extensions; _i < _a.length; _i++) {
-            var extension = _a[_i];
-            if (extension.enabled) {
-                var id = "".concat(extension.name, ".").concat(functionName);
-                var loaderProperty = property;
-                loaderProperty._activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions || {};
-                var activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions;
-                if (!activeLoaderExtensionFunctions[id]) {
-                    activeLoaderExtensionFunctions[id] = true;
-                    try {
-                        var result = actionAsync(extension);
-                        if (result) {
-                            return result;
-                        }
-                    }
-                    finally {
-                        delete activeLoaderExtensionFunctions[id];
-                    }
-                }
-            }
-        }
-        return null;
-    };
-    GLTFLoader.prototype._extensionsOnLoading = function () {
-        this._forEachExtensions(function (extension) { return extension.onLoading && extension.onLoading(); });
-    };
-    GLTFLoader.prototype._extensionsOnReady = function () {
-        this._forEachExtensions(function (extension) { return extension.onReady && extension.onReady(); });
-    };
-    GLTFLoader.prototype._extensionsLoadSceneAsync = function (context, scene) {
-        return this._applyExtensions(scene, "loadScene", function (extension) { return extension.loadSceneAsync && extension.loadSceneAsync(context, scene); });
-    };
-    GLTFLoader.prototype._extensionsLoadNodeAsync = function (context, node, assign) {
-        return this._applyExtensions(node, "loadNode", function (extension) { return extension.loadNodeAsync && extension.loadNodeAsync(context, node, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadCameraAsync = function (context, camera, assign) {
-        return this._applyExtensions(camera, "loadCamera", function (extension) { return extension.loadCameraAsync && extension.loadCameraAsync(context, camera, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadVertexDataAsync = function (context, primitive, babylonMesh) {
-        return this._applyExtensions(primitive, "loadVertexData", function (extension) { return extension._loadVertexDataAsync && extension._loadVertexDataAsync(context, primitive, babylonMesh); });
-    };
-    GLTFLoader.prototype._extensionsLoadMeshPrimitiveAsync = function (context, name, node, mesh, primitive, assign) {
-        return this._applyExtensions(primitive, "loadMeshPrimitive", function (extension) { return extension._loadMeshPrimitiveAsync && extension._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
-        return this._applyExtensions(material, "loadMaterial", function (extension) { return extension._loadMaterialAsync && extension._loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign); });
-    };
-    GLTFLoader.prototype._extensionsCreateMaterial = function (context, material, babylonDrawMode) {
-        return this._applyExtensions(material, "createMaterial", function (extension) { return extension.createMaterial && extension.createMaterial(context, material, babylonDrawMode); });
-    };
-    GLTFLoader.prototype._extensionsLoadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
-        return this._applyExtensions(material, "loadMaterialProperties", function (extension) { return extension.loadMaterialPropertiesAsync && extension.loadMaterialPropertiesAsync(context, material, babylonMaterial); });
-    };
-    GLTFLoader.prototype._extensionsLoadTextureInfoAsync = function (context, textureInfo, assign) {
-        return this._applyExtensions(textureInfo, "loadTextureInfo", function (extension) { return extension.loadTextureInfoAsync && extension.loadTextureInfoAsync(context, textureInfo, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadTextureAsync = function (context, texture, assign) {
-        return this._applyExtensions(texture, "loadTexture", function (extension) { return extension._loadTextureAsync && extension._loadTextureAsync(context, texture, assign); });
-    };
-    GLTFLoader.prototype._extensionsLoadAnimationAsync = function (context, animation) {
-        return this._applyExtensions(animation, "loadAnimation", function (extension) { return extension.loadAnimationAsync && extension.loadAnimationAsync(context, animation); });
-    };
-    GLTFLoader.prototype._extensionsLoadSkinAsync = function (context, node, skin) {
-        return this._applyExtensions(skin, "loadSkin", function (extension) { return extension._loadSkinAsync && extension._loadSkinAsync(context, node, skin); });
-    };
-    GLTFLoader.prototype._extensionsLoadUriAsync = function (context, property, uri) {
-        return this._applyExtensions(property, "loadUri", function (extension) { return extension._loadUriAsync && extension._loadUriAsync(context, property, uri); });
-    };
-    GLTFLoader.prototype._extensionsLoadBufferViewAsync = function (context, bufferView) {
-        return this._applyExtensions(bufferView, "loadBufferView", function (extension) { return extension.loadBufferViewAsync && extension.loadBufferViewAsync(context, bufferView); });
-    };
-    GLTFLoader.prototype._extensionsLoadBufferAsync = function (context, buffer, byteOffset, byteLength) {
-        return this._applyExtensions(buffer, "loadBuffer", function (extension) { return extension.loadBufferAsync && extension.loadBufferAsync(context, buffer, byteOffset, byteLength); });
-    };
-    /**
-     * Helper method called by a loader extension to load an glTF extension.
-     * @param context The context when loading the asset
-     * @param property The glTF property to load the extension from
-     * @param extensionName The name of the extension to load
-     * @param actionAsync The action to run
-     * @returns The promise returned by actionAsync or null if the extension does not exist
-     */
-    GLTFLoader.LoadExtensionAsync = function (context, property, extensionName, actionAsync) {
-        if (!property.extensions) {
-            return null;
-        }
-        var extensions = property.extensions;
-        var extension = extensions[extensionName];
-        if (!extension) {
-            return null;
-        }
-        return actionAsync("".concat(context, "/extensions/").concat(extensionName), extension);
-    };
-    /**
-     * Helper method called by a loader extension to load a glTF extra.
-     * @param context The context when loading the asset
-     * @param property The glTF property to load the extra from
-     * @param extensionName The name of the extension to load
-     * @param actionAsync The action to run
-     * @returns The promise returned by actionAsync or null if the extra does not exist
-     */
-    GLTFLoader.LoadExtraAsync = function (context, property, extensionName, actionAsync) {
-        if (!property.extras) {
-            return null;
-        }
-        var extras = property.extras;
-        var extra = extras[extensionName];
-        if (!extra) {
-            return null;
-        }
-        return actionAsync("".concat(context, "/extras/").concat(extensionName), extra);
-    };
-    /**
-     * Checks for presence of an extension.
-     * @param name The name of the extension to check
-     * @returns A boolean indicating the presence of the given extension name in `extensionsUsed`
-     */
-    GLTFLoader.prototype.isExtensionUsed = function (name) {
-        return !!this._gltf.extensionsUsed && this._gltf.extensionsUsed.indexOf(name) !== -1;
-    };
-    /**
-     * Increments the indentation level and logs a message.
-     * @param message The message to log
-     */
-    GLTFLoader.prototype.logOpen = function (message) {
-        this._parent._logOpen(message);
-    };
-    /**
-     * Decrements the indentation level.
-     */
-    GLTFLoader.prototype.logClose = function () {
-        this._parent._logClose();
-    };
-    /**
-     * Logs a message
-     * @param message The message to log
-     */
-    GLTFLoader.prototype.log = function (message) {
-        this._parent._log(message);
-    };
-    /**
-     * Starts a performance counter.
-     * @param counterName The name of the performance counter
-     */
-    GLTFLoader.prototype.startPerformanceCounter = function (counterName) {
-        this._parent._startPerformanceCounter(counterName);
-    };
-    /**
-     * Ends a performance counter.
-     * @param counterName The name of the performance counter
-     */
-    GLTFLoader.prototype.endPerformanceCounter = function (counterName) {
-        this._parent._endPerformanceCounter(counterName);
-    };
-    GLTFLoader._RegisteredExtensions = {};
-    /**
-     * The default glTF sampler.
-     */
-    GLTFLoader.DefaultSampler = { index: -1 };
-    return GLTFLoader;
-}());
-export { GLTFLoader };
-GLTFFileLoader._CreateGLTF2Loader = function (parent) { return new GLTFLoader(parent); };
+import { Deferred } from "@babylonjs/core/Misc/deferred.js";
+import { Quaternion, Vector3, Matrix, TmpVectors } 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 { AnimationGroup } from "@babylonjs/core/Animations/animationGroup.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 { Material } from "@babylonjs/core/Materials/material.js";
+import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
+import { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+import { TransformNode } from "@babylonjs/core/Meshes/transformNode.js";
+import { Buffer, VertexBuffer } from "@babylonjs/core/Buffers/buffer.js";
+import { Geometry } from "@babylonjs/core/Meshes/geometry.js";
+import { Mesh } from "@babylonjs/core/Meshes/mesh.js";
+import { MorphTarget } from "@babylonjs/core/Morph/morphTarget.js";
+import { MorphTargetManager } from "@babylonjs/core/Morph/morphTargetManager.js";
+import { GLTFFileLoader, GLTFLoaderState, GLTFLoaderCoordinateSystemMode, GLTFLoaderAnimationStartMode } from "../glTFFileLoader.js";
+import { AnimationKeyInterpolation } from "@babylonjs/core/Animations/animationKey.js";
+import { DecodeBase64UrlToBinary, IsBase64DataUrl, LoadFileError } from "@babylonjs/core/Misc/fileTools.js";
+import { Logger } from "@babylonjs/core/Misc/logger.js";
+import { BoundingInfo } from "@babylonjs/core/Culling/boundingInfo.js";
+import { StringTools } from "@babylonjs/core/Misc/stringTools.js";
+/**
+ * Helper class for working with arrays when loading the glTF asset
+ */
+var ArrayItem = /** @class */ (function () {
+    function ArrayItem() {
+    }
+    /**
+     * Gets an item from the given array.
+     * @param context The context when loading the asset
+     * @param array The array to get the item from
+     * @param index The index to the array
+     * @returns The array item
+     */
+    ArrayItem.Get = function (context, array, index) {
+        if (!array || index == undefined || !array[index]) {
+            throw new Error("".concat(context, ": Failed to find index (").concat(index, ")"));
+        }
+        return array[index];
+    };
+    /**
+     * Assign an `index` field to each item of the given array.
+     * @param array The array of items
+     */
+    ArrayItem.Assign = function (array) {
+        if (array) {
+            for (var index = 0; index < array.length; index++) {
+                array[index].index = index;
+            }
+        }
+    };
+    return ArrayItem;
+}());
+export { ArrayItem };
+/**
+ * The glTF 2.0 loader
+ */
+var GLTFLoader = /** @class */ (function () {
+    /**
+     * @param parent
+     * @hidden
+     */
+    function GLTFLoader(parent) {
+        /** @hidden */
+        this._completePromises = new Array();
+        /** @hidden */
+        this._assetContainer = null;
+        /** Storage */
+        this._babylonLights = [];
+        /** @hidden */
+        this._disableInstancedMesh = 0;
+        this._extensions = new Array();
+        this._disposed = false;
+        this._rootUrl = null;
+        this._fileName = null;
+        this._uniqueRootUrl = null;
+        this._bin = null;
+        this._rootBabylonMesh = null;
+        this._defaultBabylonMaterialData = {};
+        this._postSceneLoadActions = new Array();
+        this._parent = parent;
+    }
+    /**
+     * Registers a loader extension.
+     * @param name The name of the loader extension.
+     * @param factory The factory function that creates the loader extension.
+     */
+    GLTFLoader.RegisterExtension = function (name, factory) {
+        if (GLTFLoader.UnregisterExtension(name)) {
+            Logger.Warn("Extension with the name '".concat(name, "' already exists"));
+        }
+        GLTFLoader._RegisteredExtensions[name] = {
+            factory: factory,
+        };
+    };
+    /**
+     * Unregisters a loader extension.
+     * @param name The name of the loader extension.
+     * @returns A boolean indicating whether the extension has been unregistered
+     */
+    GLTFLoader.UnregisterExtension = function (name) {
+        if (!GLTFLoader._RegisteredExtensions[name]) {
+            return false;
+        }
+        delete GLTFLoader._RegisteredExtensions[name];
+        return true;
+    };
+    Object.defineProperty(GLTFLoader.prototype, "gltf", {
+        /**
+         * The object that represents the glTF JSON.
+         */
+        get: function () {
+            if (!this._gltf) {
+                throw new Error("glTF JSON is not available");
+            }
+            return this._gltf;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFLoader.prototype, "bin", {
+        /**
+         * The BIN chunk of a binary glTF.
+         */
+        get: function () {
+            return this._bin;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFLoader.prototype, "parent", {
+        /**
+         * The parent file loader.
+         */
+        get: function () {
+            return this._parent;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFLoader.prototype, "babylonScene", {
+        /**
+         * The Babylon scene when loading the asset.
+         */
+        get: function () {
+            if (!this._babylonScene) {
+                throw new Error("Scene is not available");
+            }
+            return this._babylonScene;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GLTFLoader.prototype, "rootBabylonMesh", {
+        /**
+         * The root Babylon mesh when loading the asset.
+         */
+        get: function () {
+            return this._rootBabylonMesh;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /** @hidden */
+    GLTFLoader.prototype.dispose = function () {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        this._completePromises.length = 0;
+        this._extensions.forEach(function (extension) { return extension.dispose && extension.dispose(); });
+        this._extensions.length = 0;
+        this._gltf = null; // TODO
+        this._bin = null;
+        this._babylonScene = null; // TODO
+        this._rootBabylonMesh = null;
+        this._defaultBabylonMaterialData = {};
+        this._postSceneLoadActions.length = 0;
+        this._parent.dispose();
+    };
+    /**
+     * @param meshesNames
+     * @param scene
+     * @param container
+     * @param data
+     * @param rootUrl
+     * @param onProgress
+     * @param fileName
+     * @hidden
+     */
+    GLTFLoader.prototype.importMeshAsync = function (meshesNames, scene, container, data, rootUrl, onProgress, fileName) {
+        var _this = this;
+        if (fileName === void 0) { fileName = ""; }
+        return Promise.resolve().then(function () {
+            _this._babylonScene = scene;
+            _this._assetContainer = container;
+            _this._loadData(data);
+            var nodes = null;
+            if (meshesNames) {
+                var nodeMap_1 = {};
+                if (_this._gltf.nodes) {
+                    for (var _i = 0, _a = _this._gltf.nodes; _i < _a.length; _i++) {
+                        var node = _a[_i];
+                        if (node.name) {
+                            nodeMap_1[node.name] = node.index;
+                        }
+                    }
+                }
+                var names = meshesNames instanceof Array ? meshesNames : [meshesNames];
+                nodes = names.map(function (name) {
+                    var node = nodeMap_1[name];
+                    if (node === undefined) {
+                        throw new Error("Failed to find node '".concat(name, "'"));
+                    }
+                    return node;
+                });
+            }
+            return _this._loadAsync(rootUrl, fileName, nodes, function () {
+                return {
+                    meshes: _this._getMeshes(),
+                    particleSystems: [],
+                    skeletons: _this._getSkeletons(),
+                    animationGroups: _this._getAnimationGroups(),
+                    lights: _this._babylonLights,
+                    transformNodes: _this._getTransformNodes(),
+                    geometries: _this._getGeometries(),
+                };
+            });
+        });
+    };
+    /**
+     * @param scene
+     * @param data
+     * @param rootUrl
+     * @param onProgress
+     * @param fileName
+     * @hidden
+     */
+    GLTFLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress, fileName) {
+        var _this = this;
+        if (fileName === void 0) { fileName = ""; }
+        return Promise.resolve().then(function () {
+            _this._babylonScene = scene;
+            _this._loadData(data);
+            return _this._loadAsync(rootUrl, fileName, null, function () { return undefined; });
+        });
+    };
+    GLTFLoader.prototype._loadAsync = function (rootUrl, fileName, nodes, resultFunc) {
+        var _this = this;
+        return Promise.resolve()
+            .then(function () {
+            _this._rootUrl = rootUrl;
+            _this._uniqueRootUrl = !StringTools.StartsWith(rootUrl, "file:") && fileName ? rootUrl : "".concat(rootUrl).concat(Date.now(), "/");
+            _this._fileName = fileName;
+            _this._loadExtensions();
+            _this._checkExtensions();
+            var loadingToReadyCounterName = "".concat(GLTFLoaderState[GLTFLoaderState.LOADING], " => ").concat(GLTFLoaderState[GLTFLoaderState.READY]);
+            var loadingToCompleteCounterName = "".concat(GLTFLoaderState[GLTFLoaderState.LOADING], " => ").concat(GLTFLoaderState[GLTFLoaderState.COMPLETE]);
+            _this._parent._startPerformanceCounter(loadingToReadyCounterName);
+            _this._parent._startPerformanceCounter(loadingToCompleteCounterName);
+            _this._parent._setState(GLTFLoaderState.LOADING);
+            _this._extensionsOnLoading();
+            var promises = new Array();
+            // Block the marking of materials dirty until the scene is loaded.
+            var oldBlockMaterialDirtyMechanism = _this._babylonScene.blockMaterialDirtyMechanism;
+            _this._babylonScene.blockMaterialDirtyMechanism = true;
+            if (!_this.parent.loadOnlyMaterials) {
+                if (nodes) {
+                    promises.push(_this.loadSceneAsync("/nodes", { nodes: nodes, index: -1 }));
+                }
+                else if (_this._gltf.scene != undefined || (_this._gltf.scenes && _this._gltf.scenes[0])) {
+                    var scene = ArrayItem.Get("/scene", _this._gltf.scenes, _this._gltf.scene || 0);
+                    promises.push(_this.loadSceneAsync("/scenes/".concat(scene.index), scene));
+                }
+            }
+            if (!_this.parent.skipMaterials && _this.parent.loadAllMaterials && _this._gltf.materials) {
+                for (var m = 0; m < _this._gltf.materials.length; ++m) {
+                    var material = _this._gltf.materials[m];
+                    var context_1 = "/materials/" + m;
+                    var babylonDrawMode = Material.TriangleFillMode;
+                    promises.push(_this._loadMaterialAsync(context_1, material, null, babylonDrawMode, function () { }));
+                }
+            }
+            // Restore the blocking of material dirty.
+            _this._babylonScene.blockMaterialDirtyMechanism = oldBlockMaterialDirtyMechanism;
+            if (_this._parent.compileMaterials) {
+                promises.push(_this._compileMaterialsAsync());
+            }
+            if (_this._parent.compileShadowGenerators) {
+                promises.push(_this._compileShadowGeneratorsAsync());
+            }
+            var resultPromise = Promise.all(promises).then(function () {
+                if (_this._rootBabylonMesh) {
+                    _this._rootBabylonMesh.setEnabled(true);
+                }
+                _this._extensionsOnReady();
+                _this._parent._setState(GLTFLoaderState.READY);
+                _this._startAnimations();
+                return resultFunc();
+            });
+            return resultPromise.then(function (result) {
+                _this._parent._endPerformanceCounter(loadingToReadyCounterName);
+                Tools.SetImmediate(function () {
+                    if (!_this._disposed) {
+                        Promise.all(_this._completePromises).then(function () {
+                            _this._parent._endPerformanceCounter(loadingToCompleteCounterName);
+                            _this._parent._setState(GLTFLoaderState.COMPLETE);
+                            _this._parent.onCompleteObservable.notifyObservers(undefined);
+                            _this._parent.onCompleteObservable.clear();
+                            _this.dispose();
+                        }, function (error) {
+                            _this._parent.onErrorObservable.notifyObservers(error);
+                            _this._parent.onErrorObservable.clear();
+                            _this.dispose();
+                        });
+                    }
+                });
+                return result;
+            });
+        })
+            .catch(function (error) {
+            if (!_this._disposed) {
+                _this._parent.onErrorObservable.notifyObservers(error);
+                _this._parent.onErrorObservable.clear();
+                _this.dispose();
+            }
+            throw error;
+        });
+    };
+    GLTFLoader.prototype._loadData = function (data) {
+        this._gltf = data.json;
+        this._setupData();
+        if (data.bin) {
+            var buffers = this._gltf.buffers;
+            if (buffers && buffers[0] && !buffers[0].uri) {
+                var binaryBuffer = buffers[0];
+                if (binaryBuffer.byteLength < data.bin.byteLength - 3 || binaryBuffer.byteLength > data.bin.byteLength) {
+                    Logger.Warn("Binary buffer length (".concat(binaryBuffer.byteLength, ") from JSON does not match chunk length (").concat(data.bin.byteLength, ")"));
+                }
+                this._bin = data.bin;
+            }
+            else {
+                Logger.Warn("Unexpected BIN chunk");
+            }
+        }
+    };
+    GLTFLoader.prototype._setupData = function () {
+        ArrayItem.Assign(this._gltf.accessors);
+        ArrayItem.Assign(this._gltf.animations);
+        ArrayItem.Assign(this._gltf.buffers);
+        ArrayItem.Assign(this._gltf.bufferViews);
+        ArrayItem.Assign(this._gltf.cameras);
+        ArrayItem.Assign(this._gltf.images);
+        ArrayItem.Assign(this._gltf.materials);
+        ArrayItem.Assign(this._gltf.meshes);
+        ArrayItem.Assign(this._gltf.nodes);
+        ArrayItem.Assign(this._gltf.samplers);
+        ArrayItem.Assign(this._gltf.scenes);
+        ArrayItem.Assign(this._gltf.skins);
+        ArrayItem.Assign(this._gltf.textures);
+        if (this._gltf.nodes) {
+            var nodeParents = {};
+            for (var _i = 0, _a = this._gltf.nodes; _i < _a.length; _i++) {
+                var node = _a[_i];
+                if (node.children) {
+                    for (var _b = 0, _c = node.children; _b < _c.length; _b++) {
+                        var index = _c[_b];
+                        nodeParents[index] = node.index;
+                    }
+                }
+            }
+            var rootNode = this._createRootNode();
+            for (var _d = 0, _e = this._gltf.nodes; _d < _e.length; _d++) {
+                var node = _e[_d];
+                var parentIndex = nodeParents[node.index];
+                node.parent = parentIndex === undefined ? rootNode : this._gltf.nodes[parentIndex];
+            }
+        }
+    };
+    GLTFLoader.prototype._loadExtensions = function () {
+        for (var name_1 in GLTFLoader._RegisteredExtensions) {
+            var extension = GLTFLoader._RegisteredExtensions[name_1].factory(this);
+            if (extension.name !== name_1) {
+                Logger.Warn("The name of the glTF loader extension instance does not match the registered name: ".concat(extension.name, " !== ").concat(name_1));
+            }
+            this._extensions.push(extension);
+            this._parent.onExtensionLoadedObservable.notifyObservers(extension);
+        }
+        this._extensions.sort(function (a, b) { return (a.order || Number.MAX_VALUE) - (b.order || Number.MAX_VALUE); });
+        this._parent.onExtensionLoadedObservable.clear();
+    };
+    GLTFLoader.prototype._checkExtensions = function () {
+        if (this._gltf.extensionsRequired) {
+            var _loop_1 = function (name_2) {
+                var available = this_1._extensions.some(function (extension) { return extension.name === name_2 && extension.enabled; });
+                if (!available) {
+                    throw new Error("Require extension ".concat(name_2, " is not available"));
+                }
+            };
+            var this_1 = this;
+            for (var _i = 0, _a = this._gltf.extensionsRequired; _i < _a.length; _i++) {
+                var name_2 = _a[_i];
+                _loop_1(name_2);
+            }
+        }
+    };
+    GLTFLoader.prototype._createRootNode = function () {
+        this._babylonScene._blockEntityCollection = !!this._assetContainer;
+        this._rootBabylonMesh = new Mesh("__root__", this._babylonScene);
+        this._rootBabylonMesh._parentContainer = this._assetContainer;
+        this._babylonScene._blockEntityCollection = false;
+        this._rootBabylonMesh.setEnabled(false);
+        var rootNode = {
+            _babylonTransformNode: this._rootBabylonMesh,
+            index: -1,
+        };
+        switch (this._parent.coordinateSystemMode) {
+            case GLTFLoaderCoordinateSystemMode.AUTO: {
+                if (!this._babylonScene.useRightHandedSystem) {
+                    rootNode.rotation = [0, 1, 0, 0];
+                    rootNode.scale = [1, 1, -1];
+                    GLTFLoader._LoadTransform(rootNode, this._rootBabylonMesh);
+                }
+                break;
+            }
+            case GLTFLoaderCoordinateSystemMode.FORCE_RIGHT_HANDED: {
+                this._babylonScene.useRightHandedSystem = true;
+                break;
+            }
+            default: {
+                throw new Error("Invalid coordinate system mode (".concat(this._parent.coordinateSystemMode, ")"));
+            }
+        }
+        this._parent.onMeshLoadedObservable.notifyObservers(this._rootBabylonMesh);
+        return rootNode;
+    };
+    /**
+     * Loads a glTF scene.
+     * @param context The context when loading the asset
+     * @param scene The glTF scene property
+     * @returns A promise that resolves when the load is complete
+     */
+    GLTFLoader.prototype.loadSceneAsync = function (context, scene) {
+        var _this = this;
+        var extensionPromise = this._extensionsLoadSceneAsync(context, scene);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        var promises = new Array();
+        this.logOpen("".concat(context, " ").concat(scene.name || ""));
+        if (scene.nodes) {
+            for (var _i = 0, _a = scene.nodes; _i < _a.length; _i++) {
+                var index = _a[_i];
+                var node = ArrayItem.Get("".concat(context, "/nodes/").concat(index), this._gltf.nodes, index);
+                promises.push(this.loadNodeAsync("/nodes/".concat(node.index), node, function (babylonMesh) {
+                    babylonMesh.parent = _this._rootBabylonMesh;
+                }));
+            }
+        }
+        for (var _b = 0, _c = this._postSceneLoadActions; _b < _c.length; _b++) {
+            var action = _c[_b];
+            action();
+        }
+        promises.push(this._loadAnimationsAsync());
+        this.logClose();
+        return Promise.all(promises).then(function () { });
+    };
+    GLTFLoader.prototype._forEachPrimitive = function (node, callback) {
+        if (node._primitiveBabylonMeshes) {
+            for (var _i = 0, _a = node._primitiveBabylonMeshes; _i < _a.length; _i++) {
+                var babylonMesh = _a[_i];
+                callback(babylonMesh);
+            }
+        }
+    };
+    GLTFLoader.prototype._getGeometries = function () {
+        var geometries = new Array();
+        var nodes = this._gltf.nodes;
+        if (nodes) {
+            for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+                var node = nodes_1[_i];
+                this._forEachPrimitive(node, function (babylonMesh) {
+                    var geometry = babylonMesh.geometry;
+                    if (geometry && geometries.indexOf(geometry) === -1) {
+                        geometries.push(geometry);
+                    }
+                });
+            }
+        }
+        return geometries;
+    };
+    GLTFLoader.prototype._getMeshes = function () {
+        var meshes = new Array();
+        // Root mesh is always first, if available.
+        if (this._rootBabylonMesh) {
+            meshes.push(this._rootBabylonMesh);
+        }
+        var nodes = this._gltf.nodes;
+        if (nodes) {
+            for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) {
+                var node = nodes_2[_i];
+                this._forEachPrimitive(node, function (babylonMesh) {
+                    meshes.push(babylonMesh);
+                });
+            }
+        }
+        return meshes;
+    };
+    GLTFLoader.prototype._getTransformNodes = function () {
+        var transformNodes = new Array();
+        var nodes = this._gltf.nodes;
+        if (nodes) {
+            for (var _i = 0, nodes_3 = nodes; _i < nodes_3.length; _i++) {
+                var node = nodes_3[_i];
+                if (node._babylonTransformNode && node._babylonTransformNode.getClassName() === "TransformNode") {
+                    transformNodes.push(node._babylonTransformNode);
+                }
+                if (node._babylonTransformNodeForSkin) {
+                    transformNodes.push(node._babylonTransformNodeForSkin);
+                }
+            }
+        }
+        return transformNodes;
+    };
+    GLTFLoader.prototype._getSkeletons = function () {
+        var skeletons = new Array();
+        var skins = this._gltf.skins;
+        if (skins) {
+            for (var _i = 0, skins_1 = skins; _i < skins_1.length; _i++) {
+                var skin = skins_1[_i];
+                if (skin._data) {
+                    skeletons.push(skin._data.babylonSkeleton);
+                }
+            }
+        }
+        return skeletons;
+    };
+    GLTFLoader.prototype._getAnimationGroups = function () {
+        var animationGroups = new Array();
+        var animations = this._gltf.animations;
+        if (animations) {
+            for (var _i = 0, animations_1 = animations; _i < animations_1.length; _i++) {
+                var animation = animations_1[_i];
+                if (animation._babylonAnimationGroup) {
+                    animationGroups.push(animation._babylonAnimationGroup);
+                }
+            }
+        }
+        return animationGroups;
+    };
+    GLTFLoader.prototype._startAnimations = function () {
+        switch (this._parent.animationStartMode) {
+            case GLTFLoaderAnimationStartMode.NONE: {
+                // do nothing
+                break;
+            }
+            case GLTFLoaderAnimationStartMode.FIRST: {
+                var babylonAnimationGroups = this._getAnimationGroups();
+                if (babylonAnimationGroups.length !== 0) {
+                    babylonAnimationGroups[0].start(true);
+                }
+                break;
+            }
+            case GLTFLoaderAnimationStartMode.ALL: {
+                var babylonAnimationGroups = this._getAnimationGroups();
+                for (var _i = 0, babylonAnimationGroups_1 = babylonAnimationGroups; _i < babylonAnimationGroups_1.length; _i++) {
+                    var babylonAnimationGroup = babylonAnimationGroups_1[_i];
+                    babylonAnimationGroup.start(true);
+                }
+                break;
+            }
+            default: {
+                Logger.Error("Invalid animation start mode (".concat(this._parent.animationStartMode, ")"));
+                return;
+            }
+        }
+    };
+    /**
+     * Loads a glTF node.
+     * @param context The context when loading the asset
+     * @param node The glTF node property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded Babylon mesh when the load is complete
+     */
+    GLTFLoader.prototype.loadNodeAsync = function (context, node, assign) {
+        var _this = this;
+        if (assign === void 0) { assign = function () { }; }
+        var extensionPromise = this._extensionsLoadNodeAsync(context, node, assign);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        if (node._babylonTransformNode) {
+            throw new Error("".concat(context, ": Invalid recursive node hierarchy"));
+        }
+        var promises = new Array();
+        this.logOpen("".concat(context, " ").concat(node.name || ""));
+        var loadNode = function (babylonTransformNode) {
+            GLTFLoader.AddPointerMetadata(babylonTransformNode, context);
+            GLTFLoader._LoadTransform(node, babylonTransformNode);
+            if (node.camera != undefined) {
+                var camera = ArrayItem.Get("".concat(context, "/camera"), _this._gltf.cameras, node.camera);
+                promises.push(_this.loadCameraAsync("/cameras/".concat(camera.index), camera, function (babylonCamera) {
+                    babylonCamera.parent = babylonTransformNode;
+                }));
+            }
+            if (node.children) {
+                for (var _i = 0, _a = node.children; _i < _a.length; _i++) {
+                    var index = _a[_i];
+                    var childNode = ArrayItem.Get("".concat(context, "/children/").concat(index), _this._gltf.nodes, index);
+                    promises.push(_this.loadNodeAsync("/nodes/".concat(childNode.index), childNode, function (childBabylonMesh) {
+                        childBabylonMesh.parent = babylonTransformNode;
+                    }));
+                }
+            }
+            assign(babylonTransformNode);
+        };
+        if (node.mesh == undefined || node.skin != undefined) {
+            var nodeName = node.name || "node".concat(node.index);
+            this._babylonScene._blockEntityCollection = !!this._assetContainer;
+            var transformNode = new TransformNode(nodeName, this._babylonScene);
+            transformNode._parentContainer = this._assetContainer;
+            this._babylonScene._blockEntityCollection = false;
+            if (node.mesh == undefined) {
+                node._babylonTransformNode = transformNode;
+            }
+            else {
+                node._babylonTransformNodeForSkin = transformNode;
+            }
+            loadNode(transformNode);
+        }
+        if (node.mesh != undefined) {
+            if (node.skin == undefined) {
+                var mesh = ArrayItem.Get("".concat(context, "/mesh"), this._gltf.meshes, node.mesh);
+                promises.push(this._loadMeshAsync("/meshes/".concat(mesh.index), node, mesh, loadNode));
+            }
+            else {
+                // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
+                // This code path will place the skinned mesh as a sibling of the skeleton root node without loading the
+                // transform, which effectively ignores the transform of the skinned mesh, as per spec.
+                var mesh = ArrayItem.Get("".concat(context, "/mesh"), this._gltf.meshes, node.mesh);
+                promises.push(this._loadMeshAsync("/meshes/".concat(mesh.index), node, mesh, function (babylonTransformNode) {
+                    // Duplicate the metadata from the skin node to the skinned mesh in case any loader extension added metadata.
+                    babylonTransformNode.metadata = node._babylonTransformNodeForSkin.metadata;
+                    var skin = ArrayItem.Get("".concat(context, "/skin"), _this._gltf.skins, node.skin);
+                    promises.push(_this._loadSkinAsync("/skins/".concat(skin.index), node, skin, function (babylonSkeleton) {
+                        _this._forEachPrimitive(node, function (babylonMesh) {
+                            babylonMesh.skeleton = babylonSkeleton;
+                        });
+                        // Wait until the scene is loaded to ensure the skeleton root node has been loaded.
+                        _this._postSceneLoadActions.push(function () {
+                            if (skin.skeleton != undefined) {
+                                // Place the skinned mesh node as a sibling of the skeleton root node.
+                                var skeletonRootNode = ArrayItem.Get("/skins/".concat(skin.index, "/skeleton"), _this._gltf.nodes, skin.skeleton);
+                                babylonTransformNode.parent = skeletonRootNode.parent._babylonTransformNode;
+                            }
+                            else {
+                                babylonTransformNode.parent = _this._rootBabylonMesh;
+                            }
+                        });
+                    }));
+                }));
+            }
+        }
+        this.logClose();
+        return Promise.all(promises).then(function () {
+            _this._forEachPrimitive(node, function (babylonMesh) {
+                if (babylonMesh.geometry && babylonMesh.geometry.useBoundingInfoFromGeometry) {
+                    // simply apply the world matrices to the bounding info - the extends are already ok
+                    babylonMesh._updateBoundingInfo();
+                }
+                else {
+                    babylonMesh.refreshBoundingInfo(true);
+                }
+            });
+            return node._babylonTransformNode;
+        });
+    };
+    GLTFLoader.prototype._loadMeshAsync = function (context, node, mesh, assign) {
+        var primitives = mesh.primitives;
+        if (!primitives || !primitives.length) {
+            throw new Error("".concat(context, ": Primitives are missing"));
+        }
+        if (primitives[0].index == undefined) {
+            ArrayItem.Assign(primitives);
+        }
+        var promises = new Array();
+        this.logOpen("".concat(context, " ").concat(mesh.name || ""));
+        var name = node.name || "node".concat(node.index);
+        if (primitives.length === 1) {
+            var primitive = mesh.primitives[0];
+            promises.push(this._loadMeshPrimitiveAsync("".concat(context, "/primitives/").concat(primitive.index), name, node, mesh, primitive, function (babylonMesh) {
+                node._babylonTransformNode = babylonMesh;
+                node._primitiveBabylonMeshes = [babylonMesh];
+            }));
+        }
+        else {
+            this._babylonScene._blockEntityCollection = !!this._assetContainer;
+            node._babylonTransformNode = new TransformNode(name, this._babylonScene);
+            node._babylonTransformNode._parentContainer = this._assetContainer;
+            this._babylonScene._blockEntityCollection = false;
+            node._primitiveBabylonMeshes = [];
+            for (var _i = 0, primitives_1 = primitives; _i < primitives_1.length; _i++) {
+                var primitive = primitives_1[_i];
+                promises.push(this._loadMeshPrimitiveAsync("".concat(context, "/primitives/").concat(primitive.index), "".concat(name, "_primitive").concat(primitive.index), node, mesh, primitive, function (babylonMesh) {
+                    babylonMesh.parent = node._babylonTransformNode;
+                    node._primitiveBabylonMeshes.push(babylonMesh);
+                }));
+            }
+        }
+        assign(node._babylonTransformNode);
+        this.logClose();
+        return Promise.all(promises).then(function () {
+            return node._babylonTransformNode;
+        });
+    };
+    /**
+     * @hidden Define this method to modify the default behavior when loading data for mesh primitives.
+     * @param context The context when loading the asset
+     * @param name The mesh name when loading the asset
+     * @param node The glTF node when loading the asset
+     * @param mesh The glTF mesh when loading the asset
+     * @param primitive The glTF mesh primitive property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled
+     */
+    GLTFLoader.prototype._loadMeshPrimitiveAsync = function (context, name, node, mesh, primitive, assign) {
+        var _this = this;
+        var extensionPromise = this._extensionsLoadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        this.logOpen("".concat(context));
+        var shouldInstance = this._disableInstancedMesh === 0 && this._parent.createInstances && node.skin == undefined && !mesh.primitives[0].targets;
+        var babylonAbstractMesh;
+        var promise;
+        if (shouldInstance && primitive._instanceData) {
+            this._babylonScene._blockEntityCollection = !!this._assetContainer;
+            babylonAbstractMesh = primitive._instanceData.babylonSourceMesh.createInstance(name);
+            babylonAbstractMesh._parentContainer = this._assetContainer;
+            this._babylonScene._blockEntityCollection = false;
+            promise = primitive._instanceData.promise;
+        }
+        else {
+            var promises = new Array();
+            this._babylonScene._blockEntityCollection = !!this._assetContainer;
+            var babylonMesh_1 = new Mesh(name, this._babylonScene);
+            babylonMesh_1._parentContainer = this._assetContainer;
+            this._babylonScene._blockEntityCollection = false;
+            babylonMesh_1.overrideMaterialSideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
+            this._createMorphTargets(context, node, mesh, primitive, babylonMesh_1);
+            promises.push(this._loadVertexDataAsync(context, primitive, babylonMesh_1).then(function (babylonGeometry) {
+                return _this._loadMorphTargetsAsync(context, primitive, babylonMesh_1, babylonGeometry).then(function () {
+                    _this._babylonScene._blockEntityCollection = !!_this._assetContainer;
+                    babylonGeometry.applyToMesh(babylonMesh_1);
+                    babylonGeometry._parentContainer = _this._assetContainer;
+                    _this._babylonScene._blockEntityCollection = false;
+                });
+            }));
+            var babylonDrawMode = GLTFLoader._GetDrawMode(context, primitive.mode);
+            if (primitive.material == undefined) {
+                var babylonMaterial = this._defaultBabylonMaterialData[babylonDrawMode];
+                if (!babylonMaterial) {
+                    babylonMaterial = this._createDefaultMaterial("__GLTFLoader._default", babylonDrawMode);
+                    this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
+                    this._defaultBabylonMaterialData[babylonDrawMode] = babylonMaterial;
+                }
+                babylonMesh_1.material = babylonMaterial;
+            }
+            else if (!this.parent.skipMaterials) {
+                var material = ArrayItem.Get("".concat(context, "/material"), this._gltf.materials, primitive.material);
+                promises.push(this._loadMaterialAsync("/materials/".concat(material.index), material, babylonMesh_1, babylonDrawMode, function (babylonMaterial) {
+                    babylonMesh_1.material = babylonMaterial;
+                }));
+            }
+            promise = Promise.all(promises);
+            if (shouldInstance) {
+                primitive._instanceData = {
+                    babylonSourceMesh: babylonMesh_1,
+                    promise: promise,
+                };
+            }
+            babylonAbstractMesh = babylonMesh_1;
+        }
+        GLTFLoader.AddPointerMetadata(babylonAbstractMesh, context);
+        this._parent.onMeshLoadedObservable.notifyObservers(babylonAbstractMesh);
+        assign(babylonAbstractMesh);
+        this.logClose();
+        return promise.then(function () {
+            return babylonAbstractMesh;
+        });
+    };
+    GLTFLoader.prototype._loadVertexDataAsync = function (context, primitive, babylonMesh) {
+        var _this = this;
+        var extensionPromise = this._extensionsLoadVertexDataAsync(context, primitive, babylonMesh);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        var attributes = primitive.attributes;
+        if (!attributes) {
+            throw new Error("".concat(context, ": Attributes are missing"));
+        }
+        var promises = new Array();
+        var babylonGeometry = new Geometry(babylonMesh.name, this._babylonScene);
+        if (primitive.indices == undefined) {
+            babylonMesh.isUnIndexed = true;
+        }
+        else {
+            var accessor = ArrayItem.Get("".concat(context, "/indices"), this._gltf.accessors, primitive.indices);
+            promises.push(this._loadIndicesAccessorAsync("/accessors/".concat(accessor.index), accessor).then(function (data) {
+                babylonGeometry.setIndices(data);
+            }));
+        }
+        var loadAttribute = function (attribute, kind, callback) {
+            if (attributes[attribute] == undefined) {
+                return;
+            }
+            babylonMesh._delayInfo = babylonMesh._delayInfo || [];
+            if (babylonMesh._delayInfo.indexOf(kind) === -1) {
+                babylonMesh._delayInfo.push(kind);
+            }
+            var accessor = ArrayItem.Get("".concat(context, "/attributes/").concat(attribute), _this._gltf.accessors, attributes[attribute]);
+            promises.push(_this._loadVertexAccessorAsync("/accessors/".concat(accessor.index), accessor, kind).then(function (babylonVertexBuffer) {
+                if (babylonVertexBuffer.getKind() === VertexBuffer.PositionKind && !_this.parent.alwaysComputeBoundingBox && !babylonMesh.skeleton) {
+                    var mmin = accessor.min, mmax = accessor.max;
+                    if (mmin !== undefined && mmax !== undefined) {
+                        if (accessor.normalized && accessor.componentType !== 5126 /* FLOAT */) {
+                            var divider = 1;
+                            switch (accessor.componentType) {
+                                case 5120 /* BYTE */:
+                                    divider = 127.0;
+                                    break;
+                                case 5121 /* UNSIGNED_BYTE */:
+                                    divider = 255.0;
+                                    break;
+                                case 5122 /* SHORT */:
+                                    divider = 32767.0;
+                                    break;
+                                case 5123 /* UNSIGNED_SHORT */:
+                                    divider = 65535.0;
+                                    break;
+                            }
+                            for (var i = 0; i < 3; ++i) {
+                                mmin[i] = Math.max(mmin[i] / divider, -1.0);
+                                mmax[i] = Math.max(mmax[i] / divider, -1.0);
+                            }
+                        }
+                        var min = TmpVectors.Vector3[0], max = TmpVectors.Vector3[1];
+                        min.copyFromFloats.apply(min, mmin);
+                        max.copyFromFloats.apply(max, mmax);
+                        babylonGeometry._boundingInfo = new BoundingInfo(min, max);
+                        babylonGeometry.useBoundingInfoFromGeometry = true;
+                    }
+                }
+                babylonGeometry.setVerticesBuffer(babylonVertexBuffer, accessor.count);
+            }));
+            if (kind == VertexBuffer.MatricesIndicesExtraKind) {
+                babylonMesh.numBoneInfluencers = 8;
+            }
+            if (callback) {
+                callback(accessor);
+            }
+        };
+        loadAttribute("POSITION", VertexBuffer.PositionKind);
+        loadAttribute("NORMAL", VertexBuffer.NormalKind);
+        loadAttribute("TANGENT", VertexBuffer.TangentKind);
+        loadAttribute("TEXCOORD_0", VertexBuffer.UVKind);
+        loadAttribute("TEXCOORD_1", VertexBuffer.UV2Kind);
+        loadAttribute("TEXCOORD_2", VertexBuffer.UV3Kind);
+        loadAttribute("TEXCOORD_3", VertexBuffer.UV4Kind);
+        loadAttribute("TEXCOORD_4", VertexBuffer.UV5Kind);
+        loadAttribute("TEXCOORD_5", VertexBuffer.UV6Kind);
+        loadAttribute("JOINTS_0", VertexBuffer.MatricesIndicesKind);
+        loadAttribute("WEIGHTS_0", VertexBuffer.MatricesWeightsKind);
+        loadAttribute("JOINTS_1", VertexBuffer.MatricesIndicesExtraKind);
+        loadAttribute("WEIGHTS_1", VertexBuffer.MatricesWeightsExtraKind);
+        loadAttribute("COLOR_0", VertexBuffer.ColorKind, function (accessor) {
+            if (accessor.type === "VEC4" /* VEC4 */) {
+                babylonMesh.hasVertexAlpha = true;
+            }
+        });
+        return Promise.all(promises).then(function () {
+            return babylonGeometry;
+        });
+    };
+    GLTFLoader.prototype._createMorphTargets = function (context, node, mesh, primitive, babylonMesh) {
+        if (!primitive.targets) {
+            return;
+        }
+        if (node._numMorphTargets == undefined) {
+            node._numMorphTargets = primitive.targets.length;
+        }
+        else if (primitive.targets.length !== node._numMorphTargets) {
+            throw new Error("".concat(context, ": Primitives do not have the same number of targets"));
+        }
+        var targetNames = mesh.extras ? mesh.extras.targetNames : null;
+        babylonMesh.morphTargetManager = new MorphTargetManager(babylonMesh.getScene());
+        babylonMesh.morphTargetManager.areUpdatesFrozen = true;
+        for (var index = 0; index < primitive.targets.length; index++) {
+            var weight = node.weights ? node.weights[index] : mesh.weights ? mesh.weights[index] : 0;
+            var name_3 = targetNames ? targetNames[index] : "morphTarget".concat(index);
+            babylonMesh.morphTargetManager.addTarget(new MorphTarget(name_3, weight, babylonMesh.getScene()));
+            // TODO: tell the target whether it has positions, normals, tangents
+        }
+    };
+    GLTFLoader.prototype._loadMorphTargetsAsync = function (context, primitive, babylonMesh, babylonGeometry) {
+        if (!primitive.targets) {
+            return Promise.resolve();
+        }
+        var promises = new Array();
+        var morphTargetManager = babylonMesh.morphTargetManager;
+        for (var index = 0; index < morphTargetManager.numTargets; index++) {
+            var babylonMorphTarget = morphTargetManager.getTarget(index);
+            promises.push(this._loadMorphTargetVertexDataAsync("".concat(context, "/targets/").concat(index), babylonGeometry, primitive.targets[index], babylonMorphTarget));
+        }
+        return Promise.all(promises).then(function () {
+            morphTargetManager.areUpdatesFrozen = false;
+        });
+    };
+    GLTFLoader.prototype._loadMorphTargetVertexDataAsync = function (context, babylonGeometry, attributes, babylonMorphTarget) {
+        var _this = this;
+        var promises = new Array();
+        var loadAttribute = function (attribute, kind, setData) {
+            if (attributes[attribute] == undefined) {
+                return;
+            }
+            var babylonVertexBuffer = babylonGeometry.getVertexBuffer(kind);
+            if (!babylonVertexBuffer) {
+                return;
+            }
+            var accessor = ArrayItem.Get("".concat(context, "/").concat(attribute), _this._gltf.accessors, attributes[attribute]);
+            promises.push(_this._loadFloatAccessorAsync("/accessors/".concat(accessor.index), accessor).then(function (data) {
+                setData(babylonVertexBuffer, data);
+            }));
+        };
+        loadAttribute("POSITION", VertexBuffer.PositionKind, function (babylonVertexBuffer, data) {
+            var positions = new Float32Array(data.length);
+            babylonVertexBuffer.forEach(data.length, function (value, index) {
+                positions[index] = data[index] + value;
+            });
+            babylonMorphTarget.setPositions(positions);
+        });
+        loadAttribute("NORMAL", VertexBuffer.NormalKind, function (babylonVertexBuffer, data) {
+            var normals = new Float32Array(data.length);
+            babylonVertexBuffer.forEach(normals.length, function (value, index) {
+                normals[index] = data[index] + value;
+            });
+            babylonMorphTarget.setNormals(normals);
+        });
+        loadAttribute("TANGENT", VertexBuffer.TangentKind, function (babylonVertexBuffer, data) {
+            var tangents = new Float32Array((data.length / 3) * 4);
+            var dataIndex = 0;
+            babylonVertexBuffer.forEach((data.length / 3) * 4, function (value, index) {
+                // Tangent data for morph targets is stored as xyz delta.
+                // The vertexData.tangent is stored as xyzw.
+                // So we need to skip every fourth vertexData.tangent.
+                if ((index + 1) % 4 !== 0) {
+                    tangents[dataIndex] = data[dataIndex] + value;
+                    dataIndex++;
+                }
+            });
+            babylonMorphTarget.setTangents(tangents);
+        });
+        return Promise.all(promises).then(function () { });
+    };
+    GLTFLoader._LoadTransform = function (node, babylonNode) {
+        // Ignore the TRS of skinned nodes.
+        // See https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins (second implementation note)
+        if (node.skin != undefined) {
+            return;
+        }
+        var position = Vector3.Zero();
+        var rotation = Quaternion.Identity();
+        var scaling = Vector3.One();
+        if (node.matrix) {
+            var matrix = Matrix.FromArray(node.matrix);
+            matrix.decompose(scaling, rotation, position);
+        }
+        else {
+            if (node.translation) {
+                position = Vector3.FromArray(node.translation);
+            }
+            if (node.rotation) {
+                rotation = Quaternion.FromArray(node.rotation);
+            }
+            if (node.scale) {
+                scaling = Vector3.FromArray(node.scale);
+            }
+        }
+        babylonNode.position = position;
+        babylonNode.rotationQuaternion = rotation;
+        babylonNode.scaling = scaling;
+    };
+    GLTFLoader.prototype._loadSkinAsync = function (context, node, skin, assign) {
+        var _this = this;
+        var extensionPromise = this._extensionsLoadSkinAsync(context, node, skin);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        if (skin._data) {
+            assign(skin._data.babylonSkeleton);
+            return skin._data.promise;
+        }
+        var skeletonId = "skeleton".concat(skin.index);
+        this._babylonScene._blockEntityCollection = !!this._assetContainer;
+        var babylonSkeleton = new Skeleton(skin.name || skeletonId, skeletonId, this._babylonScene);
+        babylonSkeleton._parentContainer = this._assetContainer;
+        this._babylonScene._blockEntityCollection = false;
+        this._loadBones(context, skin, babylonSkeleton);
+        var promise = this._loadSkinInverseBindMatricesDataAsync(context, skin).then(function (inverseBindMatricesData) {
+            _this._updateBoneMatrices(babylonSkeleton, inverseBindMatricesData);
+        });
+        skin._data = {
+            babylonSkeleton: babylonSkeleton,
+            promise: promise,
+        };
+        assign(babylonSkeleton);
+        return promise;
+    };
+    GLTFLoader.prototype._loadBones = function (context, skin, babylonSkeleton) {
+        if (skin.skeleton == undefined || this._parent.alwaysComputeSkeletonRootNode) {
+            var rootNode = this._findSkeletonRootNode("".concat(context, "/joints"), skin.joints);
+            if (rootNode) {
+                if (skin.skeleton === undefined) {
+                    skin.skeleton = rootNode.index;
+                }
+                else {
+                    var isParent = function (a, b) {
+                        for (; b.parent; b = b.parent) {
+                            if (b.parent === a) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    };
+                    var skeletonNode = ArrayItem.Get("".concat(context, "/skeleton"), this._gltf.nodes, skin.skeleton);
+                    if (skeletonNode !== rootNode && !isParent(skeletonNode, rootNode)) {
+                        Logger.Warn("".concat(context, "/skeleton: Overriding with nearest common ancestor as skeleton node is not a common root"));
+                        skin.skeleton = rootNode.index;
+                    }
+                }
+            }
+            else {
+                Logger.Warn("".concat(context, ": Failed to find common root"));
+            }
+        }
+        var babylonBones = {};
+        for (var _i = 0, _a = skin.joints; _i < _a.length; _i++) {
+            var index = _a[_i];
+            var node = ArrayItem.Get("".concat(context, "/joints/").concat(index), this._gltf.nodes, index);
+            this._loadBone(node, skin, babylonSkeleton, babylonBones);
+        }
+    };
+    GLTFLoader.prototype._findSkeletonRootNode = function (context, joints) {
+        if (joints.length === 0) {
+            return null;
+        }
+        var paths = {};
+        for (var _i = 0, joints_1 = joints; _i < joints_1.length; _i++) {
+            var index = joints_1[_i];
+            var path = new Array();
+            var node = ArrayItem.Get("".concat(context, "/").concat(index), this._gltf.nodes, index);
+            while (node.index !== -1) {
+                path.unshift(node);
+                node = node.parent;
+            }
+            paths[index] = path;
+        }
+        var rootNode = null;
+        for (var i = 0;; ++i) {
+            var path = paths[joints[0]];
+            if (i >= path.length) {
+                return rootNode;
+            }
+            var node = path[i];
+            for (var j = 1; j < joints.length; ++j) {
+                path = paths[joints[j]];
+                if (i >= path.length || node !== path[i]) {
+                    return rootNode;
+                }
+            }
+            rootNode = node;
+        }
+    };
+    GLTFLoader.prototype._loadBone = function (node, skin, babylonSkeleton, babylonBones) {
+        var babylonBone = babylonBones[node.index];
+        if (babylonBone) {
+            return babylonBone;
+        }
+        var parentBabylonBone = null;
+        if (node.index !== skin.skeleton) {
+            if (node.parent && node.parent.index !== -1) {
+                parentBabylonBone = this._loadBone(node.parent, skin, babylonSkeleton, babylonBones);
+            }
+            else if (skin.skeleton !== undefined) {
+                Logger.Warn("/skins/".concat(skin.index, "/skeleton: Skeleton node is not a common root"));
+            }
+        }
+        var boneIndex = skin.joints.indexOf(node.index);
+        babylonBone = new Bone(node.name || "joint".concat(node.index), babylonSkeleton, parentBabylonBone, this._getNodeMatrix(node), null, null, boneIndex);
+        babylonBones[node.index] = babylonBone;
+        // Wait until the scene is loaded to ensure the transform nodes are loaded.
+        this._postSceneLoadActions.push(function () {
+            // Link the Babylon bone with the corresponding Babylon transform node.
+            // A glTF joint is a pointer to a glTF node in the glTF node hierarchy similar to Unity3D.
+            babylonBone.linkTransformNode(node._babylonTransformNode);
+        });
+        return babylonBone;
+    };
+    GLTFLoader.prototype._loadSkinInverseBindMatricesDataAsync = function (context, skin) {
+        if (skin.inverseBindMatrices == undefined) {
+            return Promise.resolve(null);
+        }
+        var accessor = ArrayItem.Get("".concat(context, "/inverseBindMatrices"), this._gltf.accessors, skin.inverseBindMatrices);
+        return this._loadFloatAccessorAsync("/accessors/".concat(accessor.index), accessor);
+    };
+    GLTFLoader.prototype._updateBoneMatrices = function (babylonSkeleton, inverseBindMatricesData) {
+        for (var _i = 0, _a = babylonSkeleton.bones; _i < _a.length; _i++) {
+            var babylonBone = _a[_i];
+            var baseMatrix = Matrix.Identity();
+            var boneIndex = babylonBone._index;
+            if (inverseBindMatricesData && boneIndex !== -1) {
+                Matrix.FromArrayToRef(inverseBindMatricesData, boneIndex * 16, baseMatrix);
+                baseMatrix.invertToRef(baseMatrix);
+            }
+            var babylonParentBone = babylonBone.getParent();
+            if (babylonParentBone) {
+                baseMatrix.multiplyToRef(babylonParentBone.getInvertedAbsoluteTransform(), baseMatrix);
+            }
+            babylonBone.updateMatrix(baseMatrix, false, false);
+            babylonBone._updateDifferenceMatrix(undefined, false);
+        }
+    };
+    GLTFLoader.prototype._getNodeMatrix = function (node) {
+        return node.matrix
+            ? Matrix.FromArray(node.matrix)
+            : Matrix.Compose(node.scale ? Vector3.FromArray(node.scale) : Vector3.One(), node.rotation ? Quaternion.FromArray(node.rotation) : Quaternion.Identity(), node.translation ? Vector3.FromArray(node.translation) : Vector3.Zero());
+    };
+    /**
+     * Loads a glTF camera.
+     * @param context The context when loading the asset
+     * @param camera The glTF camera property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded Babylon camera when the load is complete
+     */
+    GLTFLoader.prototype.loadCameraAsync = function (context, camera, assign) {
+        if (assign === void 0) { assign = function () { }; }
+        var extensionPromise = this._extensionsLoadCameraAsync(context, camera, assign);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        var promises = new Array();
+        this.logOpen("".concat(context, " ").concat(camera.name || ""));
+        this._babylonScene._blockEntityCollection = !!this._assetContainer;
+        var babylonCamera = new FreeCamera(camera.name || "camera".concat(camera.index), Vector3.Zero(), this._babylonScene, false);
+        babylonCamera._parentContainer = this._assetContainer;
+        this._babylonScene._blockEntityCollection = false;
+        babylonCamera.ignoreParentScaling = true;
+        babylonCamera.rotation = new Vector3(0, Math.PI, 0);
+        switch (camera.type) {
+            case "perspective" /* PERSPECTIVE */: {
+                var perspective = camera.perspective;
+                if (!perspective) {
+                    throw new Error("".concat(context, ": Camera perspective properties are missing"));
+                }
+                babylonCamera.fov = perspective.yfov;
+                babylonCamera.minZ = perspective.znear;
+                babylonCamera.maxZ = perspective.zfar || 0;
+                break;
+            }
+            case "orthographic" /* ORTHOGRAPHIC */: {
+                if (!camera.orthographic) {
+                    throw new Error("".concat(context, ": Camera orthographic properties are missing"));
+                }
+                babylonCamera.mode = Camera.ORTHOGRAPHIC_CAMERA;
+                babylonCamera.orthoLeft = -camera.orthographic.xmag;
+                babylonCamera.orthoRight = camera.orthographic.xmag;
+                babylonCamera.orthoBottom = -camera.orthographic.ymag;
+                babylonCamera.orthoTop = camera.orthographic.ymag;
+                babylonCamera.minZ = camera.orthographic.znear;
+                babylonCamera.maxZ = camera.orthographic.zfar;
+                break;
+            }
+            default: {
+                throw new Error("".concat(context, ": Invalid camera type (").concat(camera.type, ")"));
+            }
+        }
+        GLTFLoader.AddPointerMetadata(babylonCamera, context);
+        this._parent.onCameraLoadedObservable.notifyObservers(babylonCamera);
+        assign(babylonCamera);
+        this.logClose();
+        return Promise.all(promises).then(function () {
+            return babylonCamera;
+        });
+    };
+    GLTFLoader.prototype._loadAnimationsAsync = function () {
+        var animations = this._gltf.animations;
+        if (!animations) {
+            return Promise.resolve();
+        }
+        var promises = new Array();
+        for (var index = 0; index < animations.length; index++) {
+            var animation = animations[index];
+            promises.push(this.loadAnimationAsync("/animations/".concat(animation.index), animation).then(function (animationGroup) {
+                // Delete the animation group if it ended up not having any animations in it.
+                if (animationGroup.targetedAnimations.length === 0) {
+                    animationGroup.dispose();
+                }
+            }));
+        }
+        return Promise.all(promises).then(function () { });
+    };
+    /**
+     * Loads a glTF animation.
+     * @param context The context when loading the asset
+     * @param animation The glTF animation property
+     * @returns A promise that resolves with the loaded Babylon animation group when the load is complete
+     */
+    GLTFLoader.prototype.loadAnimationAsync = function (context, animation) {
+        var promise = this._extensionsLoadAnimationAsync(context, animation);
+        if (promise) {
+            return promise;
+        }
+        this._babylonScene._blockEntityCollection = !!this._assetContainer;
+        var babylonAnimationGroup = new AnimationGroup(animation.name || "animation".concat(animation.index), this._babylonScene);
+        babylonAnimationGroup._parentContainer = this._assetContainer;
+        this._babylonScene._blockEntityCollection = false;
+        animation._babylonAnimationGroup = babylonAnimationGroup;
+        var promises = new Array();
+        ArrayItem.Assign(animation.channels);
+        ArrayItem.Assign(animation.samplers);
+        for (var _i = 0, _a = animation.channels; _i < _a.length; _i++) {
+            var channel = _a[_i];
+            promises.push(this._loadAnimationChannelAsync("".concat(context, "/channels/").concat(channel.index), context, animation, channel, babylonAnimationGroup));
+        }
+        return Promise.all(promises).then(function () {
+            babylonAnimationGroup.normalize(0);
+            return babylonAnimationGroup;
+        });
+    };
+    /**
+     * @hidden Loads a glTF animation channel.
+     * @param context The context when loading the asset
+     * @param animationContext The context of the animation when loading the asset
+     * @param animation The glTF animation property
+     * @param channel The glTF animation channel property
+     * @param babylonAnimationGroup The babylon animation group property
+     * @param animationTargetOverride The babylon animation channel target override property. My be null.
+     * @returns A void promise when the channel load is complete
+     */
+    GLTFLoader.prototype._loadAnimationChannelAsync = function (context, animationContext, animation, channel, babylonAnimationGroup, animationTargetOverride) {
+        var _this = this;
+        if (animationTargetOverride === void 0) { animationTargetOverride = null; }
+        if (channel.target.node == undefined) {
+            return Promise.resolve();
+        }
+        var targetNode = ArrayItem.Get("".concat(context, "/target/node"), this._gltf.nodes, channel.target.node);
+        // Ignore animations that have no animation targets.
+        if ((channel.target.path === "weights" /* WEIGHTS */ && !targetNode._numMorphTargets) ||
+            (channel.target.path !== "weights" /* WEIGHTS */ && !targetNode._babylonTransformNode)) {
+            return Promise.resolve();
+        }
+        var sampler = ArrayItem.Get("".concat(context, "/sampler"), animation.samplers, channel.sampler);
+        return this._loadAnimationSamplerAsync("".concat(animationContext, "/samplers/").concat(channel.sampler), sampler).then(function (data) {
+            var targetPath;
+            var animationType;
+            switch (channel.target.path) {
+                case "translation" /* TRANSLATION */: {
+                    targetPath = "position";
+                    animationType = Animation.ANIMATIONTYPE_VECTOR3;
+                    break;
+                }
+                case "rotation" /* ROTATION */: {
+                    targetPath = "rotationQuaternion";
+                    animationType = Animation.ANIMATIONTYPE_QUATERNION;
+                    break;
+                }
+                case "scale" /* SCALE */: {
+                    targetPath = "scaling";
+                    animationType = Animation.ANIMATIONTYPE_VECTOR3;
+                    break;
+                }
+                case "weights" /* WEIGHTS */: {
+                    targetPath = "influence";
+                    animationType = Animation.ANIMATIONTYPE_FLOAT;
+                    break;
+                }
+                default: {
+                    throw new Error("".concat(context, "/target/path: Invalid value (").concat(channel.target.path, ")"));
+                }
+            }
+            var outputBufferOffset = 0;
+            var getNextOutputValue;
+            switch (targetPath) {
+                case "position": {
+                    getNextOutputValue = function (scale) {
+                        var value = Vector3.FromArray(data.output, outputBufferOffset).scaleInPlace(scale);
+                        outputBufferOffset += 3;
+                        return value;
+                    };
+                    break;
+                }
+                case "rotationQuaternion": {
+                    getNextOutputValue = function (scale) {
+                        var value = Quaternion.FromArray(data.output, outputBufferOffset).scaleInPlace(scale);
+                        outputBufferOffset += 4;
+                        return value;
+                    };
+                    break;
+                }
+                case "scaling": {
+                    getNextOutputValue = function (scale) {
+                        var value = Vector3.FromArray(data.output, outputBufferOffset).scaleInPlace(scale);
+                        outputBufferOffset += 3;
+                        return value;
+                    };
+                    break;
+                }
+                case "influence": {
+                    getNextOutputValue = function (scale) {
+                        var value = new Array(targetNode._numMorphTargets);
+                        for (var i = 0; i < targetNode._numMorphTargets; i++) {
+                            value[i] = data.output[outputBufferOffset++] * scale;
+                        }
+                        return value;
+                    };
+                    break;
+                }
+            }
+            var getNextKey;
+            switch (data.interpolation) {
+                case "STEP" /* STEP */: {
+                    getNextKey = function (frameIndex) { return ({
+                        frame: data.input[frameIndex] * _this.parent.targetFps,
+                        value: getNextOutputValue(1),
+                        interpolation: AnimationKeyInterpolation.STEP,
+                    }); };
+                    break;
+                }
+                case "LINEAR" /* LINEAR */: {
+                    getNextKey = function (frameIndex) { return ({
+                        frame: data.input[frameIndex] * _this.parent.targetFps,
+                        value: getNextOutputValue(1),
+                    }); };
+                    break;
+                }
+                case "CUBICSPLINE" /* CUBICSPLINE */: {
+                    var invTargetFps_1 = 1 / _this.parent.targetFps;
+                    getNextKey = function (frameIndex) { return ({
+                        frame: data.input[frameIndex] * _this.parent.targetFps,
+                        inTangent: getNextOutputValue(invTargetFps_1),
+                        value: getNextOutputValue(1),
+                        outTangent: getNextOutputValue(invTargetFps_1),
+                    }); };
+                    break;
+                }
+            }
+            var keys = new Array(data.input.length);
+            for (var frameIndex = 0; frameIndex < data.input.length; frameIndex++) {
+                keys[frameIndex] = getNextKey(frameIndex);
+            }
+            if (targetPath === "influence") {
+                var _loop_2 = function (targetIndex) {
+                    var animationName = "".concat(babylonAnimationGroup.name, "_channel").concat(babylonAnimationGroup.targetedAnimations.length);
+                    var babylonAnimation = new Animation(animationName, targetPath, _this.parent.targetFps, animationType);
+                    babylonAnimation.setKeys(keys.map(function (key) { return ({
+                        frame: key.frame,
+                        inTangent: key.inTangent ? key.inTangent[targetIndex] : undefined,
+                        value: key.value[targetIndex],
+                        outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined,
+                    }); }));
+                    _this._forEachPrimitive(targetNode, function (babylonAbstractMesh) {
+                        var babylonMesh = babylonAbstractMesh;
+                        var morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);
+                        var babylonAnimationClone = babylonAnimation.clone();
+                        morphTarget.animations.push(babylonAnimationClone);
+                        babylonAnimationGroup.addTargetedAnimation(babylonAnimationClone, morphTarget);
+                    });
+                };
+                for (var targetIndex = 0; targetIndex < targetNode._numMorphTargets; targetIndex++) {
+                    _loop_2(targetIndex);
+                }
+            }
+            else {
+                var animationName = "".concat(babylonAnimationGroup.name, "_channel").concat(babylonAnimationGroup.targetedAnimations.length);
+                var babylonAnimation = new Animation(animationName, targetPath, _this.parent.targetFps, animationType);
+                babylonAnimation.setKeys(keys);
+                if (animationTargetOverride != null && animationTargetOverride.animations != null) {
+                    animationTargetOverride.animations.push(babylonAnimation);
+                    babylonAnimationGroup.addTargetedAnimation(babylonAnimation, animationTargetOverride);
+                }
+                else {
+                    targetNode._babylonTransformNode.animations.push(babylonAnimation);
+                    babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonTransformNode);
+                }
+            }
+        });
+    };
+    GLTFLoader.prototype._loadAnimationSamplerAsync = function (context, sampler) {
+        if (sampler._data) {
+            return sampler._data;
+        }
+        var interpolation = sampler.interpolation || "LINEAR" /* LINEAR */;
+        switch (interpolation) {
+            case "STEP" /* STEP */:
+            case "LINEAR" /* LINEAR */:
+            case "CUBICSPLINE" /* CUBICSPLINE */: {
+                break;
+            }
+            default: {
+                throw new Error("".concat(context, "/interpolation: Invalid value (").concat(sampler.interpolation, ")"));
+            }
+        }
+        var inputAccessor = ArrayItem.Get("".concat(context, "/input"), this._gltf.accessors, sampler.input);
+        var outputAccessor = ArrayItem.Get("".concat(context, "/output"), this._gltf.accessors, sampler.output);
+        sampler._data = Promise.all([
+            this._loadFloatAccessorAsync("/accessors/".concat(inputAccessor.index), inputAccessor),
+            this._loadFloatAccessorAsync("/accessors/".concat(outputAccessor.index), outputAccessor),
+        ]).then(function (_a) {
+            var inputData = _a[0], outputData = _a[1];
+            return {
+                input: inputData,
+                interpolation: interpolation,
+                output: outputData,
+            };
+        });
+        return sampler._data;
+    };
+    /**
+     * Loads a glTF buffer.
+     * @param context The context when loading the asset
+     * @param buffer The glTF buffer property
+     * @param byteOffset The byte offset to use
+     * @param byteLength The byte length to use
+     * @returns A promise that resolves with the loaded data when the load is complete
+     */
+    GLTFLoader.prototype.loadBufferAsync = function (context, buffer, byteOffset, byteLength) {
+        var extensionPromise = this._extensionsLoadBufferAsync(context, buffer, byteOffset, byteLength);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        if (!buffer._data) {
+            if (buffer.uri) {
+                buffer._data = this.loadUriAsync("".concat(context, "/uri"), buffer, buffer.uri);
+            }
+            else {
+                if (!this._bin) {
+                    throw new Error("".concat(context, ": Uri is missing or the binary glTF is missing its binary chunk"));
+                }
+                buffer._data = this._bin.readAsync(0, buffer.byteLength);
+            }
+        }
+        return buffer._data.then(function (data) {
+            try {
+                return new Uint8Array(data.buffer, data.byteOffset + byteOffset, byteLength);
+            }
+            catch (e) {
+                throw new Error("".concat(context, ": ").concat(e.message));
+            }
+        });
+    };
+    /**
+     * Loads a glTF buffer view.
+     * @param context The context when loading the asset
+     * @param bufferView The glTF buffer view property
+     * @returns A promise that resolves with the loaded data when the load is complete
+     */
+    GLTFLoader.prototype.loadBufferViewAsync = function (context, bufferView) {
+        var extensionPromise = this._extensionsLoadBufferViewAsync(context, bufferView);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        if (bufferView._data) {
+            return bufferView._data;
+        }
+        var buffer = ArrayItem.Get("".concat(context, "/buffer"), this._gltf.buffers, bufferView.buffer);
+        bufferView._data = this.loadBufferAsync("/buffers/".concat(buffer.index), buffer, bufferView.byteOffset || 0, bufferView.byteLength);
+        return bufferView._data;
+    };
+    GLTFLoader.prototype._loadAccessorAsync = function (context, accessor, constructor) {
+        var _this = this;
+        if (accessor._data) {
+            return accessor._data;
+        }
+        var numComponents = GLTFLoader._GetNumComponents(context, accessor.type);
+        var byteStride = numComponents * VertexBuffer.GetTypeByteLength(accessor.componentType);
+        var length = numComponents * accessor.count;
+        if (accessor.bufferView == undefined) {
+            accessor._data = Promise.resolve(new constructor(length));
+        }
+        else {
+            var bufferView_1 = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, accessor.bufferView);
+            accessor._data = this.loadBufferViewAsync("/bufferViews/".concat(bufferView_1.index), bufferView_1).then(function (data) {
+                if (accessor.componentType === 5126 /* FLOAT */ && !accessor.normalized && (!bufferView_1.byteStride || bufferView_1.byteStride === byteStride)) {
+                    return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, length);
+                }
+                else {
+                    var typedArray_1 = new constructor(length);
+                    VertexBuffer.ForEach(data, accessor.byteOffset || 0, bufferView_1.byteStride || byteStride, numComponents, accessor.componentType, typedArray_1.length, accessor.normalized || false, function (value, index) {
+                        typedArray_1[index] = value;
+                    });
+                    return typedArray_1;
+                }
+            });
+        }
+        if (accessor.sparse) {
+            var sparse_1 = accessor.sparse;
+            accessor._data = accessor._data.then(function (data) {
+                var typedArray = data;
+                var indicesBufferView = ArrayItem.Get("".concat(context, "/sparse/indices/bufferView"), _this._gltf.bufferViews, sparse_1.indices.bufferView);
+                var valuesBufferView = ArrayItem.Get("".concat(context, "/sparse/values/bufferView"), _this._gltf.bufferViews, sparse_1.values.bufferView);
+                return Promise.all([
+                    _this.loadBufferViewAsync("/bufferViews/".concat(indicesBufferView.index), indicesBufferView),
+                    _this.loadBufferViewAsync("/bufferViews/".concat(valuesBufferView.index), valuesBufferView),
+                ]).then(function (_a) {
+                    var indicesData = _a[0], valuesData = _a[1];
+                    var indices = GLTFLoader._GetTypedArray("".concat(context, "/sparse/indices"), sparse_1.indices.componentType, indicesData, sparse_1.indices.byteOffset, sparse_1.count);
+                    var sparseLength = numComponents * sparse_1.count;
+                    var values;
+                    if (accessor.componentType === 5126 /* FLOAT */ && !accessor.normalized) {
+                        values = GLTFLoader._GetTypedArray("".concat(context, "/sparse/values"), accessor.componentType, valuesData, sparse_1.values.byteOffset, sparseLength);
+                    }
+                    else {
+                        var sparseData = GLTFLoader._GetTypedArray("".concat(context, "/sparse/values"), accessor.componentType, valuesData, sparse_1.values.byteOffset, sparseLength);
+                        values = new constructor(sparseLength);
+                        VertexBuffer.ForEach(sparseData, 0, byteStride, numComponents, accessor.componentType, values.length, accessor.normalized || false, function (value, index) {
+                            values[index] = value;
+                        });
+                    }
+                    var valuesIndex = 0;
+                    for (var indicesIndex = 0; indicesIndex < indices.length; indicesIndex++) {
+                        var dataIndex = indices[indicesIndex] * numComponents;
+                        for (var componentIndex = 0; componentIndex < numComponents; componentIndex++) {
+                            typedArray[dataIndex++] = values[valuesIndex++];
+                        }
+                    }
+                    return typedArray;
+                });
+            });
+        }
+        return accessor._data;
+    };
+    /**
+     * @param context
+     * @param accessor
+     * @hidden
+     */
+    GLTFLoader.prototype._loadFloatAccessorAsync = function (context, accessor) {
+        return this._loadAccessorAsync(context, accessor, Float32Array);
+    };
+    GLTFLoader.prototype._loadIndicesAccessorAsync = function (context, accessor) {
+        if (accessor.type !== "SCALAR" /* SCALAR */) {
+            throw new Error("".concat(context, "/type: Invalid value ").concat(accessor.type));
+        }
+        if (accessor.componentType !== 5121 /* UNSIGNED_BYTE */ &&
+            accessor.componentType !== 5123 /* UNSIGNED_SHORT */ &&
+            accessor.componentType !== 5125 /* UNSIGNED_INT */) {
+            throw new Error("".concat(context, "/componentType: Invalid value ").concat(accessor.componentType));
+        }
+        if (accessor._data) {
+            return accessor._data;
+        }
+        if (accessor.sparse) {
+            var constructor = GLTFLoader._GetTypedArrayConstructor("".concat(context, "/componentType"), accessor.componentType);
+            accessor._data = this._loadAccessorAsync(context, accessor, constructor);
+        }
+        else {
+            var bufferView = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, accessor.bufferView);
+            accessor._data = this.loadBufferViewAsync("/bufferViews/".concat(bufferView.index), bufferView).then(function (data) {
+                return GLTFLoader._GetTypedArray(context, accessor.componentType, data, accessor.byteOffset, accessor.count);
+            });
+        }
+        return accessor._data;
+    };
+    GLTFLoader.prototype._loadVertexBufferViewAsync = function (bufferView) {
+        var _this = this;
+        if (bufferView._babylonBuffer) {
+            return bufferView._babylonBuffer;
+        }
+        bufferView._babylonBuffer = this.loadBufferViewAsync("/bufferViews/".concat(bufferView.index), bufferView).then(function (data) {
+            return new Buffer(_this._babylonScene.getEngine(), data, false);
+        });
+        return bufferView._babylonBuffer;
+    };
+    GLTFLoader.prototype._loadVertexAccessorAsync = function (context, accessor, kind) {
+        var _this = this;
+        var _a;
+        if ((_a = accessor._babylonVertexBuffer) === null || _a === void 0 ? void 0 : _a[kind]) {
+            return accessor._babylonVertexBuffer[kind];
+        }
+        if (!accessor._babylonVertexBuffer) {
+            accessor._babylonVertexBuffer = {};
+        }
+        if (accessor.sparse) {
+            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then(function (data) {
+                return new VertexBuffer(_this._babylonScene.getEngine(), data, kind, false);
+            });
+        }
+        // Load joint indices as a float array since the shaders expect float data but glTF uses unsigned byte/short.
+        // This prevents certain platforms (e.g. D3D) from having to convert the data to float on the fly.
+        else if (kind === VertexBuffer.MatricesIndicesKind || kind === VertexBuffer.MatricesIndicesExtraKind) {
+            accessor._babylonVertexBuffer[kind] = this._loadFloatAccessorAsync(context, accessor).then(function (data) {
+                return new VertexBuffer(_this._babylonScene.getEngine(), data, kind, false);
+            });
+        }
+        else {
+            var bufferView_2 = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, accessor.bufferView);
+            accessor._babylonVertexBuffer[kind] = this._loadVertexBufferViewAsync(bufferView_2).then(function (babylonBuffer) {
+                var size = GLTFLoader._GetNumComponents(context, accessor.type);
+                return new VertexBuffer(_this._babylonScene.getEngine(), babylonBuffer, kind, false, false, bufferView_2.byteStride, false, accessor.byteOffset, size, accessor.componentType, accessor.normalized, true, 1, true);
+            });
+        }
+        return accessor._babylonVertexBuffer[kind];
+    };
+    GLTFLoader.prototype._loadMaterialMetallicRoughnessPropertiesAsync = function (context, properties, babylonMaterial) {
+        if (!(babylonMaterial instanceof PBRMaterial)) {
+            throw new Error("".concat(context, ": Material type not supported"));
+        }
+        var promises = new Array();
+        if (properties) {
+            if (properties.baseColorFactor) {
+                babylonMaterial.albedoColor = Color3.FromArray(properties.baseColorFactor);
+                babylonMaterial.alpha = properties.baseColorFactor[3];
+            }
+            else {
+                babylonMaterial.albedoColor = Color3.White();
+            }
+            babylonMaterial.metallic = properties.metallicFactor == undefined ? 1 : properties.metallicFactor;
+            babylonMaterial.roughness = properties.roughnessFactor == undefined ? 1 : properties.roughnessFactor;
+            if (properties.baseColorTexture) {
+                promises.push(this.loadTextureInfoAsync("".concat(context, "/baseColorTexture"), properties.baseColorTexture, function (texture) {
+                    texture.name = "".concat(babylonMaterial.name, " (Base Color)");
+                    babylonMaterial.albedoTexture = texture;
+                }));
+            }
+            if (properties.metallicRoughnessTexture) {
+                properties.metallicRoughnessTexture.nonColorData = true;
+                promises.push(this.loadTextureInfoAsync("".concat(context, "/metallicRoughnessTexture"), properties.metallicRoughnessTexture, function (texture) {
+                    texture.name = "".concat(babylonMaterial.name, " (Metallic Roughness)");
+                    babylonMaterial.metallicTexture = texture;
+                }));
+                babylonMaterial.useMetallnessFromMetallicTextureBlue = true;
+                babylonMaterial.useRoughnessFromMetallicTextureGreen = true;
+                babylonMaterial.useRoughnessFromMetallicTextureAlpha = false;
+            }
+        }
+        return Promise.all(promises).then(function () { });
+    };
+    /**
+     * @param context
+     * @param material
+     * @param babylonMesh
+     * @param babylonDrawMode
+     * @param assign
+     * @hidden
+     */
+    GLTFLoader.prototype._loadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
+        if (assign === void 0) { assign = function () { }; }
+        var extensionPromise = this._extensionsLoadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        material._data = material._data || {};
+        var babylonData = material._data[babylonDrawMode];
+        if (!babylonData) {
+            this.logOpen("".concat(context, " ").concat(material.name || ""));
+            var babylonMaterial = this.createMaterial(context, material, babylonDrawMode);
+            babylonData = {
+                babylonMaterial: babylonMaterial,
+                babylonMeshes: [],
+                promise: this.loadMaterialPropertiesAsync(context, material, babylonMaterial),
+            };
+            material._data[babylonDrawMode] = babylonData;
+            GLTFLoader.AddPointerMetadata(babylonMaterial, context);
+            this._parent.onMaterialLoadedObservable.notifyObservers(babylonMaterial);
+            this.logClose();
+        }
+        if (babylonMesh) {
+            babylonData.babylonMeshes.push(babylonMesh);
+            babylonMesh.onDisposeObservable.addOnce(function () {
+                var index = babylonData.babylonMeshes.indexOf(babylonMesh);
+                if (index !== -1) {
+                    babylonData.babylonMeshes.splice(index, 1);
+                }
+            });
+        }
+        assign(babylonData.babylonMaterial);
+        return babylonData.promise.then(function () {
+            return babylonData.babylonMaterial;
+        });
+    };
+    GLTFLoader.prototype._createDefaultMaterial = function (name, babylonDrawMode) {
+        this._babylonScene._blockEntityCollection = !!this._assetContainer;
+        var babylonMaterial = new PBRMaterial(name, this._babylonScene);
+        babylonMaterial._parentContainer = this._assetContainer;
+        this._babylonScene._blockEntityCollection = false;
+        // Moved to mesh so user can change materials on gltf meshes: babylonMaterial.sideOrientation = this._babylonScene.useRightHandedSystem ? Material.CounterClockWiseSideOrientation : Material.ClockWiseSideOrientation;
+        babylonMaterial.fillMode = babylonDrawMode;
+        babylonMaterial.enableSpecularAntiAliasing = true;
+        babylonMaterial.useRadianceOverAlpha = !this._parent.transparencyAsCoverage;
+        babylonMaterial.useSpecularOverAlpha = !this._parent.transparencyAsCoverage;
+        babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;
+        babylonMaterial.metallic = 1;
+        babylonMaterial.roughness = 1;
+        return babylonMaterial;
+    };
+    /**
+     * Creates a Babylon material from a glTF material.
+     * @param context The context when loading the asset
+     * @param material The glTF material property
+     * @param babylonDrawMode The draw mode for the Babylon material
+     * @returns The Babylon material
+     */
+    GLTFLoader.prototype.createMaterial = function (context, material, babylonDrawMode) {
+        var extensionPromise = this._extensionsCreateMaterial(context, material, babylonDrawMode);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        var name = material.name || "material".concat(material.index);
+        var babylonMaterial = this._createDefaultMaterial(name, babylonDrawMode);
+        return babylonMaterial;
+    };
+    /**
+     * Loads properties from a glTF material into a Babylon material.
+     * @param context The context when loading the asset
+     * @param material The glTF material property
+     * @param babylonMaterial The Babylon material
+     * @returns A promise that resolves when the load is complete
+     */
+    GLTFLoader.prototype.loadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
+        var extensionPromise = this._extensionsLoadMaterialPropertiesAsync(context, material, babylonMaterial);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        var promises = new Array();
+        promises.push(this.loadMaterialBasePropertiesAsync(context, material, babylonMaterial));
+        if (material.pbrMetallicRoughness) {
+            promises.push(this._loadMaterialMetallicRoughnessPropertiesAsync("".concat(context, "/pbrMetallicRoughness"), material.pbrMetallicRoughness, babylonMaterial));
+        }
+        this.loadMaterialAlphaProperties(context, material, babylonMaterial);
+        return Promise.all(promises).then(function () { });
+    };
+    /**
+     * Loads the normal, occlusion, and emissive properties from a glTF material into a Babylon material.
+     * @param context The context when loading the asset
+     * @param material The glTF material property
+     * @param babylonMaterial The Babylon material
+     * @returns A promise that resolves when the load is complete
+     */
+    GLTFLoader.prototype.loadMaterialBasePropertiesAsync = function (context, material, babylonMaterial) {
+        if (!(babylonMaterial instanceof PBRMaterial)) {
+            throw new Error("".concat(context, ": Material type not supported"));
+        }
+        var promises = new Array();
+        babylonMaterial.emissiveColor = material.emissiveFactor ? Color3.FromArray(material.emissiveFactor) : new Color3(0, 0, 0);
+        if (material.doubleSided) {
+            babylonMaterial.backFaceCulling = false;
+            babylonMaterial.twoSidedLighting = true;
+        }
+        if (material.normalTexture) {
+            material.normalTexture.nonColorData = true;
+            promises.push(this.loadTextureInfoAsync("".concat(context, "/normalTexture"), material.normalTexture, function (texture) {
+                texture.name = "".concat(babylonMaterial.name, " (Normal)");
+                babylonMaterial.bumpTexture = texture;
+            }));
+            babylonMaterial.invertNormalMapX = !this._babylonScene.useRightHandedSystem;
+            babylonMaterial.invertNormalMapY = this._babylonScene.useRightHandedSystem;
+            if (material.normalTexture.scale != undefined) {
+                babylonMaterial.bumpTexture.level = material.normalTexture.scale;
+            }
+            babylonMaterial.forceIrradianceInFragment = true;
+        }
+        if (material.occlusionTexture) {
+            material.occlusionTexture.nonColorData = true;
+            promises.push(this.loadTextureInfoAsync("".concat(context, "/occlusionTexture"), material.occlusionTexture, function (texture) {
+                texture.name = "".concat(babylonMaterial.name, " (Occlusion)");
+                babylonMaterial.ambientTexture = texture;
+            }));
+            babylonMaterial.useAmbientInGrayScale = true;
+            if (material.occlusionTexture.strength != undefined) {
+                babylonMaterial.ambientTextureStrength = material.occlusionTexture.strength;
+            }
+        }
+        if (material.emissiveTexture) {
+            promises.push(this.loadTextureInfoAsync("".concat(context, "/emissiveTexture"), material.emissiveTexture, function (texture) {
+                texture.name = "".concat(babylonMaterial.name, " (Emissive)");
+                babylonMaterial.emissiveTexture = texture;
+            }));
+        }
+        return Promise.all(promises).then(function () { });
+    };
+    /**
+     * Loads the alpha properties from a glTF material into a Babylon material.
+     * Must be called after the setting the albedo texture of the Babylon material when the material has an albedo texture.
+     * @param context The context when loading the asset
+     * @param material The glTF material property
+     * @param babylonMaterial The Babylon material
+     */
+    GLTFLoader.prototype.loadMaterialAlphaProperties = function (context, material, babylonMaterial) {
+        if (!(babylonMaterial instanceof PBRMaterial)) {
+            throw new Error("".concat(context, ": Material type not supported"));
+        }
+        var alphaMode = material.alphaMode || "OPAQUE" /* OPAQUE */;
+        switch (alphaMode) {
+            case "OPAQUE" /* OPAQUE */: {
+                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_OPAQUE;
+                break;
+            }
+            case "MASK" /* MASK */: {
+                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHATEST;
+                babylonMaterial.alphaCutOff = material.alphaCutoff == undefined ? 0.5 : material.alphaCutoff;
+                if (babylonMaterial.albedoTexture) {
+                    babylonMaterial.albedoTexture.hasAlpha = true;
+                }
+                break;
+            }
+            case "BLEND" /* BLEND */: {
+                babylonMaterial.transparencyMode = PBRMaterial.PBRMATERIAL_ALPHABLEND;
+                if (babylonMaterial.albedoTexture) {
+                    babylonMaterial.albedoTexture.hasAlpha = true;
+                    babylonMaterial.useAlphaFromAlbedoTexture = true;
+                }
+                break;
+            }
+            default: {
+                throw new Error("".concat(context, "/alphaMode: Invalid value (").concat(material.alphaMode, ")"));
+            }
+        }
+    };
+    /**
+     * Loads a glTF texture info.
+     * @param context The context when loading the asset
+     * @param textureInfo The glTF texture info property
+     * @param assign A function called synchronously after parsing the glTF properties
+     * @returns A promise that resolves with the loaded Babylon texture when the load is complete
+     */
+    GLTFLoader.prototype.loadTextureInfoAsync = function (context, textureInfo, assign) {
+        var _this = this;
+        if (assign === void 0) { assign = function () { }; }
+        var extensionPromise = this._extensionsLoadTextureInfoAsync(context, textureInfo, assign);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        this.logOpen("".concat(context));
+        if (textureInfo.texCoord >= 6) {
+            throw new Error("".concat(context, "/texCoord: Invalid value (").concat(textureInfo.texCoord, ")"));
+        }
+        var texture = ArrayItem.Get("".concat(context, "/index"), this._gltf.textures, textureInfo.index);
+        texture._textureInfo = textureInfo;
+        var promise = this._loadTextureAsync("/textures/".concat(textureInfo.index), texture, function (babylonTexture) {
+            babylonTexture.coordinatesIndex = textureInfo.texCoord || 0;
+            GLTFLoader.AddPointerMetadata(babylonTexture, context);
+            _this._parent.onTextureLoadedObservable.notifyObservers(babylonTexture);
+            assign(babylonTexture);
+        });
+        this.logClose();
+        return promise;
+    };
+    /**
+     * @param context
+     * @param texture
+     * @param assign
+     * @hidden
+     */
+    GLTFLoader.prototype._loadTextureAsync = function (context, texture, assign) {
+        if (assign === void 0) { assign = function () { }; }
+        var extensionPromise = this._extensionsLoadTextureAsync(context, texture, assign);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        this.logOpen("".concat(context, " ").concat(texture.name || ""));
+        var sampler = texture.sampler == undefined ? GLTFLoader.DefaultSampler : ArrayItem.Get("".concat(context, "/sampler"), this._gltf.samplers, texture.sampler);
+        var image = ArrayItem.Get("".concat(context, "/source"), this._gltf.images, texture.source);
+        var promise = this._createTextureAsync(context, sampler, image, assign, undefined, !texture._textureInfo.nonColorData);
+        this.logClose();
+        return promise;
+    };
+    /**
+     * @param context
+     * @param sampler
+     * @param image
+     * @param assign
+     * @param textureLoaderOptions
+     * @param useSRGBBuffer
+     * @hidden
+     */
+    GLTFLoader.prototype._createTextureAsync = function (context, sampler, image, assign, textureLoaderOptions, useSRGBBuffer) {
+        var _this = this;
+        if (assign === void 0) { assign = function () { }; }
+        var samplerData = this._loadSampler("/samplers/".concat(sampler.index), sampler);
+        var promises = new Array();
+        var deferred = new Deferred();
+        this._babylonScene._blockEntityCollection = !!this._assetContainer;
+        var textureCreationOptions = {
+            noMipmap: samplerData.noMipMaps,
+            invertY: false,
+            samplingMode: samplerData.samplingMode,
+            onLoad: function () {
+                if (!_this._disposed) {
+                    deferred.resolve();
+                }
+            },
+            onError: function (message, exception) {
+                if (!_this._disposed) {
+                    deferred.reject(new Error("".concat(context, ": ").concat(exception && exception.message ? exception.message : message || "Failed to load texture")));
+                }
+            },
+            mimeType: image.mimeType,
+            loaderOptions: textureLoaderOptions,
+            useSRGBBuffer: !!useSRGBBuffer && this._parent.useSRGBBuffers,
+        };
+        var babylonTexture = new Texture(null, this._babylonScene, textureCreationOptions);
+        babylonTexture._parentContainer = this._assetContainer;
+        this._babylonScene._blockEntityCollection = false;
+        promises.push(deferred.promise);
+        promises.push(this.loadImageAsync("/images/".concat(image.index), image).then(function (data) {
+            var name = image.uri || "".concat(_this._fileName, "#image").concat(image.index);
+            var dataUrl = "data:".concat(_this._uniqueRootUrl).concat(name);
+            babylonTexture.updateURL(dataUrl, data);
+        }));
+        babylonTexture.wrapU = samplerData.wrapU;
+        babylonTexture.wrapV = samplerData.wrapV;
+        assign(babylonTexture);
+        return Promise.all(promises).then(function () {
+            return babylonTexture;
+        });
+    };
+    GLTFLoader.prototype._loadSampler = function (context, sampler) {
+        if (!sampler._data) {
+            sampler._data = {
+                noMipMaps: sampler.minFilter === 9728 /* NEAREST */ || sampler.minFilter === 9729 /* LINEAR */,
+                samplingMode: GLTFLoader._GetTextureSamplingMode(context, sampler),
+                wrapU: GLTFLoader._GetTextureWrapMode("".concat(context, "/wrapS"), sampler.wrapS),
+                wrapV: GLTFLoader._GetTextureWrapMode("".concat(context, "/wrapT"), sampler.wrapT),
+            };
+        }
+        return sampler._data;
+    };
+    /**
+     * Loads a glTF image.
+     * @param context The context when loading the asset
+     * @param image The glTF image property
+     * @returns A promise that resolves with the loaded data when the load is complete
+     */
+    GLTFLoader.prototype.loadImageAsync = function (context, image) {
+        if (!image._data) {
+            this.logOpen("".concat(context, " ").concat(image.name || ""));
+            if (image.uri) {
+                image._data = this.loadUriAsync("".concat(context, "/uri"), image, image.uri);
+            }
+            else {
+                var bufferView = ArrayItem.Get("".concat(context, "/bufferView"), this._gltf.bufferViews, image.bufferView);
+                image._data = this.loadBufferViewAsync("/bufferViews/".concat(bufferView.index), bufferView);
+            }
+            this.logClose();
+        }
+        return image._data;
+    };
+    /**
+     * Loads a glTF uri.
+     * @param context The context when loading the asset
+     * @param property The glTF property associated with the uri
+     * @param uri The base64 or relative uri
+     * @returns A promise that resolves with the loaded data when the load is complete
+     */
+    GLTFLoader.prototype.loadUriAsync = function (context, property, uri) {
+        var _this = this;
+        var extensionPromise = this._extensionsLoadUriAsync(context, property, uri);
+        if (extensionPromise) {
+            return extensionPromise;
+        }
+        if (!GLTFLoader._ValidateUri(uri)) {
+            throw new Error("".concat(context, ": '").concat(uri, "' is invalid"));
+        }
+        if (IsBase64DataUrl(uri)) {
+            var data = new Uint8Array(DecodeBase64UrlToBinary(uri));
+            this.log("".concat(context, ": Decoded ").concat(uri.substr(0, 64), "... (").concat(data.length, " bytes)"));
+            return Promise.resolve(data);
+        }
+        this.log("".concat(context, ": Loading ").concat(uri));
+        return this._parent.preprocessUrlAsync(this._rootUrl + uri).then(function (url) {
+            return new Promise(function (resolve, reject) {
+                _this._parent._loadFile(_this._babylonScene, url, function (data) {
+                    if (!_this._disposed) {
+                        _this.log("".concat(context, ": Loaded ").concat(uri, " (").concat(data.byteLength, " bytes)"));
+                        resolve(new Uint8Array(data));
+                    }
+                }, true, function (request) {
+                    reject(new LoadFileError("".concat(context, ": Failed to load '").concat(uri, "'").concat(request ? ": " + request.status + " " + request.statusText : ""), request));
+                });
+            });
+        });
+    };
+    /**
+     * Adds a JSON pointer to the metadata of the Babylon object at `<object>.metadata.gltf.pointers`.
+     * @param babylonObject the Babylon object with metadata
+     * @param babylonObject.metadata
+     * @param pointer the JSON pointer
+     */
+    GLTFLoader.AddPointerMetadata = function (babylonObject, pointer) {
+        var metadata = (babylonObject.metadata = babylonObject.metadata || {});
+        var gltf = (metadata.gltf = metadata.gltf || {});
+        var pointers = (gltf.pointers = gltf.pointers || []);
+        pointers.push(pointer);
+    };
+    GLTFLoader._GetTextureWrapMode = function (context, mode) {
+        // Set defaults if undefined
+        mode = mode == undefined ? 10497 /* REPEAT */ : mode;
+        switch (mode) {
+            case 33071 /* CLAMP_TO_EDGE */:
+                return Texture.CLAMP_ADDRESSMODE;
+            case 33648 /* MIRRORED_REPEAT */:
+                return Texture.MIRROR_ADDRESSMODE;
+            case 10497 /* REPEAT */:
+                return Texture.WRAP_ADDRESSMODE;
+            default:
+                Logger.Warn("".concat(context, ": Invalid value (").concat(mode, ")"));
+                return Texture.WRAP_ADDRESSMODE;
+        }
+    };
+    GLTFLoader._GetTextureSamplingMode = function (context, sampler) {
+        // Set defaults if undefined
+        var magFilter = sampler.magFilter == undefined ? 9729 /* LINEAR */ : sampler.magFilter;
+        var minFilter = sampler.minFilter == undefined ? 9987 /* LINEAR_MIPMAP_LINEAR */ : sampler.minFilter;
+        if (magFilter === 9729 /* LINEAR */) {
+            switch (minFilter) {
+                case 9728 /* NEAREST */:
+                    return Texture.LINEAR_NEAREST;
+                case 9729 /* LINEAR */:
+                    return Texture.LINEAR_LINEAR;
+                case 9984 /* NEAREST_MIPMAP_NEAREST */:
+                    return Texture.LINEAR_NEAREST_MIPNEAREST;
+                case 9985 /* LINEAR_MIPMAP_NEAREST */:
+                    return Texture.LINEAR_LINEAR_MIPNEAREST;
+                case 9986 /* NEAREST_MIPMAP_LINEAR */:
+                    return Texture.LINEAR_NEAREST_MIPLINEAR;
+                case 9987 /* LINEAR_MIPMAP_LINEAR */:
+                    return Texture.LINEAR_LINEAR_MIPLINEAR;
+                default:
+                    Logger.Warn("".concat(context, "/minFilter: Invalid value (").concat(minFilter, ")"));
+                    return Texture.LINEAR_LINEAR_MIPLINEAR;
+            }
+        }
+        else {
+            if (magFilter !== 9728 /* NEAREST */) {
+                Logger.Warn("".concat(context, "/magFilter: Invalid value (").concat(magFilter, ")"));
+            }
+            switch (minFilter) {
+                case 9728 /* NEAREST */:
+                    return Texture.NEAREST_NEAREST;
+                case 9729 /* LINEAR */:
+                    return Texture.NEAREST_LINEAR;
+                case 9984 /* NEAREST_MIPMAP_NEAREST */:
+                    return Texture.NEAREST_NEAREST_MIPNEAREST;
+                case 9985 /* LINEAR_MIPMAP_NEAREST */:
+                    return Texture.NEAREST_LINEAR_MIPNEAREST;
+                case 9986 /* NEAREST_MIPMAP_LINEAR */:
+                    return Texture.NEAREST_NEAREST_MIPLINEAR;
+                case 9987 /* LINEAR_MIPMAP_LINEAR */:
+                    return Texture.NEAREST_LINEAR_MIPLINEAR;
+                default:
+                    Logger.Warn("".concat(context, "/minFilter: Invalid value (").concat(minFilter, ")"));
+                    return Texture.NEAREST_NEAREST_MIPNEAREST;
+            }
+        }
+    };
+    GLTFLoader._GetTypedArrayConstructor = function (context, componentType) {
+        switch (componentType) {
+            case 5120 /* BYTE */:
+                return Int8Array;
+            case 5121 /* UNSIGNED_BYTE */:
+                return Uint8Array;
+            case 5122 /* SHORT */:
+                return Int16Array;
+            case 5123 /* UNSIGNED_SHORT */:
+                return Uint16Array;
+            case 5125 /* UNSIGNED_INT */:
+                return Uint32Array;
+            case 5126 /* FLOAT */:
+                return Float32Array;
+            default:
+                throw new Error("".concat(context, ": Invalid component type ").concat(componentType));
+        }
+    };
+    GLTFLoader._GetTypedArray = function (context, componentType, bufferView, byteOffset, length) {
+        var buffer = bufferView.buffer;
+        byteOffset = bufferView.byteOffset + (byteOffset || 0);
+        var constructor = GLTFLoader._GetTypedArrayConstructor("".concat(context, "/componentType"), componentType);
+        var componentTypeLength = VertexBuffer.GetTypeByteLength(componentType);
+        if (byteOffset % componentTypeLength !== 0) {
+            // HACK: Copy the buffer if byte offset is not a multiple of component type byte length.
+            Logger.Warn("".concat(context, ": Copying buffer as byte offset (").concat(byteOffset, ") is not a multiple of component type byte length (").concat(componentTypeLength, ")"));
+            return new constructor(buffer.slice(byteOffset, byteOffset + length * componentTypeLength), 0);
+        }
+        return new constructor(buffer, byteOffset, length);
+    };
+    GLTFLoader._GetNumComponents = function (context, type) {
+        switch (type) {
+            case "SCALAR":
+                return 1;
+            case "VEC2":
+                return 2;
+            case "VEC3":
+                return 3;
+            case "VEC4":
+                return 4;
+            case "MAT2":
+                return 4;
+            case "MAT3":
+                return 9;
+            case "MAT4":
+                return 16;
+        }
+        throw new Error("".concat(context, ": Invalid type (").concat(type, ")"));
+    };
+    GLTFLoader._ValidateUri = function (uri) {
+        return Tools.IsBase64(uri) || uri.indexOf("..") === -1;
+    };
+    /**
+     * @param context
+     * @param mode
+     * @hidden
+     */
+    GLTFLoader._GetDrawMode = function (context, mode) {
+        if (mode == undefined) {
+            mode = 4 /* TRIANGLES */;
+        }
+        switch (mode) {
+            case 0 /* POINTS */:
+                return Material.PointListDrawMode;
+            case 1 /* LINES */:
+                return Material.LineListDrawMode;
+            case 2 /* LINE_LOOP */:
+                return Material.LineLoopDrawMode;
+            case 3 /* LINE_STRIP */:
+                return Material.LineStripDrawMode;
+            case 4 /* TRIANGLES */:
+                return Material.TriangleFillMode;
+            case 5 /* TRIANGLE_STRIP */:
+                return Material.TriangleStripDrawMode;
+            case 6 /* TRIANGLE_FAN */:
+                return Material.TriangleFanDrawMode;
+        }
+        throw new Error("".concat(context, ": Invalid mesh primitive mode (").concat(mode, ")"));
+    };
+    GLTFLoader.prototype._compileMaterialsAsync = function () {
+        var _this = this;
+        this._parent._startPerformanceCounter("Compile materials");
+        var promises = new Array();
+        if (this._gltf.materials) {
+            for (var _i = 0, _a = this._gltf.materials; _i < _a.length; _i++) {
+                var material = _a[_i];
+                if (material._data) {
+                    for (var babylonDrawMode in material._data) {
+                        var babylonData = material._data[babylonDrawMode];
+                        for (var _b = 0, _c = babylonData.babylonMeshes; _b < _c.length; _b++) {
+                            var babylonMesh = _c[_b];
+                            // Ensure nonUniformScaling is set if necessary.
+                            babylonMesh.computeWorldMatrix(true);
+                            var babylonMaterial = babylonData.babylonMaterial;
+                            promises.push(babylonMaterial.forceCompilationAsync(babylonMesh));
+                            promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { useInstances: true }));
+                            if (this._parent.useClipPlane) {
+                                promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true }));
+                                promises.push(babylonMaterial.forceCompilationAsync(babylonMesh, { clipPlane: true, useInstances: true }));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return Promise.all(promises).then(function () {
+            _this._parent._endPerformanceCounter("Compile materials");
+        });
+    };
+    GLTFLoader.prototype._compileShadowGeneratorsAsync = function () {
+        var _this = this;
+        this._parent._startPerformanceCounter("Compile shadow generators");
+        var promises = new Array();
+        var lights = this._babylonScene.lights;
+        for (var _i = 0, lights_1 = lights; _i < lights_1.length; _i++) {
+            var light = lights_1[_i];
+            var generator = light.getShadowGenerator();
+            if (generator) {
+                promises.push(generator.forceCompilationAsync());
+            }
+        }
+        return Promise.all(promises).then(function () {
+            _this._parent._endPerformanceCounter("Compile shadow generators");
+        });
+    };
+    GLTFLoader.prototype._forEachExtensions = function (action) {
+        for (var _i = 0, _a = this._extensions; _i < _a.length; _i++) {
+            var extension = _a[_i];
+            if (extension.enabled) {
+                action(extension);
+            }
+        }
+    };
+    GLTFLoader.prototype._applyExtensions = function (property, functionName, actionAsync) {
+        for (var _i = 0, _a = this._extensions; _i < _a.length; _i++) {
+            var extension = _a[_i];
+            if (extension.enabled) {
+                var id = "".concat(extension.name, ".").concat(functionName);
+                var loaderProperty = property;
+                loaderProperty._activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions || {};
+                var activeLoaderExtensionFunctions = loaderProperty._activeLoaderExtensionFunctions;
+                if (!activeLoaderExtensionFunctions[id]) {
+                    activeLoaderExtensionFunctions[id] = true;
+                    try {
+                        var result = actionAsync(extension);
+                        if (result) {
+                            return result;
+                        }
+                    }
+                    finally {
+                        delete activeLoaderExtensionFunctions[id];
+                    }
+                }
+            }
+        }
+        return null;
+    };
+    GLTFLoader.prototype._extensionsOnLoading = function () {
+        this._forEachExtensions(function (extension) { return extension.onLoading && extension.onLoading(); });
+    };
+    GLTFLoader.prototype._extensionsOnReady = function () {
+        this._forEachExtensions(function (extension) { return extension.onReady && extension.onReady(); });
+    };
+    GLTFLoader.prototype._extensionsLoadSceneAsync = function (context, scene) {
+        return this._applyExtensions(scene, "loadScene", function (extension) { return extension.loadSceneAsync && extension.loadSceneAsync(context, scene); });
+    };
+    GLTFLoader.prototype._extensionsLoadNodeAsync = function (context, node, assign) {
+        return this._applyExtensions(node, "loadNode", function (extension) { return extension.loadNodeAsync && extension.loadNodeAsync(context, node, assign); });
+    };
+    GLTFLoader.prototype._extensionsLoadCameraAsync = function (context, camera, assign) {
+        return this._applyExtensions(camera, "loadCamera", function (extension) { return extension.loadCameraAsync && extension.loadCameraAsync(context, camera, assign); });
+    };
+    GLTFLoader.prototype._extensionsLoadVertexDataAsync = function (context, primitive, babylonMesh) {
+        return this._applyExtensions(primitive, "loadVertexData", function (extension) { return extension._loadVertexDataAsync && extension._loadVertexDataAsync(context, primitive, babylonMesh); });
+    };
+    GLTFLoader.prototype._extensionsLoadMeshPrimitiveAsync = function (context, name, node, mesh, primitive, assign) {
+        return this._applyExtensions(primitive, "loadMeshPrimitive", function (extension) { return extension._loadMeshPrimitiveAsync && extension._loadMeshPrimitiveAsync(context, name, node, mesh, primitive, assign); });
+    };
+    GLTFLoader.prototype._extensionsLoadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
+        return this._applyExtensions(material, "loadMaterial", function (extension) { return extension._loadMaterialAsync && extension._loadMaterialAsync(context, material, babylonMesh, babylonDrawMode, assign); });
+    };
+    GLTFLoader.prototype._extensionsCreateMaterial = function (context, material, babylonDrawMode) {
+        return this._applyExtensions(material, "createMaterial", function (extension) { return extension.createMaterial && extension.createMaterial(context, material, babylonDrawMode); });
+    };
+    GLTFLoader.prototype._extensionsLoadMaterialPropertiesAsync = function (context, material, babylonMaterial) {
+        return this._applyExtensions(material, "loadMaterialProperties", function (extension) { return extension.loadMaterialPropertiesAsync && extension.loadMaterialPropertiesAsync(context, material, babylonMaterial); });
+    };
+    GLTFLoader.prototype._extensionsLoadTextureInfoAsync = function (context, textureInfo, assign) {
+        return this._applyExtensions(textureInfo, "loadTextureInfo", function (extension) { return extension.loadTextureInfoAsync && extension.loadTextureInfoAsync(context, textureInfo, assign); });
+    };
+    GLTFLoader.prototype._extensionsLoadTextureAsync = function (context, texture, assign) {
+        return this._applyExtensions(texture, "loadTexture", function (extension) { return extension._loadTextureAsync && extension._loadTextureAsync(context, texture, assign); });
+    };
+    GLTFLoader.prototype._extensionsLoadAnimationAsync = function (context, animation) {
+        return this._applyExtensions(animation, "loadAnimation", function (extension) { return extension.loadAnimationAsync && extension.loadAnimationAsync(context, animation); });
+    };
+    GLTFLoader.prototype._extensionsLoadSkinAsync = function (context, node, skin) {
+        return this._applyExtensions(skin, "loadSkin", function (extension) { return extension._loadSkinAsync && extension._loadSkinAsync(context, node, skin); });
+    };
+    GLTFLoader.prototype._extensionsLoadUriAsync = function (context, property, uri) {
+        return this._applyExtensions(property, "loadUri", function (extension) { return extension._loadUriAsync && extension._loadUriAsync(context, property, uri); });
+    };
+    GLTFLoader.prototype._extensionsLoadBufferViewAsync = function (context, bufferView) {
+        return this._applyExtensions(bufferView, "loadBufferView", function (extension) { return extension.loadBufferViewAsync && extension.loadBufferViewAsync(context, bufferView); });
+    };
+    GLTFLoader.prototype._extensionsLoadBufferAsync = function (context, buffer, byteOffset, byteLength) {
+        return this._applyExtensions(buffer, "loadBuffer", function (extension) { return extension.loadBufferAsync && extension.loadBufferAsync(context, buffer, byteOffset, byteLength); });
+    };
+    /**
+     * Helper method called by a loader extension to load an glTF extension.
+     * @param context The context when loading the asset
+     * @param property The glTF property to load the extension from
+     * @param extensionName The name of the extension to load
+     * @param actionAsync The action to run
+     * @returns The promise returned by actionAsync or null if the extension does not exist
+     */
+    GLTFLoader.LoadExtensionAsync = function (context, property, extensionName, actionAsync) {
+        if (!property.extensions) {
+            return null;
+        }
+        var extensions = property.extensions;
+        var extension = extensions[extensionName];
+        if (!extension) {
+            return null;
+        }
+        return actionAsync("".concat(context, "/extensions/").concat(extensionName), extension);
+    };
+    /**
+     * Helper method called by a loader extension to load a glTF extra.
+     * @param context The context when loading the asset
+     * @param property The glTF property to load the extra from
+     * @param extensionName The name of the extension to load
+     * @param actionAsync The action to run
+     * @returns The promise returned by actionAsync or null if the extra does not exist
+     */
+    GLTFLoader.LoadExtraAsync = function (context, property, extensionName, actionAsync) {
+        if (!property.extras) {
+            return null;
+        }
+        var extras = property.extras;
+        var extra = extras[extensionName];
+        if (!extra) {
+            return null;
+        }
+        return actionAsync("".concat(context, "/extras/").concat(extensionName), extra);
+    };
+    /**
+     * Checks for presence of an extension.
+     * @param name The name of the extension to check
+     * @returns A boolean indicating the presence of the given extension name in `extensionsUsed`
+     */
+    GLTFLoader.prototype.isExtensionUsed = function (name) {
+        return !!this._gltf.extensionsUsed && this._gltf.extensionsUsed.indexOf(name) !== -1;
+    };
+    /**
+     * Increments the indentation level and logs a message.
+     * @param message The message to log
+     */
+    GLTFLoader.prototype.logOpen = function (message) {
+        this._parent._logOpen(message);
+    };
+    /**
+     * Decrements the indentation level.
+     */
+    GLTFLoader.prototype.logClose = function () {
+        this._parent._logClose();
+    };
+    /**
+     * Logs a message
+     * @param message The message to log
+     */
+    GLTFLoader.prototype.log = function (message) {
+        this._parent._log(message);
+    };
+    /**
+     * Starts a performance counter.
+     * @param counterName The name of the performance counter
+     */
+    GLTFLoader.prototype.startPerformanceCounter = function (counterName) {
+        this._parent._startPerformanceCounter(counterName);
+    };
+    /**
+     * Ends a performance counter.
+     * @param counterName The name of the performance counter
+     */
+    GLTFLoader.prototype.endPerformanceCounter = function (counterName) {
+        this._parent._endPerformanceCounter(counterName);
+    };
+    GLTFLoader._RegisteredExtensions = {};
+    /**
+     * The default glTF sampler.
+     */
+    GLTFLoader.DefaultSampler = { index: -1 };
+    return GLTFLoader;
+}());
+export { GLTFLoader };
+GLTFFileLoader._CreateGLTF2Loader = function (parent) { return new GLTFLoader(parent); };
 //# sourceMappingURL=glTFLoader.js.map