@babylonjs/viewer 7.40.2 → 7.40.3-alpha

package/viewer/viewer.js

@@ -1,783 +0,0 @@
-import { Engine } from "@babylonjs/core/Engines/engine.js";
-import { SceneLoader } from "@babylonjs/core/Loading/sceneLoader.js";
-import { RenderingManager } from "@babylonjs/core/Rendering/renderingManager.js";
-import { Tools } from "@babylonjs/core/Misc/tools.js";
-import { Effect } from "@babylonjs/core/Materials/effect.js";
-import { processConfigurationCompatibility } from "../configuration/configurationCompatibility.js";
-import { ConfigurationContainer } from "../configuration/configurationContainer.js";
-import { viewerGlobals } from "../configuration/globals.js";
-import { RenderOnlyConfigurationLoader } from "../configuration/renderOnlyLoader.js";
-// eslint-disable-next-line import/no-internal-modules
-import { deepmerge } from "../helper/index.js";
-import { ModelLoader } from "../loader/modelLoader.js";
-import { ObservablesManager } from "../managers/observablesManager.js";
-import { SceneManager } from "../managers/sceneManager.js";
-import { telemetryManager } from "../managers/telemetryManager.js";
-import { viewerManager } from "./viewerManager.js";
-import "@babylonjs/core/Misc/observable.extensions.js";
-import { Logger } from "@babylonjs/core/Misc/logger.js";
-/**
- * The AbstractViewer is the center of Babylon's viewer.
- * It is the basic implementation of the default viewer and is responsible of loading and showing the model and the templates
- */
-var AbstractViewer = /** @class */ (function () {
-    function AbstractViewer(containerElement, initialConfiguration) {
-        if (initialConfiguration === void 0) { initialConfiguration = {}; }
-        var _this = this;
-        this.containerElement = containerElement;
-        /**
-         * A flag that controls whether or not the render loop should be executed
-         */
-        this.runRenderLoop = true;
-        /**
-         * is this viewer disposed?
-         */
-        this._isDisposed = false;
-        this._hdToggled = false;
-        this._vrToggled = false;
-        this._vrModelRepositioning = 0;
-        this._vrScale = 1;
-        this._vrInit = false;
-        /**
-         * The resize function that will be registered with the window object
-         */
-        this._resize = function () {
-            // Only resize if Canvas is in the DOM
-            if (!_this.isCanvasInDOM()) {
-                return;
-            }
-            if (_this.canvas.clientWidth <= 0 || _this.canvas.clientHeight <= 0) {
-                return;
-            }
-            if (_this.configuration.engine && _this.configuration.engine.disableResize) {
-                return;
-            }
-            _this.engine.resize();
-        };
-        /**
-         * render loop that will be executed by the engine
-         * @param force
-         */
-        this._render = function (force) {
-            if (force === void 0) { force = false; }
-            if (force || (_this.sceneManager.scene && _this.sceneManager.scene.activeCamera)) {
-                if (_this.runRenderLoop || force) {
-                    _this.engine.performanceMonitor.enable();
-                    _this.sceneManager.scene.render();
-                    _this.onFrameRenderedObservable.notifyObservers(_this);
-                }
-                else {
-                    _this.engine.performanceMonitor.disable();
-                    // update camera instead of rendering
-                    _this.sceneManager.scene.activeCamera && _this.sceneManager.scene.activeCamera.update();
-                }
-            }
-        };
-        // if exists, use the container id. otherwise, generate a random string.
-        if (containerElement.id) {
-            this.baseId = containerElement.id;
-        }
-        else {
-            this.baseId = containerElement.id = "bjs" + Math.random().toString(32).substring(2, 10);
-        }
-        this._registeredOnBeforeRenderFunctions = [];
-        this._configurationContainer = new ConfigurationContainer();
-        this.observablesManager = new ObservablesManager();
-        this.modelLoader = new ModelLoader(this.observablesManager, this._configurationContainer);
-        RenderingManager.AUTOCLEAR = false;
-        // extend the configuration
-        this._configurationLoader = this.getConfigurationLoader();
-        this._configurationLoader.loadConfiguration(initialConfiguration, function (configuration) {
-            _this._onConfigurationLoaded(configuration);
-        });
-        this.onSceneInitObservable.add(function () {
-            _this.updateConfiguration();
-        });
-        this.onInitDoneObservable.add(function () {
-            _this._isInit = true;
-            _this.engine.runRenderLoop(_this._render);
-        });
-        this._prepareContainerElement();
-        // add this viewer to the viewer manager
-        viewerManager.addViewer(this);
-    }
-    Object.defineProperty(AbstractViewer.prototype, "onSceneInitObservable", {
-        // observables
-        /**
-         * Will notify when the scene was initialized
-         */
-        get: function () {
-            return this.observablesManager.onSceneInitObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onEngineInitObservable", {
-        /**
-         * will notify when the engine was initialized
-         */
-        get: function () {
-            return this.observablesManager.onEngineInitObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onModelAddedObservable", {
-        /**
-         * Will notify when a new model was added to the scene.
-         * Note that added does not necessarily mean loaded!
-         */
-        get: function () {
-            return this.observablesManager.onModelAddedObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onModelLoadedObservable", {
-        /**
-         * will notify after every model load
-         */
-        get: function () {
-            return this.observablesManager.onModelLoadedObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onModelLoadProgressObservable", {
-        /**
-         * will notify when any model notify of progress
-         */
-        get: function () {
-            return this.observablesManager.onModelLoadProgressObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onModelLoadErrorObservable", {
-        /**
-         * will notify when any model load failed.
-         */
-        get: function () {
-            return this.observablesManager.onModelLoadErrorObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onModelRemovedObservable", {
-        /**
-         * Will notify when a model was removed from the scene;
-         */
-        get: function () {
-            return this.observablesManager.onModelRemovedObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onLoaderInitObservable", {
-        /**
-         * will notify when a new loader was initialized.
-         * Used mainly to know when a model starts loading.
-         */
-        get: function () {
-            return this.observablesManager.onLoaderInitObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onInitDoneObservable", {
-        /**
-         * Observers registered here will be executed when the entire load process has finished.
-         */
-        get: function () {
-            return this.observablesManager.onViewerInitDoneObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onFrameRenderedObservable", {
-        /**
-         * Functions added to this observable will be executed on each frame rendered.
-         */
-        get: function () {
-            return this.observablesManager.onFrameRenderedObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onEnteringVRObservable", {
-        /**
-         * Observers registered here will be executed when VR more is entered.
-         */
-        get: function () {
-            return this.observablesManager.onEnteringVRObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "onExitingVRObservable", {
-        /**
-         * Observers registered here will be executed when VR mode is exited.
-         */
-        get: function () {
-            return this.observablesManager.onExitingVRObservable;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "canvas", {
-        /**
-         * The (single) canvas of this viewer
-         */
-        get: function () {
-            return this._canvas;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "configurationContainer", {
-        get: function () {
-            return this._configurationContainer;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    AbstractViewer.prototype.getConfigurationLoader = function () {
-        return new RenderOnlyConfigurationLoader();
-    };
-    /**
-     * get the baseId of this viewer
-     * @returns the baseId of this viewer
-     */
-    AbstractViewer.prototype.getBaseId = function () {
-        return this.baseId;
-    };
-    /**
-     * Do we have a canvas to render on, and is it a part of the scene
-     * @returns true if the canvas is in the DOM
-     */
-    AbstractViewer.prototype.isCanvasInDOM = function () {
-        return !!this._canvas && !!this._canvas.parentElement;
-    };
-    Object.defineProperty(AbstractViewer.prototype, "renderInBackground", {
-        /**
-         * Is the engine currently set to render even when the page is in background
-         */
-        get: function () {
-            return this.engine && this.engine.renderEvenInBackground;
-        },
-        /**
-         * Set the viewer's background rendering flag.
-         */
-        set: function (value) {
-            if (this.engine) {
-                this.engine.renderEvenInBackground = value;
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AbstractViewer.prototype, "configuration", {
-        /**
-         * Get the configuration object. This is a reference only.
-         * The configuration can ONLY be updated using the updateConfiguration function.
-         * changing this object will have no direct effect on the scene.
-         */
-        get: function () {
-            return this._configurationContainer.configuration;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * force resizing the engine.
-     */
-    AbstractViewer.prototype.forceResize = function () {
-        this._resize();
-    };
-    AbstractViewer.prototype.toggleHD = function () {
-        this._hdToggled = !this._hdToggled;
-        var scale = this._hdToggled ? Math.max(0.5, 1 / (window.devicePixelRatio || 2)) : 1;
-        this.engine.setHardwareScalingLevel(scale);
-    };
-    AbstractViewer.prototype.toggleVR = function () {
-        if (!this._vrInit) {
-            this._initVR();
-        }
-        if (this.sceneManager.vrHelper && !this.sceneManager.vrHelper.isInVRMode) {
-            // make sure the floor is set
-            if (this.sceneManager.environmentHelper && this.sceneManager.environmentHelper.ground) {
-                this.sceneManager.vrHelper.addFloorMesh(this.sceneManager.environmentHelper.ground);
-            }
-            this._vrToggled = true;
-            this.sceneManager.vrHelper.enterVR();
-            // position the vr camera to be in front of the object or wherever the user has configured it to be
-            if (this.sceneManager.vrHelper.currentVRCamera && this.sceneManager.vrHelper.currentVRCamera !== this.sceneManager.camera) {
-                if (this.configuration.vr && this.configuration.vr.cameraPosition !== undefined) {
-                    this.sceneManager.vrHelper.currentVRCamera.position.copyFromFloats(this.configuration.vr.cameraPosition.x, this.configuration.vr.cameraPosition.y, this.configuration.vr.cameraPosition.z);
-                }
-                else {
-                    this.sceneManager.vrHelper.currentVRCamera.position.copyFromFloats(0, this.sceneManager.vrHelper.currentVRCamera.position.y, -1);
-                }
-                this.sceneManager.vrHelper.currentVRCamera.rotationQuaternion &&
-                    this.sceneManager.vrHelper.currentVRCamera.rotationQuaternion.copyFromFloats(0, 0, 0, 1);
-                // set the height of the model to be what the user has configured, or floating by default
-                if (this.configuration.vr && this.configuration.vr.modelHeightCorrection !== undefined) {
-                    if (typeof this.configuration.vr.modelHeightCorrection === "number") {
-                        this._vrModelRepositioning = this.configuration.vr.modelHeightCorrection;
-                    }
-                    else if (this.configuration.vr.modelHeightCorrection) {
-                        this._vrModelRepositioning = this.sceneManager.vrHelper.currentVRCamera.position.y / 2;
-                    }
-                    else {
-                        this._vrModelRepositioning = 0;
-                    }
-                }
-                // scale the model
-                if (this.sceneManager.models.length) {
-                    var boundingVectors = this.sceneManager.models[0].rootMesh.getHierarchyBoundingVectors();
-                    var sizeVec = boundingVectors.max.subtract(boundingVectors.min);
-                    var maxDimension = Math.max(sizeVec.x, sizeVec.y, sizeVec.z);
-                    this._vrScale = 1 / maxDimension;
-                    if (this.configuration.vr && this.configuration.vr.objectScaleFactor) {
-                        this._vrScale *= this.configuration.vr.objectScaleFactor;
-                    }
-                    this.sceneManager.models[0].rootMesh.scaling.scaleInPlace(this._vrScale);
-                    // reposition the object to "float" in front of the user
-                    this.sceneManager.models[0].rootMesh.position.y += this._vrModelRepositioning;
-                    this.sceneManager.models[0].rootMesh.rotationQuaternion = null;
-                }
-                // scale the environment to match the model
-                if (this.sceneManager.environmentHelper) {
-                    this.sceneManager.environmentHelper.ground && this.sceneManager.environmentHelper.ground.scaling.scaleInPlace(this._vrScale);
-                    this.sceneManager.environmentHelper.skybox && this.sceneManager.environmentHelper.skybox.scaling.scaleInPlace(this._vrScale);
-                }
-                // post processing
-                if (this.sceneManager.defaultRenderingPipelineEnabled && this.sceneManager.defaultRenderingPipeline) {
-                    this.sceneManager.defaultRenderingPipeline.imageProcessingEnabled = false;
-                    this.sceneManager.defaultRenderingPipeline.prepare();
-                }
-            }
-            else {
-                this._vrModelRepositioning = 0;
-            }
-        }
-        else {
-            if (this.sceneManager.vrHelper) {
-                this.sceneManager.vrHelper.exitVR();
-            }
-        }
-    };
-    AbstractViewer.prototype._initVR = function () {
-        var _this = this;
-        if (this.sceneManager.vrHelper) {
-            this.observablesManager.onExitingVRObservable.add(function () {
-                if (_this._vrToggled) {
-                    _this._vrToggled = false;
-                    // undo the scaling of the model
-                    if (_this.sceneManager.models.length) {
-                        _this.sceneManager.models[0].rootMesh.scaling.scaleInPlace(1 / _this._vrScale);
-                        _this.sceneManager.models[0].rootMesh.position.y -= _this._vrModelRepositioning;
-                    }
-                    // undo the scaling of the environment
-                    if (_this.sceneManager.environmentHelper) {
-                        _this.sceneManager.environmentHelper.ground && _this.sceneManager.environmentHelper.ground.scaling.scaleInPlace(1 / _this._vrScale);
-                        _this.sceneManager.environmentHelper.skybox && _this.sceneManager.environmentHelper.skybox.scaling.scaleInPlace(1 / _this._vrScale);
-                    }
-                    // post processing
-                    if (_this.sceneManager.defaultRenderingPipelineEnabled && _this.sceneManager.defaultRenderingPipeline) {
-                        _this.sceneManager.defaultRenderingPipeline.imageProcessingEnabled = true;
-                        _this.sceneManager.defaultRenderingPipeline.prepare();
-                    }
-                    // clear set height and width
-                    _this.canvas.removeAttribute("height");
-                    _this.canvas.removeAttribute("width");
-                    _this.engine.resize();
-                }
-            });
-        }
-        this._vrInit = true;
-    };
-    AbstractViewer.prototype._onConfigurationLoaded = function (configuration) {
-        var _this = this;
-        this._configurationContainer.configuration = deepmerge(this.configuration || {}, configuration);
-        if (this.configuration.observers) {
-            this._configureObservers(this.configuration.observers);
-        }
-        // TODO remove this after testing, as this is done in the updateConfiguration as well.
-        if (this.configuration.loaderPlugins) {
-            Object.keys(this.configuration.loaderPlugins).forEach(function (name) {
-                if (_this.configuration.loaderPlugins && _this.configuration.loaderPlugins[name]) {
-                    _this.modelLoader.addPlugin(name);
-                }
-            });
-        }
-        this.observablesManager.onViewerInitStartedObservable.notifyObservers(this);
-    };
-    /**
-     * Force a single render loop execution.
-     */
-    AbstractViewer.prototype.forceRender = function () {
-        this._render(true);
-    };
-    /**
-     * Takes a screenshot of the scene and returns it as a base64 encoded png.
-     * @param callback optional callback that will be triggered when screenshot is done.
-     * @param width Optional screenshot width (default to 512).
-     * @param height Optional screenshot height (default to 512).
-     * @returns a promise with the screenshot data
-     */
-    AbstractViewer.prototype.takeScreenshot = function (callback, width, height) {
-        var _this = this;
-        if (width === void 0) { width = 0; }
-        if (height === void 0) { height = 0; }
-        width = width || this.canvas.clientWidth;
-        height = height || this.canvas.clientHeight;
-        // Create the screenshot
-        return new Promise(function (resolve, reject) {
-            try {
-                Tools.CreateScreenshot(_this.engine, _this.sceneManager.camera, { width: width, height: height }, function (data) {
-                    if (callback) {
-                        callback(data);
-                    }
-                    resolve(data);
-                });
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-    };
-    /**
-     * Update the current viewer configuration with new values.
-     * Only provided information will be updated, old configuration values will be kept.
-     * If this.configuration was manually changed, you can trigger this function with no parameters,
-     * and the entire configuration will be updated.
-     * @param newConfiguration the partial configuration to update or a URL to a JSON holding the updated configuration
-     *
-     */
-    AbstractViewer.prototype.updateConfiguration = function (newConfiguration) {
-        var _this = this;
-        if (newConfiguration === void 0) { newConfiguration = this.configuration; }
-        if (typeof newConfiguration === "string") {
-            Tools.LoadFile(newConfiguration, function (data) {
-                try {
-                    var newData = JSON.parse(data.toString());
-                    return _this.updateConfiguration(newData);
-                }
-                catch (e) {
-                    Logger.Log("Error parsing file " + newConfiguration);
-                }
-            }, undefined, undefined, undefined, function (error) {
-                Logger.Log(["Error parsing file " + newConfiguration, error]);
-            });
-        }
-        else {
-            //backcompat
-            processConfigurationCompatibility(newConfiguration);
-            // update this.configuration with the new data
-            this._configurationContainer.configuration = deepmerge(this.configuration || {}, newConfiguration);
-            this.sceneManager.updateConfiguration(newConfiguration);
-            // observers in configuration
-            if (newConfiguration.observers) {
-                this._configureObservers(newConfiguration.observers);
-            }
-            if (newConfiguration.loaderPlugins) {
-                Object.keys(newConfiguration.loaderPlugins).forEach(function (name) {
-                    if (newConfiguration.loaderPlugins && newConfiguration.loaderPlugins[name]) {
-                        _this.modelLoader.addPlugin(name);
-                    }
-                });
-            }
-        }
-    };
-    /**
-     * this is used to register native functions using the configuration object.
-     * This will configure the observers.
-     * @param observersConfiguration observers configuration
-     */
-    AbstractViewer.prototype._configureObservers = function (observersConfiguration) {
-        if (observersConfiguration.onEngineInit) {
-            this.onEngineInitObservable.add(window[observersConfiguration.onEngineInit]);
-        }
-        else {
-            if (observersConfiguration.onEngineInit === "" && this.configuration.observers && this.configuration.observers.onEngineInit) {
-                this.onEngineInitObservable.removeCallback(window[this.configuration.observers.onEngineInit]);
-            }
-        }
-        if (observersConfiguration.onSceneInit) {
-            this.onSceneInitObservable.add(window[observersConfiguration.onSceneInit]);
-        }
-        else {
-            if (observersConfiguration.onSceneInit === "" && this.configuration.observers && this.configuration.observers.onSceneInit) {
-                this.onSceneInitObservable.removeCallback(window[this.configuration.observers.onSceneInit]);
-            }
-        }
-        if (observersConfiguration.onModelLoaded) {
-            this.onModelLoadedObservable.add(window[observersConfiguration.onModelLoaded]);
-        }
-        else {
-            if (observersConfiguration.onModelLoaded === "" && this.configuration.observers && this.configuration.observers.onModelLoaded) {
-                this.onModelLoadedObservable.removeCallback(window[this.configuration.observers.onModelLoaded]);
-            }
-        }
-    };
-    /**
-     * Dispose the entire viewer including the scene and the engine
-     */
-    AbstractViewer.prototype.dispose = function () {
-        if (this._isDisposed) {
-            return;
-        }
-        window.removeEventListener("resize", this._resize);
-        if (this.sceneManager) {
-            if (this.sceneManager.scene && this.sceneManager.scene.activeCamera) {
-                this.sceneManager.scene.activeCamera.detachControl();
-            }
-            this.sceneManager.dispose();
-        }
-        this._fpsTimeoutInterval && clearInterval(this._fpsTimeoutInterval);
-        this.observablesManager.dispose();
-        this.modelLoader.dispose();
-        if (this.engine) {
-            this.engine.dispose();
-        }
-        viewerManager.removeViewer(this);
-        this._isDisposed = true;
-    };
-    /**
-     * This function will execute when the HTML templates finished initializing.
-     * It should initialize the engine and continue execution.
-     *
-     * @returns The viewer object will be returned after the object was loaded.
-     */
-    AbstractViewer.prototype._onTemplatesLoaded = function () {
-        return Promise.resolve(this);
-    };
-    /**
-     * This will force the creation of an engine and a scene.
-     * It will also load a model if preconfigured.
-     * But first - it will load the extendible onTemplateLoaded()!
-     * @returns A promise that will resolve when the template was loaded
-     */
-    AbstractViewer.prototype._onTemplateLoaded = function () {
-        var _this = this;
-        // check if viewer was disposed right after created
-        if (this._isDisposed) {
-            return Promise.reject("viewer was disposed");
-        }
-        return this._onTemplatesLoaded().then(function () {
-            var autoLoad = typeof _this.configuration.model === "string" || (_this.configuration.model && _this.configuration.model.url);
-            return _this._initEngine()
-                .then(function (engine) {
-                return _this.onEngineInitObservable.notifyObserversWithPromise(engine);
-            })
-                .then(function () {
-                _this._initTelemetryEvents();
-                if (autoLoad) {
-                    return _this.loadModel(_this.configuration.model)
-                        .catch(function () { })
-                        .then(function () {
-                        return _this.sceneManager.scene;
-                    });
-                }
-                else {
-                    return _this.sceneManager.scene || _this.sceneManager.initScene(_this.configuration.scene);
-                }
-            })
-                .then(function () {
-                return _this.onInitDoneObservable.notifyObserversWithPromise(_this);
-            })
-                .catch(function (e) {
-                Tools.Warn(e.toString());
-                return _this;
-            });
-        });
-    };
-    /**
-     * Initialize the engine. Returns a promise in case async calls are needed.
-     *
-     * @protected
-     * @returns {Promise<Engine>}
-     * @memberof Viewer
-     */
-    AbstractViewer.prototype._initEngine = function () {
-        // init custom shaders
-        this._injectCustomShaders();
-        //let canvasElement = this.templateManager.getCanvas();
-        if (!this.canvas) {
-            return Promise.reject("Canvas element not found!");
-        }
-        var config = this.configuration.engine || {};
-        // TDO enable further configuration
-        // check for webgl2 support, force-disable if needed.
-        if (viewerGlobals.disableWebGL2Support) {
-            config.engineOptions = config.engineOptions || {};
-            config.engineOptions.disableWebGL2Support = true;
-        }
-        if (this.configuration["3dCommerceCertified"]) {
-            config.engineOptions = config.engineOptions || {};
-            config.engineOptions.forceSRGBBufferSupportState = true;
-            var loader = SceneLoader.GetPluginForExtension(".gltf");
-            if (loader) {
-                loader.transparencyAsCoverage = true;
-            }
-            SceneLoader.OnPluginActivatedObservable.add(function (plugin) {
-                if (plugin.name === "gltf") {
-                    var loader_1 = plugin;
-                    loader_1.transparencyAsCoverage = true;
-                }
-            });
-        }
-        this.engine = new Engine(this.canvas, !!config.antialiasing, config.engineOptions);
-        if (!config.disableResize) {
-            window.addEventListener("resize", this._resize);
-        }
-        if (this.configuration.engine) {
-            if (this.configuration.engine.adaptiveQuality) {
-                var scale = Math.max(0.5, 1 / (window.devicePixelRatio || 2));
-                this.engine.setHardwareScalingLevel(scale);
-            }
-            if (this.configuration.engine.hdEnabled) {
-                this.toggleHD();
-            }
-        }
-        // create a new template manager for this viewer
-        this.sceneManager = new SceneManager(this.engine, this._configurationContainer, this.observablesManager);
-        return Promise.resolve(this.engine);
-    };
-    /**
-     * Initialize a model loading. The returned object (a ViewerModel object) will be loaded in the background.
-     * The difference between this and loadModel is that loadModel will fulfill the promise when the model finished loading.
-     *
-     * @param modelConfig model configuration to use when loading the model.
-     * @param clearScene should the scene be cleared before loading this model
-     * @returns a ViewerModel object that is not yet fully loaded.
-     */
-    AbstractViewer.prototype.initModel = function (modelConfig, clearScene) {
-        var _this = this;
-        if (clearScene === void 0) { clearScene = true; }
-        var configuration;
-        if (typeof modelConfig === "string") {
-            configuration = {
-                url: modelConfig,
-            };
-        }
-        else if (modelConfig instanceof File) {
-            configuration = {
-                file: modelConfig,
-                root: "file:",
-            };
-        }
-        else {
-            configuration = modelConfig;
-        }
-        if (!configuration.url && !configuration.file) {
-            throw new Error("no model provided");
-        }
-        if (clearScene) {
-            this.sceneManager.clearScene(true, false);
-        }
-        //merge the configuration for future models:
-        if (this.configuration.model && typeof this.configuration.model === "object") {
-            var globalConfig = deepmerge({}, this.configuration.model);
-            configuration = deepmerge(globalConfig, configuration);
-            if (modelConfig instanceof File) {
-                configuration.file = modelConfig;
-            }
-        }
-        else {
-            this.configuration.model = configuration;
-        }
-        this._isLoading = true;
-        var model = this.modelLoader.load(configuration);
-        this.lastUsedLoader = model.loader;
-        model.onLoadErrorObservable.add(function (errorObject) {
-            _this.onModelLoadErrorObservable.notifyObserversWithPromise(errorObject);
-        });
-        model.onLoadProgressObservable.add(function (progressEvent) {
-            _this.onModelLoadProgressObservable.notifyObserversWithPromise(progressEvent);
-        });
-        this.onLoaderInitObservable.notifyObserversWithPromise(this.lastUsedLoader);
-        model.onLoadedObservable.add(function () {
-            _this._isLoading = false;
-        });
-        return model;
-    };
-    /**
-     * load a model using the provided configuration.
-     * This function, as opposed to initModel, will return a promise that resolves when the model is loaded, and rejects with error.
-     * If you want to attach to the observables of the model, use initModel instead.
-     *
-     * @param modelConfig the model configuration or URL to load.
-     * @param clearScene Should the scene be cleared before loading the model
-     * @returns a Promise the fulfills when the model finished loading successfully.
-     */
-    AbstractViewer.prototype.loadModel = function (modelConfig, clearScene) {
-        var _this = this;
-        if (clearScene === void 0) { clearScene = true; }
-        if (this._isLoading) {
-            // We can decide here whether or not to cancel the lst load, but the developer can do that.
-            return Promise.reject("another model is curently being loaded.");
-        }
-        return Promise.resolve(this.sceneManager.scene)
-            .then(function (scene) {
-            if (!scene) {
-                return _this.sceneManager.initScene(_this.configuration.scene);
-            }
-            return scene;
-        })
-            .then(function () {
-            var model = _this.initModel(modelConfig, clearScene);
-            return new Promise(function (resolve, reject) {
-                // at this point, configuration.model is an object, not a string
-                model.onLoadedObservable.add(function () {
-                    resolve(model);
-                });
-                model.onLoadErrorObservable.add(function (error) {
-                    reject(error);
-                });
-            });
-        });
-    };
-    AbstractViewer.prototype._initTelemetryEvents = function () {
-        var _this = this;
-        telemetryManager.broadcast("Engine Capabilities", this.baseId, this.engine.getCaps());
-        telemetryManager.broadcast("Platform Details", this.baseId, {
-            userAgent: navigator.userAgent,
-            platform: navigator.platform,
-        });
-        telemetryManager.flushWebGLErrors(this.engine, this.baseId);
-        var trackFPS = function () {
-            telemetryManager.broadcast("Current FPS", _this.baseId, { fps: _this.engine.getFps() });
-        };
-        trackFPS();
-        // Track the FPS again after 60 seconds
-        this._fpsTimeoutInterval = window.setInterval(trackFPS, 60 * 1000);
-    };
-    /**
-     * Injects all the spectre shader in the babylon shader store
-     */
-    AbstractViewer.prototype._injectCustomShaders = function () {
-        var customShaders = this.configuration.customShaders;
-        // Inject all the spectre shader in the babylon shader store.
-        if (!customShaders) {
-            return;
-        }
-        if (customShaders.shaders) {
-            Object.keys(customShaders.shaders).forEach(function (key) {
-                // typescript considers a callback "unsafe", so... '!'
-                Effect.ShadersStore[key] = customShaders.shaders[key];
-            });
-        }
-        if (customShaders.includes) {
-            Object.keys(customShaders.includes).forEach(function (key) {
-                // typescript considers a callback "unsafe", so... '!'
-                Effect.IncludesShadersStore[key] = customShaders.includes[key];
-            });
-        }
-    };
-    return AbstractViewer;
-}());
-export { AbstractViewer };
-//# sourceMappingURL=viewer.js.map