@babylonjs/loaders 5.19.0 → 5.22.0

package/glTF/glTFFileLoader.js

@@ -68,8 +68,8 @@ export var GLTFLoaderState;
 /**
  * File loader for loading glTF files into a scene.
  */
-var GLTFFileLoader = /** @class */ (function () {
-    function GLTFFileLoader() {
+export class GLTFFileLoader {
+    constructor() {
         // --------------
         // Common options
         // --------------
@@ -149,7 +149,7 @@ var GLTFFileLoader = /** @class */ (function () {
          * Function called before loading a url referenced by the asset.
          * @param url
          */
-        this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
+        this.preprocessUrlAsync = (url) => Promise.resolve(url);
         /**
          * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
          * Note that the observable is raised as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
@@ -227,200 +227,151 @@ var GLTFFileLoader = /** @class */ (function () {
         /** @hidden */
         this._endPerformanceCounter = this._endPerformanceCounterDisabled;
     }
-    Object.defineProperty(GLTFFileLoader.prototype, "onParsed", {
-        /**
-         * Raised when the asset has been parsed
-         */
-        set: function (callback) {
-            if (this._onParsedObserver) {
-                this.onParsedObservable.remove(this._onParsedObserver);
-            }
-            this._onParsedObserver = this.onParsedObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "onMeshLoaded", {
-        /**
-         * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-         * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
-         */
-        set: function (callback) {
-            if (this._onMeshLoadedObserver) {
-                this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver);
-            }
-            this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "onTextureLoaded", {
-        /**
-         * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
-         */
-        set: function (callback) {
-            if (this._onTextureLoadedObserver) {
-                this.onTextureLoadedObservable.remove(this._onTextureLoadedObserver);
-            }
-            this._onTextureLoadedObserver = this.onTextureLoadedObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "onMaterialLoaded", {
-        /**
-         * Callback raised when the loader creates a material after parsing the glTF properties of the material.
-         */
-        set: function (callback) {
-            if (this._onMaterialLoadedObserver) {
-                this.onMaterialLoadedObservable.remove(this._onMaterialLoadedObserver);
-            }
-            this._onMaterialLoadedObserver = this.onMaterialLoadedObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "onCameraLoaded", {
-        /**
-         * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
-         */
-        set: function (callback) {
-            if (this._onCameraLoadedObserver) {
-                this.onCameraLoadedObservable.remove(this._onCameraLoadedObserver);
-            }
-            this._onCameraLoadedObserver = this.onCameraLoadedObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "onComplete", {
-        /**
-         * Callback raised when the asset is completely loaded, immediately before the loader is disposed.
-         * For assets with LODs, raised when all of the LODs are complete.
-         * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
-         */
-        set: function (callback) {
-            if (this._onCompleteObserver) {
-                this.onCompleteObservable.remove(this._onCompleteObserver);
-            }
-            this._onCompleteObserver = this.onCompleteObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "onError", {
-        /**
-         * Callback raised when an error occurs.
-         */
-        set: function (callback) {
-            if (this._onErrorObserver) {
-                this.onErrorObservable.remove(this._onErrorObserver);
-            }
-            this._onErrorObserver = this.onErrorObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "onDispose", {
-        /**
-         * Callback raised after the loader is disposed.
-         */
-        set: function (callback) {
-            if (this._onDisposeObserver) {
-                this.onDisposeObservable.remove(this._onDisposeObserver);
-            }
-            this._onDisposeObserver = this.onDisposeObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "onExtensionLoaded", {
-        /**
-         * Callback raised after a loader extension is created.
-         */
-        set: function (callback) {
-            if (this._onExtensionLoadedObserver) {
-                this.onExtensionLoadedObservable.remove(this._onExtensionLoadedObserver);
-            }
-            this._onExtensionLoadedObserver = this.onExtensionLoadedObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "loggingEnabled", {
-        /**
-         * Defines if the loader logging is enabled.
-         */
-        get: function () {
-            return this._loggingEnabled;
-        },
-        set: function (value) {
-            if (this._loggingEnabled === value) {
-                return;
-            }
-            this._loggingEnabled = value;
-            if (this._loggingEnabled) {
-                this._log = this._logEnabled;
-            }
-            else {
-                this._log = this._logDisabled;
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "capturePerformanceCounters", {
-        /**
-         * Defines if the loader should capture performance counters.
-         */
-        get: function () {
-            return this._capturePerformanceCounters;
-        },
-        set: function (value) {
-            if (this._capturePerformanceCounters === value) {
-                return;
-            }
-            this._capturePerformanceCounters = value;
-            if (this._capturePerformanceCounters) {
-                this._startPerformanceCounter = this._startPerformanceCounterEnabled;
-                this._endPerformanceCounter = this._endPerformanceCounterEnabled;
-            }
-            else {
-                this._startPerformanceCounter = this._startPerformanceCounterDisabled;
-                this._endPerformanceCounter = this._endPerformanceCounterDisabled;
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(GLTFFileLoader.prototype, "onValidated", {
-        /**
-         * Callback raised after a loader extension is created.
-         */
-        set: function (callback) {
-            if (this._onValidatedObserver) {
-                this.onValidatedObservable.remove(this._onValidatedObserver);
-            }
-            this._onValidatedObserver = this.onValidatedObservable.add(callback);
-        },
-        enumerable: false,
-        configurable: true
-    });
+    /**
+     * Raised when the asset has been parsed
+     */
+    set onParsed(callback) {
+        if (this._onParsedObserver) {
+            this.onParsedObservable.remove(this._onParsedObserver);
+        }
+        this._onParsedObserver = this.onParsedObservable.add(callback);
+    }
+    /**
+     * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
+     * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
+     */
+    set onMeshLoaded(callback) {
+        if (this._onMeshLoadedObserver) {
+            this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver);
+        }
+        this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(callback);
+    }
+    /**
+     * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
+     */
+    set onTextureLoaded(callback) {
+        if (this._onTextureLoadedObserver) {
+            this.onTextureLoadedObservable.remove(this._onTextureLoadedObserver);
+        }
+        this._onTextureLoadedObserver = this.onTextureLoadedObservable.add(callback);
+    }
+    /**
+     * Callback raised when the loader creates a material after parsing the glTF properties of the material.
+     */
+    set onMaterialLoaded(callback) {
+        if (this._onMaterialLoadedObserver) {
+            this.onMaterialLoadedObservable.remove(this._onMaterialLoadedObserver);
+        }
+        this._onMaterialLoadedObserver = this.onMaterialLoadedObservable.add(callback);
+    }
+    /**
+     * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
+     */
+    set onCameraLoaded(callback) {
+        if (this._onCameraLoadedObserver) {
+            this.onCameraLoadedObservable.remove(this._onCameraLoadedObserver);
+        }
+        this._onCameraLoadedObserver = this.onCameraLoadedObservable.add(callback);
+    }
+    /**
+     * Callback raised when the asset is completely loaded, immediately before the loader is disposed.
+     * For assets with LODs, raised when all of the LODs are complete.
+     * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
+     */
+    set onComplete(callback) {
+        if (this._onCompleteObserver) {
+            this.onCompleteObservable.remove(this._onCompleteObserver);
+        }
+        this._onCompleteObserver = this.onCompleteObservable.add(callback);
+    }
+    /**
+     * Callback raised when an error occurs.
+     */
+    set onError(callback) {
+        if (this._onErrorObserver) {
+            this.onErrorObservable.remove(this._onErrorObserver);
+        }
+        this._onErrorObserver = this.onErrorObservable.add(callback);
+    }
+    /**
+     * Callback raised after the loader is disposed.
+     */
+    set onDispose(callback) {
+        if (this._onDisposeObserver) {
+            this.onDisposeObservable.remove(this._onDisposeObserver);
+        }
+        this._onDisposeObserver = this.onDisposeObservable.add(callback);
+    }
+    /**
+     * Callback raised after a loader extension is created.
+     */
+    set onExtensionLoaded(callback) {
+        if (this._onExtensionLoadedObserver) {
+            this.onExtensionLoadedObservable.remove(this._onExtensionLoadedObserver);
+        }
+        this._onExtensionLoadedObserver = this.onExtensionLoadedObservable.add(callback);
+    }
+    /**
+     * Defines if the loader logging is enabled.
+     */
+    get loggingEnabled() {
+        return this._loggingEnabled;
+    }
+    set loggingEnabled(value) {
+        if (this._loggingEnabled === value) {
+            return;
+        }
+        this._loggingEnabled = value;
+        if (this._loggingEnabled) {
+            this._log = this._logEnabled;
+        }
+        else {
+            this._log = this._logDisabled;
+        }
+    }
+    /**
+     * Defines if the loader should capture performance counters.
+     */
+    get capturePerformanceCounters() {
+        return this._capturePerformanceCounters;
+    }
+    set capturePerformanceCounters(value) {
+        if (this._capturePerformanceCounters === value) {
+            return;
+        }
+        this._capturePerformanceCounters = value;
+        if (this._capturePerformanceCounters) {
+            this._startPerformanceCounter = this._startPerformanceCounterEnabled;
+            this._endPerformanceCounter = this._endPerformanceCounterEnabled;
+        }
+        else {
+            this._startPerformanceCounter = this._startPerformanceCounterDisabled;
+            this._endPerformanceCounter = this._endPerformanceCounterDisabled;
+        }
+    }
+    /**
+     * Callback raised after a loader extension is created.
+     */
+    set onValidated(callback) {
+        if (this._onValidatedObserver) {
+            this.onValidatedObservable.remove(this._onValidatedObserver);
+        }
+        this._onValidatedObserver = this.onValidatedObservable.add(callback);
+    }
     /**
      * Disposes the loader, releases resources during load, and cancels any outstanding requests.
      */
-    GLTFFileLoader.prototype.dispose = function () {
+    dispose() {
         if (this._loader) {
             this._loader.dispose();
             this._loader = null;
         }
-        for (var _i = 0, _a = this._requests; _i < _a.length; _i++) {
-            var request = _a[_i];
+        for (const request of this._requests) {
             request.abort();
         }
         this._requests.length = 0;
         delete this._progressCallback;
-        this.preprocessUrlAsync = function (url) { return Promise.resolve(url); };
+        this.preprocessUrlAsync = (url) => Promise.resolve(url);
         this.onMeshLoadedObservable.clear();
         this.onSkinLoadedObservable.clear();
         this.onTextureLoadedObservable.clear();
@@ -430,7 +381,7 @@ var GLTFFileLoader = /** @class */ (function () {
         this.onExtensionLoadedObservable.clear();
         this.onDisposeObservable.notifyObservers(undefined);
         this.onDisposeObservable.clear();
-    };
+    }
     /**
      * @param scene
      * @param fileOrUrl
@@ -440,55 +391,54 @@ var GLTFFileLoader = /** @class */ (function () {
      * @param onError
      * @hidden
      */
-    GLTFFileLoader.prototype.loadFile = function (scene, fileOrUrl, onSuccess, onProgress, useArrayBuffer, onError) {
-        var _this = this;
+    loadFile(scene, fileOrUrl, onSuccess, onProgress, useArrayBuffer, onError) {
         this._progressCallback = onProgress;
-        var rootUrl = fileOrUrl.name ? "file:" : Tools.GetFolderPath(fileOrUrl);
-        var fileName = fileOrUrl.name || Tools.GetFilename(fileOrUrl);
+        const rootUrl = fileOrUrl.name ? "file:" : Tools.GetFolderPath(fileOrUrl);
+        const fileName = fileOrUrl.name || Tools.GetFilename(fileOrUrl);
         if (useArrayBuffer) {
             if (this.useRangeRequests) {
                 if (this.validate) {
                     Logger.Warn("glTF validation is not supported when range requests are enabled");
                 }
-                var fileRequest_1 = {
-                    abort: function () { },
+                const fileRequest = {
+                    abort: () => { },
                     onCompleteObservable: new Observable(),
                 };
-                var dataBuffer = {
-                    readAsync: function (byteOffset, byteLength) {
-                        return new Promise(function (resolve, reject) {
-                            _this._loadFile(scene, fileOrUrl, function (data) {
+                const dataBuffer = {
+                    readAsync: (byteOffset, byteLength) => {
+                        return new Promise((resolve, reject) => {
+                            this._loadFile(scene, fileOrUrl, (data) => {
                                 resolve(new Uint8Array(data));
-                            }, true, function (error) {
+                            }, true, (error) => {
                                 reject(error);
-                            }, function (webRequest) {
-                                webRequest.setRequestHeader("Range", "bytes=".concat(byteOffset, "-").concat(byteOffset + byteLength - 1));
+                            }, (webRequest) => {
+                                webRequest.setRequestHeader("Range", `bytes=${byteOffset}-${byteOffset + byteLength - 1}`);
                             });
                         });
                     },
                     byteLength: 0,
                 };
-                this._unpackBinaryAsync(new DataReader(dataBuffer)).then(function (loaderData) {
-                    fileRequest_1.onCompleteObservable.notifyObservers(fileRequest_1);
+                this._unpackBinaryAsync(new DataReader(dataBuffer)).then((loaderData) => {
+                    fileRequest.onCompleteObservable.notifyObservers(fileRequest);
                     onSuccess(loaderData);
-                }, onError ? function (error) { return onError(undefined, error); } : undefined);
-                return fileRequest_1;
+                }, onError ? (error) => onError(undefined, error) : undefined);
+                return fileRequest;
             }
-            return this._loadFile(scene, fileOrUrl, function (data) {
-                _this._validate(scene, data, rootUrl, fileName);
-                _this._unpackBinaryAsync(new DataReader({
-                    readAsync: function (byteOffset, byteLength) { return readAsync(data, byteOffset, byteLength); },
+            return this._loadFile(scene, fileOrUrl, (data) => {
+                this._validate(scene, data, rootUrl, fileName);
+                this._unpackBinaryAsync(new DataReader({
+                    readAsync: (byteOffset, byteLength) => readAsync(data, byteOffset, byteLength),
                     byteLength: data.byteLength,
-                })).then(function (loaderData) {
+                })).then((loaderData) => {
                     onSuccess(loaderData);
-                }, onError ? function (error) { return onError(undefined, error); } : undefined);
+                }, onError ? (error) => onError(undefined, error) : undefined);
             }, true, onError);
         }
-        return this._loadFile(scene, fileOrUrl, function (data) {
-            _this._validate(scene, data, rootUrl, fileName);
-            onSuccess({ json: _this._parseJson(data) });
+        return this._loadFile(scene, fileOrUrl, (data) => {
+            this._validate(scene, data, rootUrl, fileName);
+            onSuccess({ json: this._parseJson(data) });
         }, useArrayBuffer, onError);
-    };
+    }
     /**
      * @param meshesNames
      * @param scene
@@ -498,16 +448,15 @@ var GLTFFileLoader = /** @class */ (function () {
      * @param fileName
      * @hidden
      */
-    GLTFFileLoader.prototype.importMeshAsync = function (meshesNames, scene, data, rootUrl, onProgress, fileName) {
-        var _this = this;
-        return Promise.resolve().then(function () {
-            _this.onParsedObservable.notifyObservers(data);
-            _this.onParsedObservable.clear();
-            _this._log("Loading ".concat(fileName || ""));
-            _this._loader = _this._getLoader(data);
-            return _this._loader.importMeshAsync(meshesNames, scene, null, data, rootUrl, onProgress, fileName);
+    importMeshAsync(meshesNames, scene, data, rootUrl, onProgress, fileName) {
+        return Promise.resolve().then(() => {
+            this.onParsedObservable.notifyObservers(data);
+            this.onParsedObservable.clear();
+            this._log(`Loading ${fileName || ""}`);
+            this._loader = this._getLoader(data);
+            return this._loader.importMeshAsync(meshesNames, scene, null, data, rootUrl, onProgress, fileName);
         });
-    };
+    }
     /**
      * @param scene
      * @param data
@@ -516,16 +465,15 @@ var GLTFFileLoader = /** @class */ (function () {
      * @param fileName
      * @hidden
      */
-    GLTFFileLoader.prototype.loadAsync = function (scene, data, rootUrl, onProgress, fileName) {
-        var _this = this;
-        return Promise.resolve().then(function () {
-            _this.onParsedObservable.notifyObservers(data);
-            _this.onParsedObservable.clear();
-            _this._log("Loading ".concat(fileName || ""));
-            _this._loader = _this._getLoader(data);
-            return _this._loader.loadAsync(scene, data, rootUrl, onProgress, fileName);
+    loadAsync(scene, data, rootUrl, onProgress, fileName) {
+        return Promise.resolve().then(() => {
+            this.onParsedObservable.notifyObservers(data);
+            this.onParsedObservable.clear();
+            this._log(`Loading ${fileName || ""}`);
+            this._loader = this._getLoader(data);
+            return this._loader.loadAsync(scene, data, rootUrl, onProgress, fileName);
         });
-    };
+    }
     /**
      * @param scene
      * @param data
@@ -534,29 +482,28 @@ var GLTFFileLoader = /** @class */ (function () {
      * @param fileName
      * @hidden
      */
-    GLTFFileLoader.prototype.loadAssetContainerAsync = function (scene, data, rootUrl, onProgress, fileName) {
-        var _this = this;
-        return Promise.resolve().then(function () {
-            _this.onParsedObservable.notifyObservers(data);
-            _this.onParsedObservable.clear();
-            _this._log("Loading ".concat(fileName || ""));
-            _this._loader = _this._getLoader(data);
+    loadAssetContainerAsync(scene, data, rootUrl, onProgress, fileName) {
+        return Promise.resolve().then(() => {
+            this.onParsedObservable.notifyObservers(data);
+            this.onParsedObservable.clear();
+            this._log(`Loading ${fileName || ""}`);
+            this._loader = this._getLoader(data);
             // Prepare the asset container.
-            var container = new AssetContainer(scene);
+            const container = new AssetContainer(scene);
             // Get materials/textures when loading to add to container
-            var materials = [];
-            _this.onMaterialLoadedObservable.add(function (material) {
+            const materials = [];
+            this.onMaterialLoadedObservable.add((material) => {
                 materials.push(material);
             });
-            var textures = [];
-            _this.onTextureLoadedObservable.add(function (texture) {
+            const textures = [];
+            this.onTextureLoadedObservable.add((texture) => {
                 textures.push(texture);
             });
-            var cameras = [];
-            _this.onCameraLoadedObservable.add(function (camera) {
+            const cameras = [];
+            this.onCameraLoadedObservable.add((camera) => {
                 cameras.push(camera);
             });
-            return _this._loader.importMeshAsync(null, scene, container, data, rootUrl, onProgress, fileName).then(function (result) {
+            return this._loader.importMeshAsync(null, scene, container, data, rootUrl, onProgress, fileName).then((result) => {
                 Array.prototype.push.apply(container.geometries, result.geometries);
                 Array.prototype.push.apply(container.meshes, result.meshes);
                 Array.prototype.push.apply(container.particleSystems, result.particleSystems);
@@ -570,79 +517,74 @@ var GLTFFileLoader = /** @class */ (function () {
                 return container;
             });
         });
-    };
+    }
     /**
      * @param data
      * @hidden
      */
-    GLTFFileLoader.prototype.canDirectLoad = function (data) {
+    canDirectLoad(data) {
         return ((data.indexOf("asset") !== -1 && data.indexOf("version") !== -1) ||
             data.startsWith("data:base64," + GLTFFileLoader._MagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.
             data.startsWith("data:;base64," + GLTFFileLoader._MagicBase64Encoded) ||
             data.startsWith("data:application/octet-stream;base64," + GLTFFileLoader._MagicBase64Encoded) ||
             data.startsWith("data:model/gltf-binary;base64," + GLTFFileLoader._MagicBase64Encoded));
-    };
+    }
     /**
      * @param scene
      * @param data
      * @hidden
      */
-    GLTFFileLoader.prototype.directLoad = function (scene, data) {
+    directLoad(scene, data) {
         if (data.startsWith("base64," + GLTFFileLoader._MagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.
             data.startsWith(";base64," + GLTFFileLoader._MagicBase64Encoded) ||
             data.startsWith("application/octet-stream;base64," + GLTFFileLoader._MagicBase64Encoded) ||
             data.startsWith("model/gltf-binary;base64," + GLTFFileLoader._MagicBase64Encoded)) {
-            var arrayBuffer_1 = DecodeBase64UrlToBinary(data);
-            this._validate(scene, arrayBuffer_1);
+            const arrayBuffer = DecodeBase64UrlToBinary(data);
+            this._validate(scene, arrayBuffer);
             return this._unpackBinaryAsync(new DataReader({
-                readAsync: function (byteOffset, byteLength) { return readAsync(arrayBuffer_1, byteOffset, byteLength); },
-                byteLength: arrayBuffer_1.byteLength,
+                readAsync: (byteOffset, byteLength) => readAsync(arrayBuffer, byteOffset, byteLength),
+                byteLength: arrayBuffer.byteLength,
             }));
         }
         this._validate(scene, data);
         return Promise.resolve({ json: this._parseJson(data) });
-    };
+    }
     /** @hidden */
-    GLTFFileLoader.prototype.createPlugin = function () {
+    createPlugin() {
         return new GLTFFileLoader();
-    };
-    Object.defineProperty(GLTFFileLoader.prototype, "loaderState", {
-        /**
-         * The loader state or null if the loader is not active.
-         */
-        get: function () {
-            return this._state;
-        },
-        enumerable: false,
-        configurable: true
-    });
+    }
+    /**
+     * The loader state or null if the loader is not active.
+     */
+    get loaderState() {
+        return this._state;
+    }
     /**
      * Returns a promise that resolves when the asset is completely loaded.
      * @returns a promise that resolves when the asset is completely loaded.
      */
-    GLTFFileLoader.prototype.whenCompleteAsync = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            _this.onCompleteObservable.addOnce(function () {
+    whenCompleteAsync() {
+        return new Promise((resolve, reject) => {
+            this.onCompleteObservable.addOnce(() => {
                 resolve();
             });
-            _this.onErrorObservable.addOnce(function (reason) {
+            this.onErrorObservable.addOnce((reason) => {
                 reject(reason);
             });
         });
-    };
+    }
     /**
      * @param state
      * @hidden
      */
-    GLTFFileLoader.prototype._setState = function (state) {
+    _setState(state) {
         if (this._state === state) {
             return;
         }
         this._state = state;
         this.onLoaderStateChangedObservable.notifyObservers(this._state);
         this._log(GLTFLoaderState[this._state]);
-    };
+    }
     /**
      * @param scene
      * @param fileOrUrl
@@ -652,73 +594,68 @@ var GLTFFileLoader = /** @class */ (function () {
      * @param onOpened
      * @hidden
      */
-    GLTFFileLoader.prototype._loadFile = function (scene, fileOrUrl, onSuccess, useArrayBuffer, onError, onOpened) {
-        var _this = this;
-        var request = scene._loadFile(fileOrUrl, onSuccess, function (event) {
-            _this._onProgress(event, request);
+    _loadFile(scene, fileOrUrl, onSuccess, useArrayBuffer, onError, onOpened) {
+        const request = scene._loadFile(fileOrUrl, onSuccess, (event) => {
+            this._onProgress(event, request);
         }, true, useArrayBuffer, onError, onOpened);
-        request.onCompleteObservable.add(function (request) {
-            _this._requests.splice(_this._requests.indexOf(request), 1);
+        request.onCompleteObservable.add((request) => {
+            this._requests.splice(this._requests.indexOf(request), 1);
         });
         this._requests.push(request);
         return request;
-    };
-    GLTFFileLoader.prototype._onProgress = function (event, request) {
+    }
+    _onProgress(event, request) {
         if (!this._progressCallback) {
             return;
         }
         request._lengthComputable = event.lengthComputable;
         request._loaded = event.loaded;
         request._total = event.total;
-        var lengthComputable = true;
-        var loaded = 0;
-        var total = 0;
-        for (var _i = 0, _a = this._requests; _i < _a.length; _i++) {
-            var request_1 = _a[_i];
-            if (request_1._lengthComputable === undefined || request_1._loaded === undefined || request_1._total === undefined) {
+        let lengthComputable = true;
+        let loaded = 0;
+        let total = 0;
+        for (const request of this._requests) {
+            if (request._lengthComputable === undefined || request._loaded === undefined || request._total === undefined) {
                 return;
             }
-            lengthComputable = lengthComputable && request_1._lengthComputable;
-            loaded += request_1._loaded;
-            total += request_1._total;
+            lengthComputable = lengthComputable && request._lengthComputable;
+            loaded += request._loaded;
+            total += request._total;
         }
         this._progressCallback({
             lengthComputable: lengthComputable,
             loaded: loaded,
             total: lengthComputable ? total : 0,
         });
-    };
-    GLTFFileLoader.prototype._validate = function (scene, data, rootUrl, fileName) {
-        var _this = this;
-        if (rootUrl === void 0) { rootUrl = ""; }
-        if (fileName === void 0) { fileName = ""; }
+    }
+    _validate(scene, data, rootUrl = "", fileName = "") {
         if (!this.validate) {
             return;
         }
         this._startPerformanceCounter("Validate JSON");
-        GLTFValidation.ValidateAsync(data, rootUrl, fileName, function (uri) {
-            return _this.preprocessUrlAsync(rootUrl + uri).then(function (url) { return scene._loadFileAsync(url, undefined, true, true); });
-        }).then(function (result) {
-            _this._endPerformanceCounter("Validate JSON");
-            _this.onValidatedObservable.notifyObservers(result);
-            _this.onValidatedObservable.clear();
-        }, function (reason) {
-            _this._endPerformanceCounter("Validate JSON");
-            Tools.Warn("Failed to validate: ".concat(reason.message));
-            _this.onValidatedObservable.clear();
+        GLTFValidation.ValidateAsync(data, rootUrl, fileName, (uri) => {
+            return this.preprocessUrlAsync(rootUrl + uri).then((url) => scene._loadFileAsync(url, undefined, true, true));
+        }).then((result) => {
+            this._endPerformanceCounter("Validate JSON");
+            this.onValidatedObservable.notifyObservers(result);
+            this.onValidatedObservable.clear();
+        }, (reason) => {
+            this._endPerformanceCounter("Validate JSON");
+            Tools.Warn(`Failed to validate: ${reason.message}`);
+            this.onValidatedObservable.clear();
         });
-    };
-    GLTFFileLoader.prototype._getLoader = function (loaderData) {
-        var asset = loaderData.json.asset || {};
-        this._log("Asset version: ".concat(asset.version));
-        asset.minVersion && this._log("Asset minimum version: ".concat(asset.minVersion));
-        asset.generator && this._log("Asset generator: ".concat(asset.generator));
-        var version = GLTFFileLoader._parseVersion(asset.version);
+    }
+    _getLoader(loaderData) {
+        const asset = loaderData.json.asset || {};
+        this._log(`Asset version: ${asset.version}`);
+        asset.minVersion && this._log(`Asset minimum version: ${asset.minVersion}`);
+        asset.generator && this._log(`Asset generator: ${asset.generator}`);
+        const version = GLTFFileLoader._parseVersion(asset.version);
         if (!version) {
             throw new Error("Invalid version: " + asset.version);
         }
         if (asset.minVersion !== undefined) {
-            var minVersion = GLTFFileLoader._parseVersion(asset.minVersion);
+            const minVersion = GLTFFileLoader._parseVersion(asset.minVersion);
             if (!minVersion) {
                 throw new Error("Invalid minimum version: " + asset.minVersion);
             }
@@ -726,113 +663,111 @@ var GLTFFileLoader = /** @class */ (function () {
                 throw new Error("Incompatible minimum version: " + asset.minVersion);
             }
         }
-        var createLoaders = {
+        const createLoaders = {
             1: GLTFFileLoader._CreateGLTF1Loader,
             2: GLTFFileLoader._CreateGLTF2Loader,
         };
-        var createLoader = createLoaders[version.major];
+        const createLoader = createLoaders[version.major];
         if (!createLoader) {
             throw new Error("Unsupported version: " + asset.version);
         }
         return createLoader(this);
-    };
-    GLTFFileLoader.prototype._parseJson = function (json) {
+    }
+    _parseJson(json) {
         this._startPerformanceCounter("Parse JSON");
-        this._log("JSON length: ".concat(json.length));
-        var parsed = JSON.parse(json);
+        this._log(`JSON length: ${json.length}`);
+        const parsed = JSON.parse(json);
         this._endPerformanceCounter("Parse JSON");
         return parsed;
-    };
-    GLTFFileLoader.prototype._unpackBinaryAsync = function (dataReader) {
-        var _this = this;
+    }
+    _unpackBinaryAsync(dataReader) {
         this._startPerformanceCounter("Unpack Binary");
         // Read magic + version + length + json length + json format
-        return dataReader.loadAsync(20).then(function () {
-            var Binary = {
+        return dataReader.loadAsync(20).then(() => {
+            const Binary = {
                 Magic: 0x46546c67,
             };
-            var magic = dataReader.readUint32();
+            const magic = dataReader.readUint32();
             if (magic !== Binary.Magic) {
                 throw new RuntimeError("Unexpected magic: " + magic, ErrorCodes.GLTFLoaderUnexpectedMagicError);
             }
-            var version = dataReader.readUint32();
-            if (_this.loggingEnabled) {
-                _this._log("Binary version: ".concat(version));
+            const version = dataReader.readUint32();
+            if (this.loggingEnabled) {
+                this._log(`Binary version: ${version}`);
             }
-            var length = dataReader.readUint32();
+            const length = dataReader.readUint32();
             if (dataReader.buffer.byteLength !== 0 && length !== dataReader.buffer.byteLength) {
-                throw new Error("Length in header does not match actual data length: ".concat(length, " != ").concat(dataReader.buffer.byteLength));
+                throw new Error(`Length in header does not match actual data length: ${length} != ${dataReader.buffer.byteLength}`);
             }
-            var unpacked;
+            let unpacked;
             switch (version) {
                 case 1: {
-                    unpacked = _this._unpackBinaryV1Async(dataReader, length);
+                    unpacked = this._unpackBinaryV1Async(dataReader, length);
                     break;
                 }
                 case 2: {
-                    unpacked = _this._unpackBinaryV2Async(dataReader, length);
+                    unpacked = this._unpackBinaryV2Async(dataReader, length);
                     break;
                 }
                 default: {
                     throw new Error("Unsupported version: " + version);
                 }
             }
-            _this._endPerformanceCounter("Unpack Binary");
+            this._endPerformanceCounter("Unpack Binary");
             return unpacked;
         });
-    };
-    GLTFFileLoader.prototype._unpackBinaryV1Async = function (dataReader, length) {
-        var ContentFormat = {
+    }
+    _unpackBinaryV1Async(dataReader, length) {
+        const ContentFormat = {
             JSON: 0,
         };
-        var contentLength = dataReader.readUint32();
-        var contentFormat = dataReader.readUint32();
+        const contentLength = dataReader.readUint32();
+        const contentFormat = dataReader.readUint32();
         if (contentFormat !== ContentFormat.JSON) {
-            throw new Error("Unexpected content format: ".concat(contentFormat));
+            throw new Error(`Unexpected content format: ${contentFormat}`);
         }
-        var bodyLength = length - dataReader.byteOffset;
-        var data = { json: this._parseJson(dataReader.readString(contentLength)), bin: null };
+        const bodyLength = length - dataReader.byteOffset;
+        const data = { json: this._parseJson(dataReader.readString(contentLength)), bin: null };
         if (bodyLength !== 0) {
-            var startByteOffset_1 = dataReader.byteOffset;
+            const startByteOffset = dataReader.byteOffset;
             data.bin = {
-                readAsync: function (byteOffset, byteLength) { return dataReader.buffer.readAsync(startByteOffset_1 + byteOffset, byteLength); },
+                readAsync: (byteOffset, byteLength) => dataReader.buffer.readAsync(startByteOffset + byteOffset, byteLength),
                 byteLength: bodyLength,
             };
         }
         return Promise.resolve(data);
-    };
-    GLTFFileLoader.prototype._unpackBinaryV2Async = function (dataReader, length) {
-        var _this = this;
-        var ChunkFormat = {
+    }
+    _unpackBinaryV2Async(dataReader, length) {
+        const ChunkFormat = {
             JSON: 0x4e4f534a,
             BIN: 0x004e4942,
         };
         // Read the JSON chunk header.
-        var chunkLength = dataReader.readUint32();
-        var chunkFormat = dataReader.readUint32();
+        const chunkLength = dataReader.readUint32();
+        const chunkFormat = dataReader.readUint32();
         if (chunkFormat !== ChunkFormat.JSON) {
             throw new Error("First chunk format is not JSON");
         }
         // Bail if there are no other chunks.
         if (dataReader.byteOffset + chunkLength === length) {
-            return dataReader.loadAsync(chunkLength).then(function () {
-                return { json: _this._parseJson(dataReader.readString(chunkLength)), bin: null };
+            return dataReader.loadAsync(chunkLength).then(() => {
+                return { json: this._parseJson(dataReader.readString(chunkLength)), bin: null };
             });
         }
         // Read the JSON chunk and the length and type of the next chunk.
-        return dataReader.loadAsync(chunkLength + 8).then(function () {
-            var data = { json: _this._parseJson(dataReader.readString(chunkLength)), bin: null };
-            var readAsync = function () {
-                var chunkLength = dataReader.readUint32();
-                var chunkFormat = dataReader.readUint32();
+        return dataReader.loadAsync(chunkLength + 8).then(() => {
+            const data = { json: this._parseJson(dataReader.readString(chunkLength)), bin: null };
+            const readAsync = () => {
+                const chunkLength = dataReader.readUint32();
+                const chunkFormat = dataReader.readUint32();
                 switch (chunkFormat) {
                     case ChunkFormat.JSON: {
                         throw new Error("Unexpected JSON chunk");
                     }
                     case ChunkFormat.BIN: {
-                        var startByteOffset_2 = dataReader.byteOffset;
+                        const startByteOffset = dataReader.byteOffset;
                         data.bin = {
-                            readAsync: function (byteOffset, byteLength) { return dataReader.buffer.readAsync(startByteOffset_2 + byteOffset, byteLength); },
+                            readAsync: (byteOffset, byteLength) => dataReader.buffer.readAsync(startByteOffset + byteOffset, byteLength),
                             byteLength: chunkLength,
                         };
                         dataReader.skipBytes(chunkLength);
@@ -851,15 +786,15 @@ var GLTFFileLoader = /** @class */ (function () {
             };
             return readAsync();
         });
-    };
-    GLTFFileLoader._parseVersion = function (version) {
+    }
+    static _parseVersion(version) {
         if (version === "1.0" || version === "1.0.1") {
             return {
                 major: 1,
                 minor: 0,
             };
         }
-        var match = (version + "").match(/^(\d+)\.(\d+)/);
+        const match = (version + "").match(/^(\d+)\.(\d+)/);
         if (!match) {
             return null;
         }
@@ -867,8 +802,8 @@ var GLTFFileLoader = /** @class */ (function () {
             major: parseInt(match[1]),
             minor: parseInt(match[2]),
         };
-    };
-    GLTFFileLoader._compareVersion = function (a, b) {
+    }
+    static _compareVersion(a, b) {
         if (a.major > b.major) {
             return 1;
         }
@@ -882,53 +817,51 @@ var GLTFFileLoader = /** @class */ (function () {
             return -1;
         }
         return 0;
-    };
+    }
     /**
      * @param message
      * @hidden
      */
-    GLTFFileLoader.prototype._logOpen = function (message) {
+    _logOpen(message) {
         this._log(message);
         this._logIndentLevel++;
-    };
+    }
     /** @hidden */
-    GLTFFileLoader.prototype._logClose = function () {
+    _logClose() {
         --this._logIndentLevel;
-    };
-    GLTFFileLoader.prototype._logEnabled = function (message) {
-        var spaces = GLTFFileLoader._logSpaces.substr(0, this._logIndentLevel * 2);
-        Logger.Log("".concat(spaces).concat(message));
-    };
-    GLTFFileLoader.prototype._logDisabled = function (message) { };
-    GLTFFileLoader.prototype._startPerformanceCounterEnabled = function (counterName) {
+    }
+    _logEnabled(message) {
+        const spaces = GLTFFileLoader._logSpaces.substr(0, this._logIndentLevel * 2);
+        Logger.Log(`${spaces}${message}`);
+    }
+    _logDisabled(message) { }
+    _startPerformanceCounterEnabled(counterName) {
         Tools.StartPerformanceCounter(counterName);
-    };
-    GLTFFileLoader.prototype._startPerformanceCounterDisabled = function (counterName) { };
-    GLTFFileLoader.prototype._endPerformanceCounterEnabled = function (counterName) {
+    }
+    _startPerformanceCounterDisabled(counterName) { }
+    _endPerformanceCounterEnabled(counterName) {
         Tools.EndPerformanceCounter(counterName);
-    };
-    GLTFFileLoader.prototype._endPerformanceCounterDisabled = function (counterName) { };
-    // ----------
-    // V1 options
-    // ----------
-    /**
-     * Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders.
-     * Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled.
-     * Defaults to true.
-     * @hidden
-     */
-    GLTFFileLoader.IncrementalLoading = true;
-    /**
-     * Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters.
-     * Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates.
-     * @hidden
-     */
-    GLTFFileLoader.HomogeneousCoordinates = false;
-    GLTFFileLoader._MagicBase64Encoded = "Z2xURg"; // "glTF" base64 encoded (without the quotes!)
-    GLTFFileLoader._logSpaces = "                                ";
-    return GLTFFileLoader;
-}());
-export { GLTFFileLoader };
+    }
+    _endPerformanceCounterDisabled(counterName) { }
+}
+// ----------
+// V1 options
+// ----------
+/**
+ * Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders.
+ * Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled.
+ * Defaults to true.
+ * @hidden
+ */
+GLTFFileLoader.IncrementalLoading = true;
+/**
+ * Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters.
+ * Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates.
+ * @hidden
+ */
+GLTFFileLoader.HomogeneousCoordinates = false;
+GLTFFileLoader._MagicBase64Encoded = "Z2xURg"; // "glTF" base64 encoded (without the quotes!)
+GLTFFileLoader._logSpaces = "                                ";
 if (SceneLoader) {
     SceneLoader.RegisterPlugin(new GLTFFileLoader());
 }