@babylonjs/loaders 5.0.0-rc.1 → 5.0.0-rc.10

package/glTF/2.0/Extensions/MSFT_lod.js

@@ -1,334 +1,370 @@
-import { Observable } from "@babylonjs/core/Misc/observable.js";
-import { Deferred } from "@babylonjs/core/Misc/deferred.js";
-import { GLTFLoader, ArrayItem } from "../glTFLoader.js";
-var NAME = "MSFT_lod";
-/**
- * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_lod)
- */
-var MSFT_lod = /** @class */ (function () {
-    /** @hidden */
-    function MSFT_lod(loader) {
-        /**
-         * The name of this extension.
-         */
-        this.name = NAME;
-        /**
-         * Defines a number that determines the order the extensions are applied.
-         */
-        this.order = 100;
-        /**
-         * Maximum number of LODs to load, starting from the lowest LOD.
-         */
-        this.maxLODsToLoad = 10;
-        /**
-         * Observable raised when all node LODs of one level are loaded.
-         * The event data is the index of the loaded LOD starting from zero.
-         * Dispose the loader to cancel the loading of the next level of LODs.
-         */
-        this.onNodeLODsLoadedObservable = new Observable();
-        /**
-         * Observable raised when all material LODs of one level are loaded.
-         * The event data is the index of the loaded LOD starting from zero.
-         * Dispose the loader to cancel the loading of the next level of LODs.
-         */
-        this.onMaterialLODsLoadedObservable = new Observable();
-        this._bufferLODs = new Array();
-        this._nodeIndexLOD = null;
-        this._nodeSignalLODs = new Array();
-        this._nodePromiseLODs = new Array();
-        this._nodeBufferLODs = new Array();
-        this._materialIndexLOD = null;
-        this._materialSignalLODs = new Array();
-        this._materialPromiseLODs = new Array();
-        this._materialBufferLODs = new Array();
-        this._loader = loader;
-        this.enabled = this._loader.isExtensionUsed(NAME);
-    }
-    /** @hidden */
-    MSFT_lod.prototype.dispose = function () {
-        this._loader = null;
-        this._nodeIndexLOD = null;
-        this._nodeSignalLODs.length = 0;
-        this._nodePromiseLODs.length = 0;
-        this._nodeBufferLODs.length = 0;
-        this._materialIndexLOD = null;
-        this._materialSignalLODs.length = 0;
-        this._materialPromiseLODs.length = 0;
-        this._materialBufferLODs.length = 0;
-        this.onMaterialLODsLoadedObservable.clear();
-        this.onNodeLODsLoadedObservable.clear();
-    };
-    /** @hidden */
-    MSFT_lod.prototype.onReady = function () {
-        var _this = this;
-        var _loop_1 = function (indexLOD) {
-            var promise = Promise.all(this_1._nodePromiseLODs[indexLOD]).then(function () {
-                if (indexLOD !== 0) {
-                    _this._loader.endPerformanceCounter("Node LOD ".concat(indexLOD));
-                    _this._loader.log("Loaded node LOD ".concat(indexLOD));
-                }
-                _this.onNodeLODsLoadedObservable.notifyObservers(indexLOD);
-                if (indexLOD !== _this._nodePromiseLODs.length - 1) {
-                    _this._loader.startPerformanceCounter("Node LOD ".concat(indexLOD + 1));
-                    _this._loadBufferLOD(_this._nodeBufferLODs, indexLOD + 1);
-                    if (_this._nodeSignalLODs[indexLOD]) {
-                        _this._nodeSignalLODs[indexLOD].resolve();
-                    }
-                }
-            });
-            this_1._loader._completePromises.push(promise);
-        };
-        var this_1 = this;
-        for (var indexLOD = 0; indexLOD < this._nodePromiseLODs.length; indexLOD++) {
-            _loop_1(indexLOD);
-        }
-        var _loop_2 = function (indexLOD) {
-            var promise = Promise.all(this_2._materialPromiseLODs[indexLOD]).then(function () {
-                if (indexLOD !== 0) {
-                    _this._loader.endPerformanceCounter("Material LOD ".concat(indexLOD));
-                    _this._loader.log("Loaded material LOD ".concat(indexLOD));
-                }
-                _this.onMaterialLODsLoadedObservable.notifyObservers(indexLOD);
-                if (indexLOD !== _this._materialPromiseLODs.length - 1) {
-                    _this._loader.startPerformanceCounter("Material LOD ".concat(indexLOD + 1));
-                    _this._loadBufferLOD(_this._materialBufferLODs, indexLOD + 1);
-                    if (_this._materialSignalLODs[indexLOD]) {
-                        _this._materialSignalLODs[indexLOD].resolve();
-                    }
-                }
-            });
-            this_2._loader._completePromises.push(promise);
-        };
-        var this_2 = this;
-        for (var indexLOD = 0; indexLOD < this._materialPromiseLODs.length; indexLOD++) {
-            _loop_2(indexLOD);
-        }
-    };
-    /** @hidden */
-    MSFT_lod.prototype.loadSceneAsync = function (context, scene) {
-        var promise = this._loader.loadSceneAsync(context, scene);
-        this._loadBufferLOD(this._bufferLODs, 0);
-        return promise;
-    };
-    /** @hidden */
-    MSFT_lod.prototype.loadNodeAsync = function (context, node, assign) {
-        var _this = this;
-        return GLTFLoader.LoadExtensionAsync(context, node, this.name, function (extensionContext, extension) {
-            var firstPromise;
-            var nodeLODs = _this._getLODs(extensionContext, node, _this._loader.gltf.nodes, extension.ids);
-            _this._loader.logOpen("".concat(extensionContext));
-            var _loop_3 = function (indexLOD) {
-                var nodeLOD = nodeLODs[indexLOD];
-                if (indexLOD !== 0) {
-                    _this._nodeIndexLOD = indexLOD;
-                    _this._nodeSignalLODs[indexLOD] = _this._nodeSignalLODs[indexLOD] || new Deferred();
-                }
-                var assignWrap = function (babylonTransformNode) {
-                    assign(babylonTransformNode);
-                    babylonTransformNode.setEnabled(false);
-                };
-                var promise = _this._loader.loadNodeAsync("/nodes/".concat(nodeLOD.index), nodeLOD, assignWrap).then(function (babylonMesh) {
-                    if (indexLOD !== 0) {
-                        // TODO: should not rely on _babylonTransformNode
-                        var previousNodeLOD = nodeLODs[indexLOD - 1];
-                        if (previousNodeLOD._babylonTransformNode) {
-                            _this._disposeTransformNode(previousNodeLOD._babylonTransformNode);
-                            delete previousNodeLOD._babylonTransformNode;
-                        }
-                    }
-                    babylonMesh.setEnabled(true);
-                    return babylonMesh;
-                });
-                _this._nodePromiseLODs[indexLOD] = _this._nodePromiseLODs[indexLOD] || [];
-                if (indexLOD === 0) {
-                    firstPromise = promise;
-                }
-                else {
-                    _this._nodeIndexLOD = null;
-                    _this._nodePromiseLODs[indexLOD].push(promise);
-                }
-            };
-            for (var indexLOD = 0; indexLOD < nodeLODs.length; indexLOD++) {
-                _loop_3(indexLOD);
-            }
-            _this._loader.logClose();
-            return firstPromise;
-        });
-    };
-    /** @hidden */
-    MSFT_lod.prototype._loadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
-        var _this = this;
-        // Don't load material LODs if already loading a node LOD.
-        if (this._nodeIndexLOD) {
-            return null;
-        }
-        return GLTFLoader.LoadExtensionAsync(context, material, this.name, function (extensionContext, extension) {
-            var firstPromise;
-            var materialLODs = _this._getLODs(extensionContext, material, _this._loader.gltf.materials, extension.ids);
-            _this._loader.logOpen("".concat(extensionContext));
-            var _loop_4 = function (indexLOD) {
-                var materialLOD = materialLODs[indexLOD];
-                if (indexLOD !== 0) {
-                    _this._materialIndexLOD = indexLOD;
-                }
-                var promise = _this._loader._loadMaterialAsync("/materials/".concat(materialLOD.index), materialLOD, babylonMesh, babylonDrawMode, function (babylonMaterial) {
-                    if (indexLOD === 0) {
-                        assign(babylonMaterial);
-                    }
-                }).then(function (babylonMaterial) {
-                    if (indexLOD !== 0) {
-                        assign(babylonMaterial);
-                        // TODO: should not rely on _data
-                        var previousDataLOD = materialLODs[indexLOD - 1]._data;
-                        if (previousDataLOD[babylonDrawMode]) {
-                            _this._disposeMaterials([previousDataLOD[babylonDrawMode].babylonMaterial]);
-                            delete previousDataLOD[babylonDrawMode];
-                        }
-                    }
-                    return babylonMaterial;
-                });
-                _this._materialPromiseLODs[indexLOD] = _this._materialPromiseLODs[indexLOD] || [];
-                if (indexLOD === 0) {
-                    firstPromise = promise;
-                }
-                else {
-                    _this._materialIndexLOD = null;
-                    _this._materialPromiseLODs[indexLOD].push(promise);
-                }
-            };
-            for (var indexLOD = 0; indexLOD < materialLODs.length; indexLOD++) {
-                _loop_4(indexLOD);
-            }
-            _this._loader.logClose();
-            return firstPromise;
-        });
-    };
-    /** @hidden */
-    MSFT_lod.prototype._loadUriAsync = function (context, property, uri) {
-        var _this = this;
-        // Defer the loading of uris if loading a node or material LOD.
-        if (this._nodeIndexLOD !== null) {
-            this._loader.log("deferred");
-            var previousIndexLOD = this._nodeIndexLOD - 1;
-            this._nodeSignalLODs[previousIndexLOD] = this._nodeSignalLODs[previousIndexLOD] || new Deferred();
-            return this._nodeSignalLODs[this._nodeIndexLOD - 1].promise.then(function () {
-                return _this._loader.loadUriAsync(context, property, uri);
-            });
-        }
-        else if (this._materialIndexLOD !== null) {
-            this._loader.log("deferred");
-            var previousIndexLOD = this._materialIndexLOD - 1;
-            this._materialSignalLODs[previousIndexLOD] = this._materialSignalLODs[previousIndexLOD] || new Deferred();
-            return this._materialSignalLODs[previousIndexLOD].promise.then(function () {
-                return _this._loader.loadUriAsync(context, property, uri);
-            });
-        }
-        return null;
-    };
-    /** @hidden */
-    MSFT_lod.prototype.loadBufferAsync = function (context, buffer, byteOffset, byteLength) {
-        if (this._loader.parent.useRangeRequests && !buffer.uri) {
-            if (!this._loader.bin) {
-                throw new Error("".concat(context, ": Uri is missing or the binary glTF is missing its binary chunk"));
-            }
-            var loadAsync = function (bufferLODs, indexLOD) {
-                var start = byteOffset;
-                var end = start + byteLength - 1;
-                var bufferLOD = bufferLODs[indexLOD];
-                if (bufferLOD) {
-                    bufferLOD.start = Math.min(bufferLOD.start, start);
-                    bufferLOD.end = Math.max(bufferLOD.end, end);
-                }
-                else {
-                    bufferLOD = { start: start, end: end, loaded: new Deferred() };
-                    bufferLODs[indexLOD] = bufferLOD;
-                }
-                return bufferLOD.loaded.promise.then(function (data) {
-                    return new Uint8Array(data.buffer, data.byteOffset + byteOffset - bufferLOD.start, byteLength);
-                });
-            };
-            this._loader.log("deferred");
-            if (this._nodeIndexLOD !== null) {
-                return loadAsync(this._nodeBufferLODs, this._nodeIndexLOD);
-            }
-            else if (this._materialIndexLOD !== null) {
-                return loadAsync(this._materialBufferLODs, this._materialIndexLOD);
-            }
-            else {
-                return loadAsync(this._bufferLODs, 0);
-            }
-        }
-        return null;
-    };
-    MSFT_lod.prototype._loadBufferLOD = function (bufferLODs, indexLOD) {
-        var bufferLOD = bufferLODs[indexLOD];
-        if (bufferLOD) {
-            this._loader.log("Loading buffer range [".concat(bufferLOD.start, "-").concat(bufferLOD.end, "]"));
-            this._loader.bin.readAsync(bufferLOD.start, bufferLOD.end - bufferLOD.start + 1).then(function (data) {
-                bufferLOD.loaded.resolve(data);
-            }, function (error) {
-                bufferLOD.loaded.reject(error);
-            });
-        }
-    };
-    /**
-     * Gets an array of LOD properties from lowest to highest.
-     */
-    MSFT_lod.prototype._getLODs = function (context, property, array, ids) {
-        if (this.maxLODsToLoad <= 0) {
-            throw new Error("maxLODsToLoad must be greater than zero");
-        }
-        var properties = new Array();
-        for (var i = ids.length - 1; i >= 0; i--) {
-            properties.push(ArrayItem.Get("".concat(context, "/ids/").concat(ids[i]), array, ids[i]));
-            if (properties.length === this.maxLODsToLoad) {
-                return properties;
-            }
-        }
-        properties.push(property);
-        return properties;
-    };
-    MSFT_lod.prototype._disposeTransformNode = function (babylonTransformNode) {
-        var _this = this;
-        var babylonMaterials = new Array();
-        var babylonMaterial = babylonTransformNode.material;
-        if (babylonMaterial) {
-            babylonMaterials.push(babylonMaterial);
-        }
-        for (var _i = 0, _a = babylonTransformNode.getChildMeshes(); _i < _a.length; _i++) {
-            var babylonMesh = _a[_i];
-            if (babylonMesh.material) {
-                babylonMaterials.push(babylonMesh.material);
-            }
-        }
-        babylonTransformNode.dispose();
-        var babylonMaterialsToDispose = babylonMaterials.filter(function (babylonMaterial) { return _this._loader.babylonScene.meshes.every(function (mesh) { return mesh.material != babylonMaterial; }); });
-        this._disposeMaterials(babylonMaterialsToDispose);
-    };
-    MSFT_lod.prototype._disposeMaterials = function (babylonMaterials) {
-        var babylonTextures = {};
-        for (var _i = 0, babylonMaterials_1 = babylonMaterials; _i < babylonMaterials_1.length; _i++) {
-            var babylonMaterial = babylonMaterials_1[_i];
-            for (var _a = 0, _b = babylonMaterial.getActiveTextures(); _a < _b.length; _a++) {
-                var babylonTexture = _b[_a];
-                babylonTextures[babylonTexture.uniqueId] = babylonTexture;
-            }
-            babylonMaterial.dispose();
-        }
-        for (var uniqueId in babylonTextures) {
-            for (var _c = 0, _d = this._loader.babylonScene.materials; _c < _d.length; _c++) {
-                var babylonMaterial = _d[_c];
-                if (babylonMaterial.hasTexture(babylonTextures[uniqueId])) {
-                    delete babylonTextures[uniqueId];
-                }
-            }
-        }
-        for (var uniqueId in babylonTextures) {
-            babylonTextures[uniqueId].dispose();
-        }
-    };
-    return MSFT_lod;
-}());
-export { MSFT_lod };
-GLTFLoader.RegisterExtension(NAME, function (loader) { return new MSFT_lod(loader); });
+import { Observable } from "@babylonjs/core/Misc/observable.js";
+import { Deferred } from "@babylonjs/core/Misc/deferred.js";
+import { GLTFLoader, ArrayItem } from "../glTFLoader";
+var NAME = "MSFT_lod";
+/**
+ * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_lod)
+ */
+var MSFT_lod = /** @class */ (function () {
+    /**
+     * @param loader
+     * @hidden
+     */
+    function MSFT_lod(loader) {
+        /**
+         * The name of this extension.
+         */
+        this.name = NAME;
+        /**
+         * Defines a number that determines the order the extensions are applied.
+         */
+        this.order = 100;
+        /**
+         * Maximum number of LODs to load, starting from the lowest LOD.
+         */
+        this.maxLODsToLoad = 10;
+        /**
+         * Observable raised when all node LODs of one level are loaded.
+         * The event data is the index of the loaded LOD starting from zero.
+         * Dispose the loader to cancel the loading of the next level of LODs.
+         */
+        this.onNodeLODsLoadedObservable = new Observable();
+        /**
+         * Observable raised when all material LODs of one level are loaded.
+         * The event data is the index of the loaded LOD starting from zero.
+         * Dispose the loader to cancel the loading of the next level of LODs.
+         */
+        this.onMaterialLODsLoadedObservable = new Observable();
+        this._bufferLODs = new Array();
+        this._nodeIndexLOD = null;
+        this._nodeSignalLODs = new Array();
+        this._nodePromiseLODs = new Array();
+        this._nodeBufferLODs = new Array();
+        this._materialIndexLOD = null;
+        this._materialSignalLODs = new Array();
+        this._materialPromiseLODs = new Array();
+        this._materialBufferLODs = new Array();
+        this._loader = loader;
+        this.enabled = this._loader.isExtensionUsed(NAME);
+    }
+    /** @hidden */
+    MSFT_lod.prototype.dispose = function () {
+        this._loader = null;
+        this._nodeIndexLOD = null;
+        this._nodeSignalLODs.length = 0;
+        this._nodePromiseLODs.length = 0;
+        this._nodeBufferLODs.length = 0;
+        this._materialIndexLOD = null;
+        this._materialSignalLODs.length = 0;
+        this._materialPromiseLODs.length = 0;
+        this._materialBufferLODs.length = 0;
+        this.onMaterialLODsLoadedObservable.clear();
+        this.onNodeLODsLoadedObservable.clear();
+    };
+    /** @hidden */
+    MSFT_lod.prototype.onReady = function () {
+        var _this = this;
+        var _loop_1 = function (indexLOD) {
+            var promise = Promise.all(this_1._nodePromiseLODs[indexLOD]).then(function () {
+                if (indexLOD !== 0) {
+                    _this._loader.endPerformanceCounter("Node LOD ".concat(indexLOD));
+                    _this._loader.log("Loaded node LOD ".concat(indexLOD));
+                }
+                _this.onNodeLODsLoadedObservable.notifyObservers(indexLOD);
+                if (indexLOD !== _this._nodePromiseLODs.length - 1) {
+                    _this._loader.startPerformanceCounter("Node LOD ".concat(indexLOD + 1));
+                    _this._loadBufferLOD(_this._nodeBufferLODs, indexLOD + 1);
+                    if (_this._nodeSignalLODs[indexLOD]) {
+                        _this._nodeSignalLODs[indexLOD].resolve();
+                    }
+                }
+            });
+            this_1._loader._completePromises.push(promise);
+        };
+        var this_1 = this;
+        for (var indexLOD = 0; indexLOD < this._nodePromiseLODs.length; indexLOD++) {
+            _loop_1(indexLOD);
+        }
+        var _loop_2 = function (indexLOD) {
+            var promise = Promise.all(this_2._materialPromiseLODs[indexLOD]).then(function () {
+                if (indexLOD !== 0) {
+                    _this._loader.endPerformanceCounter("Material LOD ".concat(indexLOD));
+                    _this._loader.log("Loaded material LOD ".concat(indexLOD));
+                }
+                _this.onMaterialLODsLoadedObservable.notifyObservers(indexLOD);
+                if (indexLOD !== _this._materialPromiseLODs.length - 1) {
+                    _this._loader.startPerformanceCounter("Material LOD ".concat(indexLOD + 1));
+                    _this._loadBufferLOD(_this._materialBufferLODs, indexLOD + 1);
+                    if (_this._materialSignalLODs[indexLOD]) {
+                        _this._materialSignalLODs[indexLOD].resolve();
+                    }
+                }
+            });
+            this_2._loader._completePromises.push(promise);
+        };
+        var this_2 = this;
+        for (var indexLOD = 0; indexLOD < this._materialPromiseLODs.length; indexLOD++) {
+            _loop_2(indexLOD);
+        }
+    };
+    /**
+     * @param context
+     * @param scene
+     * @hidden
+     */
+    MSFT_lod.prototype.loadSceneAsync = function (context, scene) {
+        var promise = this._loader.loadSceneAsync(context, scene);
+        this._loadBufferLOD(this._bufferLODs, 0);
+        return promise;
+    };
+    /**
+     * @param context
+     * @param node
+     * @param assign
+     * @hidden
+     */
+    MSFT_lod.prototype.loadNodeAsync = function (context, node, assign) {
+        var _this = this;
+        return GLTFLoader.LoadExtensionAsync(context, node, this.name, function (extensionContext, extension) {
+            var firstPromise;
+            var nodeLODs = _this._getLODs(extensionContext, node, _this._loader.gltf.nodes, extension.ids);
+            _this._loader.logOpen("".concat(extensionContext));
+            var _loop_3 = function (indexLOD) {
+                var nodeLOD = nodeLODs[indexLOD];
+                if (indexLOD !== 0) {
+                    _this._nodeIndexLOD = indexLOD;
+                    _this._nodeSignalLODs[indexLOD] = _this._nodeSignalLODs[indexLOD] || new Deferred();
+                }
+                var assignWrap = function (babylonTransformNode) {
+                    assign(babylonTransformNode);
+                    babylonTransformNode.setEnabled(false);
+                };
+                var promise = _this._loader.loadNodeAsync("/nodes/".concat(nodeLOD.index), nodeLOD, assignWrap).then(function (babylonMesh) {
+                    if (indexLOD !== 0) {
+                        // TODO: should not rely on _babylonTransformNode
+                        var previousNodeLOD = nodeLODs[indexLOD - 1];
+                        if (previousNodeLOD._babylonTransformNode) {
+                            _this._disposeTransformNode(previousNodeLOD._babylonTransformNode);
+                            delete previousNodeLOD._babylonTransformNode;
+                        }
+                    }
+                    babylonMesh.setEnabled(true);
+                    return babylonMesh;
+                });
+                _this._nodePromiseLODs[indexLOD] = _this._nodePromiseLODs[indexLOD] || [];
+                if (indexLOD === 0) {
+                    firstPromise = promise;
+                }
+                else {
+                    _this._nodeIndexLOD = null;
+                    _this._nodePromiseLODs[indexLOD].push(promise);
+                }
+            };
+            for (var indexLOD = 0; indexLOD < nodeLODs.length; indexLOD++) {
+                _loop_3(indexLOD);
+            }
+            _this._loader.logClose();
+            return firstPromise;
+        });
+    };
+    /**
+     * @param context
+     * @param material
+     * @param babylonMesh
+     * @param babylonDrawMode
+     * @param assign
+     * @hidden
+     */
+    MSFT_lod.prototype._loadMaterialAsync = function (context, material, babylonMesh, babylonDrawMode, assign) {
+        var _this = this;
+        // Don't load material LODs if already loading a node LOD.
+        if (this._nodeIndexLOD) {
+            return null;
+        }
+        return GLTFLoader.LoadExtensionAsync(context, material, this.name, function (extensionContext, extension) {
+            var firstPromise;
+            var materialLODs = _this._getLODs(extensionContext, material, _this._loader.gltf.materials, extension.ids);
+            _this._loader.logOpen("".concat(extensionContext));
+            var _loop_4 = function (indexLOD) {
+                var materialLOD = materialLODs[indexLOD];
+                if (indexLOD !== 0) {
+                    _this._materialIndexLOD = indexLOD;
+                }
+                var promise = _this._loader
+                    ._loadMaterialAsync("/materials/".concat(materialLOD.index), materialLOD, babylonMesh, babylonDrawMode, function (babylonMaterial) {
+                    if (indexLOD === 0) {
+                        assign(babylonMaterial);
+                    }
+                })
+                    .then(function (babylonMaterial) {
+                    if (indexLOD !== 0) {
+                        assign(babylonMaterial);
+                        // TODO: should not rely on _data
+                        var previousDataLOD = materialLODs[indexLOD - 1]._data;
+                        if (previousDataLOD[babylonDrawMode]) {
+                            _this._disposeMaterials([previousDataLOD[babylonDrawMode].babylonMaterial]);
+                            delete previousDataLOD[babylonDrawMode];
+                        }
+                    }
+                    return babylonMaterial;
+                });
+                _this._materialPromiseLODs[indexLOD] = _this._materialPromiseLODs[indexLOD] || [];
+                if (indexLOD === 0) {
+                    firstPromise = promise;
+                }
+                else {
+                    _this._materialIndexLOD = null;
+                    _this._materialPromiseLODs[indexLOD].push(promise);
+                }
+            };
+            for (var indexLOD = 0; indexLOD < materialLODs.length; indexLOD++) {
+                _loop_4(indexLOD);
+            }
+            _this._loader.logClose();
+            return firstPromise;
+        });
+    };
+    /**
+     * @param context
+     * @param property
+     * @param uri
+     * @hidden
+     */
+    MSFT_lod.prototype._loadUriAsync = function (context, property, uri) {
+        var _this = this;
+        // Defer the loading of uris if loading a node or material LOD.
+        if (this._nodeIndexLOD !== null) {
+            this._loader.log("deferred");
+            var previousIndexLOD = this._nodeIndexLOD - 1;
+            this._nodeSignalLODs[previousIndexLOD] = this._nodeSignalLODs[previousIndexLOD] || new Deferred();
+            return this._nodeSignalLODs[this._nodeIndexLOD - 1].promise.then(function () {
+                return _this._loader.loadUriAsync(context, property, uri);
+            });
+        }
+        else if (this._materialIndexLOD !== null) {
+            this._loader.log("deferred");
+            var previousIndexLOD = this._materialIndexLOD - 1;
+            this._materialSignalLODs[previousIndexLOD] = this._materialSignalLODs[previousIndexLOD] || new Deferred();
+            return this._materialSignalLODs[previousIndexLOD].promise.then(function () {
+                return _this._loader.loadUriAsync(context, property, uri);
+            });
+        }
+        return null;
+    };
+    /**
+     * @param context
+     * @param buffer
+     * @param byteOffset
+     * @param byteLength
+     * @hidden
+     */
+    MSFT_lod.prototype.loadBufferAsync = function (context, buffer, byteOffset, byteLength) {
+        if (this._loader.parent.useRangeRequests && !buffer.uri) {
+            if (!this._loader.bin) {
+                throw new Error("".concat(context, ": Uri is missing or the binary glTF is missing its binary chunk"));
+            }
+            var loadAsync = function (bufferLODs, indexLOD) {
+                var start = byteOffset;
+                var end = start + byteLength - 1;
+                var bufferLOD = bufferLODs[indexLOD];
+                if (bufferLOD) {
+                    bufferLOD.start = Math.min(bufferLOD.start, start);
+                    bufferLOD.end = Math.max(bufferLOD.end, end);
+                }
+                else {
+                    bufferLOD = { start: start, end: end, loaded: new Deferred() };
+                    bufferLODs[indexLOD] = bufferLOD;
+                }
+                return bufferLOD.loaded.promise.then(function (data) {
+                    return new Uint8Array(data.buffer, data.byteOffset + byteOffset - bufferLOD.start, byteLength);
+                });
+            };
+            this._loader.log("deferred");
+            if (this._nodeIndexLOD !== null) {
+                return loadAsync(this._nodeBufferLODs, this._nodeIndexLOD);
+            }
+            else if (this._materialIndexLOD !== null) {
+                return loadAsync(this._materialBufferLODs, this._materialIndexLOD);
+            }
+            else {
+                return loadAsync(this._bufferLODs, 0);
+            }
+        }
+        return null;
+    };
+    MSFT_lod.prototype._loadBufferLOD = function (bufferLODs, indexLOD) {
+        var bufferLOD = bufferLODs[indexLOD];
+        if (bufferLOD) {
+            this._loader.log("Loading buffer range [".concat(bufferLOD.start, "-").concat(bufferLOD.end, "]"));
+            this._loader.bin.readAsync(bufferLOD.start, bufferLOD.end - bufferLOD.start + 1).then(function (data) {
+                bufferLOD.loaded.resolve(data);
+            }, function (error) {
+                bufferLOD.loaded.reject(error);
+            });
+        }
+    };
+    /**
+     * Gets an array of LOD properties from lowest to highest.
+     * @param context
+     * @param property
+     * @param array
+     * @param ids
+     */
+    MSFT_lod.prototype._getLODs = function (context, property, array, ids) {
+        if (this.maxLODsToLoad <= 0) {
+            throw new Error("maxLODsToLoad must be greater than zero");
+        }
+        var properties = new Array();
+        for (var i = ids.length - 1; i >= 0; i--) {
+            properties.push(ArrayItem.Get("".concat(context, "/ids/").concat(ids[i]), array, ids[i]));
+            if (properties.length === this.maxLODsToLoad) {
+                return properties;
+            }
+        }
+        properties.push(property);
+        return properties;
+    };
+    MSFT_lod.prototype._disposeTransformNode = function (babylonTransformNode) {
+        var _this = this;
+        var babylonMaterials = new Array();
+        var babylonMaterial = babylonTransformNode.material;
+        if (babylonMaterial) {
+            babylonMaterials.push(babylonMaterial);
+        }
+        for (var _i = 0, _a = babylonTransformNode.getChildMeshes(); _i < _a.length; _i++) {
+            var babylonMesh = _a[_i];
+            if (babylonMesh.material) {
+                babylonMaterials.push(babylonMesh.material);
+            }
+        }
+        babylonTransformNode.dispose();
+        var babylonMaterialsToDispose = babylonMaterials.filter(function (babylonMaterial) { return _this._loader.babylonScene.meshes.every(function (mesh) { return mesh.material != babylonMaterial; }); });
+        this._disposeMaterials(babylonMaterialsToDispose);
+    };
+    MSFT_lod.prototype._disposeMaterials = function (babylonMaterials) {
+        var babylonTextures = {};
+        for (var _i = 0, babylonMaterials_1 = babylonMaterials; _i < babylonMaterials_1.length; _i++) {
+            var babylonMaterial = babylonMaterials_1[_i];
+            for (var _a = 0, _b = babylonMaterial.getActiveTextures(); _a < _b.length; _a++) {
+                var babylonTexture = _b[_a];
+                babylonTextures[babylonTexture.uniqueId] = babylonTexture;
+            }
+            babylonMaterial.dispose();
+        }
+        for (var uniqueId in babylonTextures) {
+            for (var _c = 0, _d = this._loader.babylonScene.materials; _c < _d.length; _c++) {
+                var babylonMaterial = _d[_c];
+                if (babylonMaterial.hasTexture(babylonTextures[uniqueId])) {
+                    delete babylonTextures[uniqueId];
+                }
+            }
+        }
+        for (var uniqueId in babylonTextures) {
+            babylonTextures[uniqueId].dispose();
+        }
+    };
+    return MSFT_lod;
+}());
+export { MSFT_lod };
+GLTFLoader.RegisterExtension(NAME, function (loader) { return new MSFT_lod(loader); });
 //# sourceMappingURL=MSFT_lod.js.map