@babylonjs/loaders 5.0.0-beta.8 → 5.0.0-beta.8-snapshot

package/glTF/2.0/glTFLoader.js

@@ -1,2249 +0,0 @@
-import { Deferred } from "@babylonjs/core/Misc/deferred.js";
-import { Quaternion, Vector3, Matrix } from "@babylonjs/core/Maths/math.vector.js";
-import { Color3 } from '@babylonjs/core/Maths/math.color.js';
-import { Tools } from "@babylonjs/core/Misc/tools.js";
-import { Camera } from "@babylonjs/core/Cameras/camera.js";
-import { FreeCamera } from "@babylonjs/core/Cameras/freeCamera.js";
-import { 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 { TmpVectors } from '@babylonjs/core/Maths/math.vector.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 () {
-    /** @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();
-    };
-    /** @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()
-                };
-            });
-        });
-    };
-    /** @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 (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.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 (material) { }));
-                }
-            }
-            // 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);
-                }
-            }
-        }
-        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;
-            node._babylonTransformNode = new TransformNode(nodeName, this._babylonScene);
-            node._babylonTransformNode._parentContainer = this._assetContainer;
-            this._babylonScene._blockEntityCollection = false;
-            loadNode(node._babylonTransformNode);
-        }
-        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) {
-                    GLTFLoader.AddPointerMetadata(babylonTransformNode, context);
-                    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 {
-                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) {
-            var rootNode = this._findSkeletonRootNode("".concat(context, "/joints"), skin.joints);
-            if (rootNode) {
-                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) {
-        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 () {
-                        var value = Vector3.FromArray(data.output, outputBufferOffset);
-                        outputBufferOffset += 3;
-                        return value;
-                    };
-                    break;
-                }
-                case "rotationQuaternion": {
-                    getNextOutputValue = function () {
-                        var value = Quaternion.FromArray(data.output, outputBufferOffset);
-                        outputBufferOffset += 4;
-                        return value;
-                    };
-                    break;
-                }
-                case "scaling": {
-                    getNextOutputValue = function () {
-                        var value = Vector3.FromArray(data.output, outputBufferOffset);
-                        outputBufferOffset += 3;
-                        return value;
-                    };
-                    break;
-                }
-                case "influence": {
-                    getNextOutputValue = function () {
-                        var value = new Array(targetNode._numMorphTargets);
-                        for (var i = 0; i < targetNode._numMorphTargets; i++) {
-                            value[i] = data.output[outputBufferOffset++];
-                        }
-                        return value;
-                    };
-                    break;
-                }
-            }
-            var getNextKey;
-            switch (data.interpolation) {
-                case "STEP" /* STEP */: {
-                    getNextKey = function (frameIndex) { return ({
-                        frame: data.input[frameIndex] * _this.parent.targetFps,
-                        value: getNextOutputValue(),
-                        interpolation: AnimationKeyInterpolation.STEP
-                    }); };
-                    break;
-                }
-                case "LINEAR" /* LINEAR */: {
-                    getNextKey = function (frameIndex) { return ({
-                        frame: data.input[frameIndex] * _this.parent.targetFps,
-                        value: getNextOutputValue()
-                    }); };
-                    break;
-                }
-                case "CUBICSPLINE" /* CUBICSPLINE */: {
-                    getNextKey = function (frameIndex) { return ({
-                        frame: data.input[frameIndex] * _this.parent.targetFps,
-                        inTangent: getNextOutputValue(),
-                        value: getNextOutputValue(),
-                        outTangent: getNextOutputValue()
-                    }); };
-                    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;
-    };
-    /** @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, kind) {
-        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, kind).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 () { });
-    };
-    /** @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;
-    };
-    /** @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;
-    };
-    /** @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 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);
-    };
-    /** @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