@babylonjs/viewer 7.41.1 → 7.42.0-alpha

package/managers/sceneManager.js

@@ -1,1375 +0,0 @@
-import { getConfigurationKey } from "../configuration/configuration.js";
-import { ModelState } from "../model/viewerModel.js";
-import { extendClassWithConfig, deepmerge } from "../helper/index.js";
-import { ViewerLabs } from "../labs/viewerLabs.js";
-import { getCustomOptimizerByName } from "../optimizer/custom/index.js";
-import { Observable } from "@babylonjs/core/Misc/observable.js";
-import { SceneOptimizer, SceneOptimizerOptions } from "@babylonjs/core/Misc/sceneOptimizer.js";
-import { ArcRotateCamera } from "@babylonjs/core/Cameras/arcRotateCamera.js";
-import { Light } from "@babylonjs/core/Lights/light.js";
-import { EnvironmentHelper } from "@babylonjs/core/Helpers/environmentHelper.js";
-import { Color3, Quaternion, Vector3, Axis, Matrix } from "@babylonjs/core/Maths/math.js";
-import { DefaultRenderingPipeline } from "@babylonjs/core/PostProcesses/RenderPipeline/Pipelines/defaultRenderingPipeline.js";
-import { Animation } from "@babylonjs/core/Animations/index.js";
-import { AnimationPropertiesOverride } from "@babylonjs/core/Animations/animationPropertiesOverride.js";
-import { RenderTargetTexture } from "@babylonjs/core/Materials/Textures/renderTargetTexture.js";
-import { PBRMaterial } from "@babylonjs/core/Materials/PBR/pbrMaterial.js";
-import { ShadowLight } from "@babylonjs/core/Lights/shadowLight.js";
-import { CubeTexture } from "@babylonjs/core/Materials/Textures/cubeTexture.js";
-import { HemisphericLight } from "@babylonjs/core/Lights/hemisphericLight.js";
-import { Scalar } from "@babylonjs/core/Maths/math.scalar.js";
-import { CreatePlane } from "@babylonjs/core/Meshes/Builders/planeBuilder.js";
-import { Tags } from "@babylonjs/core/Misc/tags.js";
-import { Scene } from "@babylonjs/core/scene.js";
-import { ShadowGenerator } from "@babylonjs/core/Lights/Shadows/shadowGenerator.js";
-import { Constants } from "@babylonjs/core/Engines/constants.js";
-import "@babylonjs/core/Audio/audioSceneComponent.js";
-import "@babylonjs/core/Helpers/sceneHelpers.js";
-import "@babylonjs/core/Misc/observable.extensions.js";
-var SceneManager = /** @class */ (function () {
-    function SceneManager(_engine, _configurationContainer, _observablesManager) {
-        var _this = this;
-        this._engine = _engine;
-        this._configurationContainer = _configurationContainer;
-        this._observablesManager = _observablesManager;
-        this._white = Color3.White();
-        this._forceShadowUpdate = false;
-        this._processShadows = true;
-        this._groundEnabled = true;
-        this._groundMirrorEnabled = true;
-        this._defaultRenderingPipelineEnabled = false;
-        this._globalConfiguration = {};
-        this._defaultRenderingPipelineShouldBuild = true;
-        // default from rendering pipeline
-        this._bloomEnabled = false;
-        // default from rendering pipeline
-        this._fxaaEnabled = false;
-        this._focusOnModel = function (model) {
-            var boundingInfo = model.rootMesh.getHierarchyBoundingVectors(true);
-            var sizeVec = boundingInfo.max.subtract(boundingInfo.min);
-            var halfSizeVec = sizeVec.scale(0.5);
-            var center = boundingInfo.min.add(halfSizeVec);
-            _this.camera.setTarget(center);
-            _this.camera.alpha = (_this._globalConfiguration.camera && _this._globalConfiguration.camera.alpha) || _this.camera.alpha;
-            _this.camera.beta = (_this._globalConfiguration.camera && _this._globalConfiguration.camera.beta) || _this.camera.beta;
-            _this.camera.radius = (_this._globalConfiguration.camera && _this._globalConfiguration.camera.radius) || _this.camera.radius;
-            var sceneDiagonalLenght = sizeVec.length();
-            if (isFinite(sceneDiagonalLenght)) {
-                _this.camera.upperRadiusLimit = sceneDiagonalLenght * 4;
-            }
-            if (_this._configurationContainer.configuration) {
-                _this._configureEnvironment(_this._configurationContainer.configuration.skybox, _this._configurationContainer.configuration.ground);
-            }
-            /*this.scene.lights.filter(light => light instanceof ShadowLight).forEach(light => {
-                // casting ais safe, due to the constraints tested before
-                (<ShadowLight>light).setDirectionToTarget(center);
-            });*/
-        };
-        this._cameraBehaviorMapping = {};
-        this.models = [];
-        this.onCameraConfiguredObservable = new Observable();
-        this.onLightsConfiguredObservable = new Observable();
-        this.onModelsConfiguredObservable = new Observable();
-        this.onSceneConfiguredObservable = new Observable();
-        this.onSceneInitObservable = new Observable(undefined, true);
-        this.onSceneOptimizerConfiguredObservable = new Observable();
-        this.onEnvironmentConfiguredObservable = new Observable();
-        this.onVRConfiguredObservable = new Observable();
-        //this._viewer.onEngineInitObservable.add(() => {
-        this._handleHardwareLimitations();
-        //});
-        this.onSceneInitObservable.add(function (scene) {
-            _this.scene.animationPropertiesOverride = _this.scene.animationPropertiesOverride || new AnimationPropertiesOverride();
-            _this.labs = new ViewerLabs(scene);
-            var updateShadows = function () {
-                for (var _i = 0, _a = _this.scene.lights; _i < _a.length; _i++) {
-                    var light = _a[_i];
-                    var generators = light.getShadowGenerators();
-                    if (generators) {
-                        // Processing shadows if animates
-                        var iterator = generators.values();
-                        for (var key = iterator.next(); key.done !== true; key = iterator.next()) {
-                            var generator = key.value;
-                            var shadowMap = generator.getShadowMap();
-                            if (shadowMap) {
-                                shadowMap.refreshRate = RenderTargetTexture.REFRESHRATE_RENDER_ONCE;
-                            }
-                        }
-                    }
-                }
-            };
-            scene.registerBeforeRender(function () {
-                if (_this._forceShadowUpdate || (scene.animatables && scene.animatables.length > 0)) {
-                    // make sure all models are loaded
-                    updateShadows();
-                    _this._forceShadowUpdate = false;
-                }
-                else if (!_this.models.every(function (model) {
-                    if (!model.shadowsRenderedAfterLoad) {
-                        model.shadowsRenderedAfterLoad = true;
-                        return false;
-                    }
-                    return model.state === ModelState.COMPLETE && !model.currentAnimation;
-                })) {
-                    updateShadows();
-                }
-            });
-            return _this._observablesManager && _this._observablesManager.onSceneInitObservable.notifyObserversWithPromise(_this.scene);
-        });
-        if (this._observablesManager) {
-            this._observablesManager.onModelLoadedObservable.add(function (model) {
-                for (var _i = 0, _a = _this.scene.lights; _i < _a.length; _i++) {
-                    var light = _a[_i];
-                    var generators = light.getShadowGenerators();
-                    if (generators) {
-                        // Processing shadows if animates
-                        var iterator = generators.values();
-                        for (var key = iterator.next(); key.done !== true; key = iterator.next()) {
-                            var generator = key.value;
-                            var shadowMap = generator.getShadowMap();
-                            if (shadowMap) {
-                                shadowMap.refreshRate = RenderTargetTexture.REFRESHRATE_RENDER_ONCE;
-                            }
-                        }
-                    }
-                }
-                _this._focusOnModel(model);
-            });
-            this._observablesManager.onModelAddedObservable.add(function (model) {
-                _this.models.push(model);
-            });
-            this._observablesManager.onModelRemovedObservable.add(function (model) {
-                _this.models.splice(_this.models.indexOf(model), 1);
-            });
-        }
-    }
-    Object.defineProperty(SceneManager.prototype, "defaultRenderingPipeline", {
-        get: function () {
-            return this._defaultRenderingPipeline;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "vrHelper", {
-        get: function () {
-            return this._vrHelper;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "isHdrSupported", {
-        /**
-         * Returns a boolean representing HDR support
-         */
-        get: function () {
-            return this._hdrSupport;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "mainColor", {
-        /**
-         * Return the main color defined in the configuration.
-         */
-        get: function () {
-            return this._configurationContainer.mainColor;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "reflectionColor", {
-        get: function () {
-            return this._configurationContainer.reflectionColor;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "animationBlendingEnabled", {
-        get: function () {
-            return this.scene && this.scene.animationPropertiesOverride.enableBlending;
-        },
-        set: function (value) {
-            this.scene.animationPropertiesOverride.enableBlending = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "observablesManager", {
-        get: function () {
-            return this._observablesManager;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "processShadows", {
-        /**
-         * The flag defining whether shadows are rendered constantly or once.
-         */
-        get: function () {
-            return this._processShadows;
-        },
-        /**
-         * Should shadows be rendered every frame, or only once and stop.
-         * This can be used to optimize a scene.
-         *
-         * Not that the shadows will NOT disapear but will remain in place.
-         * @param process if true shadows will be updated once every frame. if false they will stop being updated.
-         */
-        set: function (process) {
-            var refreshType = process ? RenderTargetTexture.REFRESHRATE_RENDER_ONEVERYFRAME : RenderTargetTexture.REFRESHRATE_RENDER_ONCE;
-            for (var _i = 0, _a = this.scene.lights; _i < _a.length; _i++) {
-                var light = _a[_i];
-                var generators = light.getShadowGenerators();
-                if (generators) {
-                    var iterator = generators.values();
-                    for (var key = iterator.next(); key.done !== true; key = iterator.next()) {
-                        var generator = key.value;
-                        var shadowMap = generator.getShadowMap();
-                        if (shadowMap) {
-                            shadowMap.refreshRate = refreshType;
-                        }
-                    }
-                }
-            }
-            this._processShadows = process;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "groundEnabled", {
-        get: function () {
-            return this._groundEnabled;
-        },
-        set: function (newValue) {
-            if (newValue === this._groundEnabled) {
-                return;
-            }
-            this._groundEnabled = newValue;
-            if (this.environmentHelper && this.environmentHelper.ground) {
-                this.environmentHelper.ground.setEnabled(this._groundEnabled);
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "groundMirrorEnabled", {
-        /**
-         * gets whether the reflection is disabled.
-         */
-        get: function () {
-            return this._groundMirrorEnabled;
-        },
-        /**
-         * sets whether the reflection is disabled.
-         */
-        set: function (value) {
-            if (this._groundMirrorEnabled === value) {
-                return;
-            }
-            this._groundMirrorEnabled = value;
-            if (this.environmentHelper && this.environmentHelper.groundMaterial && this.environmentHelper.groundMirror) {
-                if (!value) {
-                    this.environmentHelper.groundMaterial.reflectionTexture = null;
-                }
-                else {
-                    this.environmentHelper.groundMaterial.reflectionTexture = this.environmentHelper.groundMirror;
-                }
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "defaultRenderingPipelineEnabled", {
-        get: function () {
-            return this._defaultRenderingPipelineEnabled;
-        },
-        set: function (value) {
-            if (value === this._defaultRenderingPipelineEnabled) {
-                return;
-            }
-            this._defaultRenderingPipelineEnabled = value;
-            this._rebuildPostprocesses();
-            if (this._defaultRenderingPipeline) {
-                this._defaultRenderingPipelineShouldBuild = false;
-                this._defaultRenderingPipeline.prepare();
-                this.scene.imageProcessingConfiguration.applyByPostProcess = true;
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Sets the engine flags to unlock all babylon features.
-     * Can also be configured using the scene.flags configuration object
-     */
-    SceneManager.prototype.unlockBabylonFeatures = function () {
-        this.scene.shadowsEnabled = true;
-        this.scene.particlesEnabled = true;
-        this.scene.postProcessesEnabled = true;
-        this.scene.collisionsEnabled = true;
-        this.scene.lightsEnabled = true;
-        this.scene.texturesEnabled = true;
-        this.scene.lensFlaresEnabled = true;
-        this.scene.proceduralTexturesEnabled = true;
-        this.scene.renderTargetsEnabled = true;
-        this.scene.spritesEnabled = true;
-        this.scene.skeletonsEnabled = true;
-        this.scene.audioEnabled = true;
-    };
-    /**
-     * initialize the scene. Calling this function again will dispose the old scene, if exists.
-     * @param sceneConfiguration the configuration of the scene
-     * @returns a promise that resolves when the scene is ready
-     */
-    SceneManager.prototype.initScene = function (sceneConfiguration) {
-        if (sceneConfiguration === void 0) { sceneConfiguration = {}; }
-        // if the scene exists, dispose it.
-        if (this.scene) {
-            this.scene.dispose();
-        }
-        // create a new scene
-        this.scene = new Scene(this._engine);
-        this._configurationContainer.scene = this.scene;
-        // set a default PBR material
-        if (!sceneConfiguration.defaultMaterial) {
-            var defaultMaterial = new PBRMaterial("defaultMaterial", this.scene);
-            defaultMaterial.reflectivityColor = new Color3(0.1, 0.1, 0.1);
-            defaultMaterial.microSurface = 0.6;
-            if (this.scene.defaultMaterial) {
-                this.scene.defaultMaterial.dispose();
-            }
-            this.scene.defaultMaterial = defaultMaterial;
-        }
-        this.scene.animationPropertiesOverride = new AnimationPropertiesOverride();
-        Animation.AllowMatricesInterpolation = true;
-        /*if (sceneConfiguration.glow) {
-            let options: Partial<IGlowLayerOptions> = {
-                mainTextureFixedSize: 512
-            };
-            if (typeof sceneConfiguration.glow === 'object') {
-                options = sceneConfiguration.glow
-            }
-            var gl = new GlowLayer("glow", this.scene, options);
-        }*/
-        return this.onSceneInitObservable.notifyObserversWithPromise(this.scene);
-    };
-    SceneManager.prototype.clearScene = function (clearModels, clearLights) {
-        if (clearModels === void 0) { clearModels = true; }
-        if (clearLights === void 0) { clearLights = false; }
-        if (clearModels) {
-            this.models.forEach(function (m) { return m.dispose(); });
-            this.models.length = 0;
-        }
-        if (clearLights) {
-            this.scene.lights.forEach(function (l) { return l.dispose(); });
-        }
-    };
-    /**
-     * This will update the scene's configuration, including camera, lights, environment.
-     * @param newConfiguration the delta that should be configured. This includes only the changes
-     */
-    SceneManager.prototype.updateConfiguration = function (newConfiguration) {
-        var _this = this;
-        if (this._configurationContainer) {
-            this._globalConfiguration = this._configurationContainer.configuration;
-        }
-        else {
-            this._globalConfiguration = newConfiguration;
-        }
-        // update scene configuration
-        if (newConfiguration.scene) {
-            this._configureScene(newConfiguration.scene);
-        }
-        // optimizer
-        if (newConfiguration.optimizer !== undefined) {
-            this._configureOptimizer(newConfiguration.optimizer);
-        }
-        // configure model
-        /*if (newConfiguration.model && typeof newConfiguration.model === 'object') {
-            this._configureModel(newConfiguration.model);
-        }*/
-        // lights
-        this._configureLights(newConfiguration.lights);
-        // environment
-        if (newConfiguration.skybox !== undefined || newConfiguration.ground !== undefined) {
-            this._configureEnvironment(newConfiguration.skybox, newConfiguration.ground);
-        }
-        // camera
-        this._configureCamera(newConfiguration.camera);
-        if (newConfiguration.environmentMap !== undefined) {
-            this._configureEnvironmentMap(newConfiguration.environmentMap);
-        }
-        if (newConfiguration.vr !== undefined) {
-            this._configureVR(newConfiguration.vr);
-        }
-        if (newConfiguration.lab) {
-            // rendering pipelines
-            if (newConfiguration.lab.defaultRenderingPipelines) {
-                var pipelineConfig = newConfiguration.lab.defaultRenderingPipelines;
-                if (typeof pipelineConfig === "boolean") {
-                    this.defaultRenderingPipelineEnabled = pipelineConfig;
-                }
-                else {
-                    this.defaultRenderingPipelineEnabled = true;
-                }
-            }
-            if (this.environmentHelper && newConfiguration.lab.environmentMainColor) {
-                var mainColor = new Color3(newConfiguration.lab.environmentMainColor.r, newConfiguration.lab.environmentMainColor.g, newConfiguration.lab.environmentMainColor.b);
-                this.environmentHelper.setMainColor(mainColor);
-            }
-            if (newConfiguration.lab.globalLightRotation !== undefined) {
-                // rotate all lights that are shadow lights
-                this.scene.lights
-                    .filter(function (light) { return light instanceof ShadowLight; })
-                    .forEach(function (light) {
-                    // casting and '!' are safe, due to the constraints tested before
-                    _this.labs.rotateShadowLight(light, newConfiguration.lab.globalLightRotation);
-                });
-                this._forceShadowUpdate = true;
-            }
-        }
-        if (this._defaultRenderingPipeline && this._defaultRenderingPipeline.imageProcessing) {
-            this._defaultRenderingPipeline.imageProcessing.fromLinearSpace = true;
-        }
-        if (this._defaultRenderingPipelineShouldBuild && this._defaultRenderingPipeline) {
-            this._defaultRenderingPipelineShouldBuild = false;
-            this._defaultRenderingPipeline.prepare();
-        }
-    };
-    SceneManager.prototype._rebuildPostprocesses = function (configuration) {
-        if (!this._defaultRenderingPipelineEnabled || !getConfigurationKey("scene.imageProcessingConfiguration.isEnabled", this._globalConfiguration)) {
-            if (this._defaultRenderingPipeline) {
-                this._defaultRenderingPipeline.dispose();
-                this._defaultRenderingPipeline = null;
-                this.scene.autoClearDepthAndStencil = true;
-                this.scene.autoClear = true;
-                this.scene.imageProcessingConfiguration.applyByPostProcess = false;
-            }
-            return;
-        }
-        var pipelineConfig = configuration || (this._globalConfiguration.lab && this._globalConfiguration.lab.defaultRenderingPipelines);
-        if (pipelineConfig) {
-            if (!this._defaultRenderingPipeline) {
-                // Create pipeline in manual mode to avoid triggering multiple shader compilations
-                this._defaultRenderingPipeline = new DefaultRenderingPipeline("default rendering pipeline", this._hdrSupport, this.scene, [this.camera], false);
-            }
-            this.scene.autoClear = false;
-            this.scene.autoClearDepthAndStencil = false;
-            this._defaultRenderingPipelineShouldBuild = true;
-            var bloomEnabled = this._bloomEnabled;
-            if (typeof pipelineConfig !== "boolean") {
-                extendClassWithConfig(this._defaultRenderingPipeline, pipelineConfig);
-                this._bloomEnabled = !!pipelineConfig.bloomEnabled;
-                this._fxaaEnabled = !!pipelineConfig.fxaaEnabled;
-                bloomEnabled = this._bloomEnabled && pipelineConfig.bloomWeight !== undefined && pipelineConfig.bloomWeight > 0;
-                this._defaultRenderingPipeline.bloomWeight = (pipelineConfig.bloomWeight !== undefined && pipelineConfig.bloomWeight) || this._defaultRenderingPipeline.bloomWeight;
-            }
-            this._defaultRenderingPipeline.bloomEnabled = bloomEnabled;
-            this._defaultRenderingPipeline.fxaaEnabled = this.fxaaEnabled;
-        }
-    };
-    Object.defineProperty(SceneManager.prototype, "bloomEnabled", {
-        get: function () {
-            return this._bloomEnabled;
-        },
-        set: function (value) {
-            if (this._bloomEnabled === value) {
-                return;
-            }
-            this._bloomEnabled = value;
-            this._rebuildPostprocesses();
-            if (this._defaultRenderingPipeline) {
-                this._defaultRenderingPipelineShouldBuild = false;
-                this._defaultRenderingPipeline.prepare();
-                this.scene.imageProcessingConfiguration.applyByPostProcess = true;
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(SceneManager.prototype, "fxaaEnabled", {
-        get: function () {
-            return this._fxaaEnabled;
-        },
-        set: function (value) {
-            if (this._fxaaEnabled === value) {
-                return;
-            }
-            this._fxaaEnabled = value;
-            this._rebuildPostprocesses();
-            if (this._defaultRenderingPipeline) {
-                this._defaultRenderingPipelineShouldBuild = false;
-                this._defaultRenderingPipeline.prepare();
-                this.scene.imageProcessingConfiguration.applyByPostProcess = true;
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    SceneManager.prototype.setDefaultMaterial = function (sceneConfig) { };
-    /**
-     * internally configure the scene using the provided configuration.
-     * The scene will not be recreated, but just updated.
-     * @param sceneConfig the (new) scene configuration
-     */
-    SceneManager.prototype._configureScene = function (sceneConfig) {
-        // sanity check!
-        if (!this.scene) {
-            return;
-        }
-        var cc = sceneConfig.clearColor;
-        var oldcc = this.scene.clearColor;
-        if (cc) {
-            if (cc.r !== undefined) {
-                oldcc.r = cc.r;
-            }
-            if (cc.g !== undefined) {
-                oldcc.g = cc.g;
-            }
-            if (cc.b !== undefined) {
-                oldcc.b = cc.b;
-            }
-            if (cc.a !== undefined) {
-                oldcc.a = cc.a;
-            }
-        }
-        if (sceneConfig.assetsRootURL) {
-            this._assetsRootURL = sceneConfig.assetsRootURL;
-        }
-        // image processing configuration - optional.
-        if (sceneConfig.imageProcessingConfiguration) {
-            extendClassWithConfig(this.scene.imageProcessingConfiguration, sceneConfig.imageProcessingConfiguration);
-        }
-        //animation properties override
-        if (sceneConfig.animationPropertiesOverride) {
-            extendClassWithConfig(this.scene.animationPropertiesOverride, sceneConfig.animationPropertiesOverride);
-        }
-        if (sceneConfig.environmentTexture) {
-            if (!(this.scene.environmentTexture && this.scene.environmentTexture.url === sceneConfig.environmentTexture)) {
-                if (this.scene.environmentTexture && this.scene.environmentTexture.dispose) {
-                    this.scene.environmentTexture.dispose();
-                }
-                var environmentTexture = CubeTexture.CreateFromPrefilteredData(sceneConfig.environmentTexture, this.scene);
-                this.scene.environmentTexture = environmentTexture;
-            }
-        }
-        if (sceneConfig.debug === true) {
-            this.scene.debugLayer.show();
-        }
-        else if (sceneConfig.debug === false) {
-            if (this.scene.debugLayer.isVisible()) {
-                this.scene.debugLayer.hide();
-            }
-        }
-        if (sceneConfig.disableHdr) {
-            this._handleHardwareLimitations(false);
-        }
-        else {
-            this._handleHardwareLimitations(true);
-        }
-        if (sceneConfig.renderInBackground !== undefined) {
-            this._engine.renderEvenInBackground = !!sceneConfig.renderInBackground;
-        }
-        var canvas = this._engine.getInputElement();
-        if (canvas) {
-            if (this.camera && sceneConfig.disableCameraControl) {
-                this.camera.detachControl();
-            }
-            else if (this.camera && sceneConfig.disableCameraControl === false) {
-                this.camera.attachControl();
-            }
-        }
-        this.setDefaultMaterial(sceneConfig);
-        if (sceneConfig.flags) {
-            extendClassWithConfig(this.scene, sceneConfig.flags);
-        }
-        this.onSceneConfiguredObservable.notifyObservers({
-            sceneManager: this,
-            object: this.scene,
-            newConfiguration: sceneConfig,
-        });
-    };
-    /**
-     * Configure the scene optimizer.
-     * The existing scene optimizer will be disposed and a new one will be created.
-     * @param optimizerConfig the (new) optimizer configuration
-     */
-    SceneManager.prototype._configureOptimizer = function (optimizerConfig) {
-        var _this = this;
-        if (typeof optimizerConfig === "boolean") {
-            if (this.sceneOptimizer) {
-                this.sceneOptimizer.stop();
-                this.sceneOptimizer.dispose();
-                delete this.sceneOptimizer;
-            }
-            if (optimizerConfig) {
-                this.sceneOptimizer = new SceneOptimizer(this.scene);
-                this.sceneOptimizer.start();
-            }
-        }
-        else {
-            var optimizerOptions = new SceneOptimizerOptions(optimizerConfig.targetFrameRate, optimizerConfig.trackerDuration);
-            // check for degradation
-            if (optimizerConfig.degradation) {
-                switch (optimizerConfig.degradation) {
-                    case "low":
-                        optimizerOptions = SceneOptimizerOptions.LowDegradationAllowed(optimizerConfig.targetFrameRate);
-                        break;
-                    case "moderate":
-                        optimizerOptions = SceneOptimizerOptions.ModerateDegradationAllowed(optimizerConfig.targetFrameRate);
-                        break;
-                    case "hight":
-                        optimizerOptions = SceneOptimizerOptions.HighDegradationAllowed(optimizerConfig.targetFrameRate);
-                        break;
-                }
-            }
-            if (this.sceneOptimizer) {
-                this.sceneOptimizer.stop();
-                this.sceneOptimizer.dispose();
-            }
-            if (optimizerConfig.custom) {
-                var customOptimizer_1 = getCustomOptimizerByName(optimizerConfig.custom, optimizerConfig.improvementMode);
-                if (customOptimizer_1) {
-                    optimizerOptions.addCustomOptimization(function () {
-                        return customOptimizer_1(_this);
-                    }, function () {
-                        return "Babylon Viewer ".concat(optimizerConfig.custom, " custom optimization");
-                    });
-                }
-            }
-            this.sceneOptimizer = new SceneOptimizer(this.scene, optimizerOptions, optimizerConfig.autoGeneratePriorities, optimizerConfig.improvementMode);
-            this.sceneOptimizer.start();
-        }
-        this.onSceneOptimizerConfiguredObservable.notifyObservers({
-            sceneManager: this,
-            object: this.sceneOptimizer,
-            newConfiguration: optimizerConfig,
-        });
-    };
-    /**
-     * configure all models using the configuration.
-     * @param modelConfiguration the configuration to use to reconfigure the models
-     */
-    /*protected _configureModel(modelConfiguration: Partial<IModelConfiguration>) {
-        this.models.forEach(model => {
-            model.updateConfiguration(modelConfiguration);
-        });
-
-        this.onModelsConfiguredObservable.notifyObservers({
-            sceneManager: this,
-            object: this.models,
-            newConfiguration: modelConfiguration
-        });
-    }*/
-    SceneManager.prototype._configureVR = function (vrConfig) {
-        var _this = this;
-        if (vrConfig.disabled) {
-            if (this._vrHelper) {
-                if (this._vrHelper.isInVRMode) {
-                    this._vrHelper.exitVR();
-                }
-                this._vrHelper.dispose();
-                this._vrHelper = undefined;
-            }
-            return;
-        }
-        var vrOptions = deepmerge({
-            useCustomVRButton: true,
-            createDeviceOrientationCamera: false,
-            trackPosition: true,
-        }, vrConfig.vrOptions || {});
-        this._vrHelper = this.scene.createDefaultVRExperience(vrOptions);
-        if (!vrConfig.disableInteractions) {
-            this._vrHelper.enableInteractions();
-        }
-        if (!vrConfig.disableTeleportation) {
-            var floorMeshName = vrConfig.overrideFloorMeshName || "BackgroundPlane";
-            this._vrHelper.enableTeleportation({
-                floorMeshName: floorMeshName,
-            });
-        }
-        this._vrHelper.onEnteringVRObservable.add(function () {
-            if (_this._observablesManager) {
-                _this._observablesManager.onEnteringVRObservable.notifyObservers(_this);
-            }
-        });
-        this._vrHelper.onExitingVRObservable.add(function () {
-            if (_this._observablesManager) {
-                _this._observablesManager.onExitingVRObservable.notifyObservers(_this);
-            }
-        });
-        this.onVRConfiguredObservable.notifyObservers({
-            sceneManager: this,
-            object: this._vrHelper,
-            newConfiguration: vrConfig,
-        });
-    };
-    SceneManager.prototype._configureEnvironmentMap = function (environmentMapConfiguration) {
-        if (environmentMapConfiguration.texture) {
-            this.scene.environmentTexture = new CubeTexture(this._getAssetUrl(environmentMapConfiguration.texture), this.scene);
-        }
-        //sanity check
-        if (this.scene.environmentTexture) {
-            var rotatquatRotationionY = Quaternion.RotationAxis(Axis.Y, environmentMapConfiguration.rotationY || 0);
-            Matrix.FromQuaternionToRef(rotatquatRotationionY, this.scene.environmentTexture.getReflectionTextureMatrix());
-        }
-        // process mainColor changes:
-        if (environmentMapConfiguration.mainColor) {
-            this._configurationContainer.mainColor = this.mainColor || Color3.White();
-            var mc = environmentMapConfiguration.mainColor;
-            if (mc.r !== undefined) {
-                this.mainColor.r = mc.r;
-            }
-            if (mc.g !== undefined) {
-                this.mainColor.g = mc.g;
-            }
-            if (mc.b !== undefined) {
-                this.mainColor.b = mc.b;
-            }
-            this.reflectionColor.copyFrom(this.mainColor);
-            var environmentTint = getConfigurationKey("environmentMap.tintLevel", this._globalConfiguration) || 0;
-            // reflection color
-            this.reflectionColor.toLinearSpaceToRef(this.reflectionColor);
-            this.reflectionColor.scaleToRef(1 / this.scene.imageProcessingConfiguration.exposure, this.reflectionColor);
-            var tmpColor3 = Color3.Lerp(this._white, this.reflectionColor, environmentTint);
-            this.reflectionColor.copyFrom(tmpColor3);
-            //update the environment, if exists
-            if (this.environmentHelper) {
-                if (this.environmentHelper.groundMaterial) {
-                    this.environmentHelper.groundMaterial._perceptualColor = this.mainColor;
-                }
-                if (this.environmentHelper.skyboxMaterial) {
-                    this.environmentHelper.skyboxMaterial._perceptualColor = this.mainColor;
-                }
-            }
-        }
-    };
-    /**
-     * (Re) configure the camera. The camera will only be created once and from this point will only be reconfigured.
-     * @param cameraConfig the new camera configuration
-     */
-    SceneManager.prototype._configureCamera = function (cameraConfig) {
-        var _this = this;
-        if (cameraConfig === void 0) { cameraConfig = {}; }
-        if (!this.scene.activeCamera) {
-            // Inline scene.createDefaultCamera to reduce file size
-            // Dispose existing camera in replace mode.
-            if (this.scene.activeCamera) {
-                this.scene.activeCamera.dispose();
-                this.scene.activeCamera = null;
-            }
-            // Camera
-            if (!this.scene.activeCamera) {
-                var worldExtends = this.scene.getWorldExtends();
-                var worldSize = worldExtends.max.subtract(worldExtends.min);
-                var worldCenter = worldExtends.min.add(worldSize.scale(0.5));
-                var radius = worldSize.length() * 1.5;
-                // empty scene scenario!
-                if (!isFinite(radius)) {
-                    radius = 1;
-                    worldCenter.copyFromFloats(0, 0, 0);
-                }
-                var arcRotateCamera = new ArcRotateCamera("default camera", -(Math.PI / 2), Math.PI / 2, radius, worldCenter, this.scene);
-                arcRotateCamera.lowerRadiusLimit = radius * 0.01;
-                arcRotateCamera.wheelPrecision = 100 / radius;
-                var camera = arcRotateCamera;
-                camera.minZ = radius * 0.01;
-                camera.maxZ = radius * 1000;
-                camera.speed = radius * 0.2;
-                this.scene.activeCamera = camera;
-            }
-            var canvas = this.scene.getEngine().getInputElement();
-            if (canvas) {
-                this.scene.activeCamera.attachControl();
-            }
-            this.camera = this.scene.activeCamera;
-            this.camera.setTarget(Vector3.Zero());
-        }
-        if (!this.camera) {
-            this.camera = this.scene.activeCamera;
-        }
-        if (cameraConfig.position) {
-            var newPosition = this.camera.position.clone();
-            extendClassWithConfig(newPosition, cameraConfig.position);
-            this.camera.setPosition(newPosition);
-        }
-        if (cameraConfig.target) {
-            var newTarget = this.camera.target.clone();
-            extendClassWithConfig(newTarget, cameraConfig.target);
-            this.camera.setTarget(newTarget);
-        } /*else if (this.models.length && !cameraConfig.disableAutoFocus) {
-            this._focusOnModel(this.models[0]);
-        }*/
-        if (cameraConfig.rotation) {
-            this.camera.rotationQuaternion = new Quaternion(cameraConfig.rotation.x || 0, cameraConfig.rotation.y || 0, cameraConfig.rotation.z || 0, cameraConfig.rotation.w || 0);
-        }
-        if (cameraConfig.behaviors) {
-            for (var name_1 in cameraConfig.behaviors) {
-                if (cameraConfig.behaviors[name_1] !== undefined) {
-                    this._setCameraBehavior(name_1, cameraConfig.behaviors[name_1]);
-                }
-            }
-        }
-        var sceneExtends = this.scene.getWorldExtends(function (mesh) {
-            return !_this.environmentHelper || (mesh !== _this.environmentHelper.ground && mesh !== _this.environmentHelper.rootMesh && mesh !== _this.environmentHelper.skybox);
-        });
-        var sceneDiagonal = sceneExtends.max.subtract(sceneExtends.min);
-        var sceneDiagonalLength = sceneDiagonal.length();
-        if (isFinite(sceneDiagonalLength)) {
-            this.camera.upperRadiusLimit = sceneDiagonalLength * 4;
-        }
-        // sanity check!
-        if (this.scene.imageProcessingConfiguration) {
-            this.scene.imageProcessingConfiguration.colorCurvesEnabled = true;
-            this.scene.imageProcessingConfiguration.vignetteEnabled = true;
-            this.scene.imageProcessingConfiguration.toneMappingEnabled = !!getConfigurationKey("camera.toneMappingEnabled", this._globalConfiguration);
-        }
-        extendClassWithConfig(this.camera, cameraConfig);
-        this.onCameraConfiguredObservable.notifyObservers({
-            sceneManager: this,
-            object: this.camera,
-            newConfiguration: cameraConfig,
-        });
-    };
-    SceneManager.prototype._configureEnvironment = function (skyboxConifguration, groundConfiguration) {
-        var _this = this;
-        if (!skyboxConifguration && !groundConfiguration) {
-            if (this.environmentHelper) {
-                this.environmentHelper.dispose();
-                this.environmentHelper = undefined;
-            }
-        }
-        else {
-            var options = {
-                createGround: !!groundConfiguration && this._groundEnabled,
-                createSkybox: !!skyboxConifguration,
-                setupImageProcessing: false, // will be done at the scene level!,
-            };
-            // will that cause problems with model ground configuration?
-            /*if (model) {
-                const boundingInfo = model.rootMesh.getHierarchyBoundingVectors(true);
-                const sizeVec = boundingInfo.max.subtract(boundingInfo.min);
-                const halfSizeVec = sizeVec.scale(0.5);
-                const center = boundingInfo.min.add(halfSizeVec);
-                options.groundYBias = -center.y;
-            }*/
-            if (groundConfiguration) {
-                var groundConfig_1 = typeof groundConfiguration === "boolean" ? {} : groundConfiguration;
-                var groundSize = groundConfig_1.size || (typeof skyboxConifguration === "object" && skyboxConifguration.scale);
-                if (groundSize) {
-                    options.groundSize = groundSize;
-                }
-                options.enableGroundShadow = groundConfiguration === true || groundConfig_1.receiveShadows;
-                if (groundConfig_1.shadowLevel !== undefined) {
-                    options.groundShadowLevel = groundConfig_1.shadowLevel;
-                }
-                options.enableGroundMirror = !!groundConfig_1.mirror && this.groundMirrorEnabled;
-                if (groundConfig_1.texture) {
-                    options.groundTexture = this._getAssetUrl(groundConfig_1.texture);
-                }
-                if (groundConfig_1.color) {
-                    options.groundColor = new Color3(groundConfig_1.color.r, groundConfig_1.color.g, groundConfig_1.color.b);
-                }
-                if (groundConfig_1.opacity !== undefined) {
-                    options.groundOpacity = groundConfig_1.opacity;
-                }
-                if (groundConfig_1.mirror) {
-                    options.enableGroundMirror = true;
-                    // to prevent undefines
-                    if (typeof groundConfig_1.mirror === "object") {
-                        if (groundConfig_1.mirror.amount !== undefined) {
-                            options.groundMirrorAmount = groundConfig_1.mirror.amount;
-                        }
-                        if (groundConfig_1.mirror.sizeRatio !== undefined) {
-                            options.groundMirrorSizeRatio = groundConfig_1.mirror.sizeRatio;
-                        }
-                        if (groundConfig_1.mirror.blurKernel !== undefined) {
-                            options.groundMirrorBlurKernel = groundConfig_1.mirror.blurKernel;
-                        }
-                        if (groundConfig_1.mirror.fresnelWeight !== undefined) {
-                            options.groundMirrorFresnelWeight = groundConfig_1.mirror.fresnelWeight;
-                        }
-                        if (groundConfig_1.mirror.fallOffDistance !== undefined) {
-                            options.groundMirrorFallOffDistance = groundConfig_1.mirror.fallOffDistance;
-                        }
-                        if (this._defaultPipelineTextureType !== undefined) {
-                            options.groundMirrorTextureType = this._defaultPipelineTextureType;
-                        }
-                    }
-                }
-            }
-            var postInitSkyboxMaterial = false;
-            if (skyboxConifguration) {
-                var conf = skyboxConifguration === true ? {} : skyboxConifguration;
-                if (conf.material && conf.material.imageProcessingConfiguration) {
-                    options.setupImageProcessing = false; // will be configured later manually.
-                }
-                var skyboxSize = conf.scale;
-                if (skyboxSize) {
-                    options.skyboxSize = skyboxSize;
-                }
-                options.sizeAuto = !options.skyboxSize;
-                if (conf.color) {
-                    options.skyboxColor = new Color3(conf.color.r, conf.color.g, conf.color.b);
-                }
-                if (conf.cubeTexture && conf.cubeTexture.url) {
-                    if (typeof conf.cubeTexture.url === "string") {
-                        options.skyboxTexture = this._getAssetUrl(conf.cubeTexture.url);
-                    }
-                    else {
-                        // init later!
-                        postInitSkyboxMaterial = true;
-                    }
-                }
-                if (conf.material) {
-                    postInitSkyboxMaterial = true;
-                }
-            }
-            options.setupImageProcessing = false; // TMP
-            if (!this.environmentHelper) {
-                this.environmentHelper = new EnvironmentHelper(options, this.scene);
-            }
-            else {
-                // unlikely, but there might be a new scene! we need to dispose.
-                // get the scene used by the envHelper
-                var scene = this.environmentHelper.rootMesh.getScene();
-                // is it a different scene? Oh no!
-                if (scene !== this.scene) {
-                    this.environmentHelper.dispose();
-                    this.environmentHelper = new EnvironmentHelper(options, this.scene);
-                }
-                else {
-                    // recreate the ground
-                    if (this.environmentHelper.ground) {
-                        this.environmentHelper.ground.dispose();
-                    }
-                    // recreate the skybox
-                    if (this.environmentHelper.skybox) {
-                        this.environmentHelper.skybox.dispose();
-                    }
-                    this.environmentHelper.updateOptions(options);
-                    // update doesn't change the size of the skybox and ground, so we have to recreate!
-                    //this.environmentHelper.dispose();
-                    //this.environmentHelper = new EnvironmentHelper(options, this.scene);
-                }
-            }
-            if (this.environmentHelper.rootMesh && this._globalConfiguration.scene && this._globalConfiguration.scene.environmentRotationY !== undefined) {
-                this.environmentHelper.rootMesh.rotation.y = this._globalConfiguration.scene.environmentRotationY;
-            }
-            var groundConfig = typeof groundConfiguration === "boolean" ? {} : groundConfiguration;
-            if (this.environmentHelper.groundMaterial && groundConfig) {
-                this.environmentHelper.groundMaterial._perceptualColor = this.mainColor;
-                if (groundConfig.material) {
-                    extendClassWithConfig(this.environmentHelper.groundMaterial, groundConfig.material);
-                }
-                if (this.environmentHelper.groundMirror) {
-                    var mirrorClearColor = this.environmentHelper.groundMaterial._perceptualColor.toLinearSpace();
-                    // TODO user camera exposure value to set the mirror clear color
-                    var exposure = Math.pow(2.0, -this.scene.imageProcessingConfiguration.exposure) * Math.PI;
-                    mirrorClearColor.scaleToRef(1 / exposure, mirrorClearColor);
-                    this.environmentHelper.groundMirror.clearColor.r = Scalar.Clamp(mirrorClearColor.r);
-                    this.environmentHelper.groundMirror.clearColor.g = Scalar.Clamp(mirrorClearColor.g);
-                    this.environmentHelper.groundMirror.clearColor.b = Scalar.Clamp(mirrorClearColor.b);
-                    this.environmentHelper.groundMirror.clearColor.a = 1;
-                    if (!this.groundMirrorEnabled) {
-                        this.environmentHelper.groundMaterial.reflectionTexture = null;
-                    }
-                }
-            }
-            var skyboxMaterial = this.environmentHelper.skyboxMaterial;
-            if (skyboxMaterial) {
-                skyboxMaterial._perceptualColor = this.mainColor;
-                if (postInitSkyboxMaterial) {
-                    if (typeof skyboxConifguration === "object" && skyboxConifguration.material) {
-                        extendClassWithConfig(skyboxMaterial, skyboxConifguration.material);
-                    }
-                }
-            }
-        }
-        this._observablesManager &&
-            this._observablesManager.onModelLoadedObservable.add(function (model) {
-                _this._updateGroundMirrorRenderList(model);
-            });
-        this.onEnvironmentConfiguredObservable.notifyObservers({
-            sceneManager: this,
-            object: this.environmentHelper,
-            newConfiguration: {
-                skybox: skyboxConifguration,
-                ground: groundConfiguration,
-            },
-        });
-    };
-    /**
-     * configure the lights.
-     * @param lightsConfiguration the (new) light(s) configuration
-     */
-    SceneManager.prototype._configureLights = function (lightsConfiguration) {
-        var _this = this;
-        if (lightsConfiguration === void 0) { lightsConfiguration = {}; }
-        // sanity check!
-        var lightKeys = Object.keys(lightsConfiguration).filter(function (name) { return name !== "globalRotation"; });
-        if (!lightKeys.length) {
-            if (!this.scene.lights.length) {
-                new HemisphericLight("default light", Vector3.Up(), this.scene);
-            }
-        }
-        else {
-            var lightsAvailable_1 = this.scene.lights.map(function (light) { return light.name; });
-            // compare to the global (!) configuration object and dispose unneeded:
-            var lightsToConfigure_1 = Object.keys(this._globalConfiguration.lights || []);
-            if (Object.keys(lightsToConfigure_1).length !== lightsAvailable_1.length) {
-                lightsAvailable_1.forEach(function (lName) {
-                    if (lightsToConfigure_1.indexOf(lName) === -1) {
-                        _this.scene.getLightByName(lName).dispose();
-                    }
-                });
-            }
-            lightKeys.forEach(function (name) {
-                var lightConfig = { type: 0 };
-                if (typeof lightsConfiguration[name] === "object") {
-                    lightConfig = lightsConfiguration[name];
-                }
-                if (typeof lightsConfiguration[name] === "number") {
-                    lightConfig.type = lightsConfiguration[name];
-                }
-                lightConfig.name = name;
-                var light;
-                // light is not already available
-                if (lightsAvailable_1.indexOf(name) === -1) {
-                    var constructor = Light.GetConstructorFromName(lightConfig.type, lightConfig.name, _this.scene);
-                    if (!constructor) {
-                        return;
-                    }
-                    light = constructor();
-                }
-                else {
-                    // available? get it from the scene
-                    light = _this.scene.getLightByName(name);
-                    if (typeof lightsConfiguration[name] === "boolean") {
-                        lightConfig.type = light.getTypeID();
-                    }
-                    lightsAvailable_1 = lightsAvailable_1.filter(function (ln) { return ln !== name; });
-                    if (lightConfig.type !== undefined && light.getTypeID() !== lightConfig.type) {
-                        light.dispose();
-                        var constructor = Light.GetConstructorFromName(lightConfig.type, lightConfig.name, _this.scene);
-                        if (!constructor) {
-                            return;
-                        }
-                        light = constructor();
-                    }
-                }
-                // if config set the light to false, dispose it.
-                if (lightsConfiguration[name] === false) {
-                    light.dispose();
-                    return;
-                }
-                //enabled
-                var enabled = lightConfig.enabled !== undefined ? lightConfig.enabled : !lightConfig.disabled;
-                light.setEnabled(enabled);
-                extendClassWithConfig(light, lightConfig);
-                //position. Some lights don't support shadows
-                if (light instanceof ShadowLight) {
-                    // set default values
-                    light.shadowMinZ = light.shadowMinZ || 0.2;
-                    light.shadowMaxZ = Math.min(10, light.shadowMaxZ || 10); //large far clips reduce shadow depth precision
-                    if (lightConfig.target) {
-                        if (light.setDirectionToTarget) {
-                            var target = Vector3.Zero().copyFromFloats(lightConfig.target.x, lightConfig.target.y, lightConfig.target.z);
-                            light.setDirectionToTarget(target);
-                        }
-                    }
-                    else if (lightConfig.direction) {
-                        var direction = Vector3.Zero().copyFromFloats(lightConfig.direction.x, lightConfig.direction.y, lightConfig.direction.z);
-                        light.direction = direction;
-                    }
-                    var isShadowEnabled = false;
-                    if (light.getTypeID() === Light.LIGHTTYPEID_DIRECTIONALLIGHT) {
-                        light.shadowFrustumSize = lightConfig.shadowFrustumSize || 2;
-                        isShadowEnabled = true;
-                    }
-                    else if (light.getTypeID() === Light.LIGHTTYPEID_SPOTLIGHT) {
-                        var spotLight = light;
-                        if (lightConfig.spotAngle !== undefined) {
-                            spotLight.angle = (lightConfig.spotAngle * Math.PI) / 180;
-                        }
-                        if (spotLight.angle && lightConfig.shadowFieldOfView) {
-                            spotLight.shadowAngleScale = lightConfig.shadowFieldOfView / spotLight.angle;
-                        }
-                        isShadowEnabled = true;
-                    }
-                    else if (light.getTypeID() === Light.LIGHTTYPEID_POINTLIGHT) {
-                        if (lightConfig.shadowFieldOfView) {
-                            light.shadowAngle = (lightConfig.shadowFieldOfView * Math.PI) / 180;
-                        }
-                        isShadowEnabled = true;
-                    }
-                    var shadowGenerator_1 = light.getShadowGenerator();
-                    if (isShadowEnabled && lightConfig.shadowEnabled && _this._maxShadows) {
-                        var bufferSize = lightConfig.shadowBufferSize || 256;
-                        if (!shadowGenerator_1) {
-                            shadowGenerator_1 = new ShadowGenerator(bufferSize, light);
-                        }
-                        var blurKernel = _this.getBlurKernel(light, bufferSize);
-                        shadowGenerator_1.bias = _this._shadowGeneratorBias;
-                        shadowGenerator_1.blurKernel = blurKernel;
-                        //override defaults
-                        extendClassWithConfig(shadowGenerator_1, lightConfig.shadowConfig || {});
-                        // add the focus meshes to the shadow list
-                        _this._observablesManager &&
-                            _this._observablesManager.onModelLoadedObservable.add(function (model) {
-                                _this._updateShadowRenderList(shadowGenerator_1, model);
-                            });
-                        //if (model) {
-                        _this._updateShadowRenderList(shadowGenerator_1);
-                        //}
-                    }
-                    else if (shadowGenerator_1) {
-                        shadowGenerator_1.dispose();
-                    }
-                }
-            });
-            // render priority
-            var globalLightsConfiguration = this._globalConfiguration.lights || {};
-            Object.keys(globalLightsConfiguration)
-                .sort()
-                .forEach(function (name, idx) {
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                // const configuration = globalLightsConfiguration[name];
-                var light = _this.scene.getLightByName(name);
-                // sanity check
-                if (!light) {
-                    return;
-                }
-                light.renderPriority = -idx;
-            });
-        }
-        this.onLightsConfiguredObservable.notifyObservers({
-            sceneManager: this,
-            object: this.scene.lights,
-            newConfiguration: lightsConfiguration,
-        });
-    };
-    SceneManager.prototype._updateShadowRenderList = function (shadowGenerator, model, resetList) {
-        var focusMeshes = model ? model.meshes : this.scene.meshes;
-        // add the focus meshes to the shadow list
-        var shadownMap = shadowGenerator.getShadowMap();
-        if (!shadownMap) {
-            return;
-        }
-        if (resetList && shadownMap.renderList) {
-            shadownMap.renderList.length = 0;
-        }
-        else {
-            shadownMap.renderList = shadownMap.renderList || [];
-        }
-        for (var index = 0; index < focusMeshes.length; index++) {
-            var mesh = focusMeshes[index];
-            if (Tags.MatchesQuery(mesh, "castShadow") && shadownMap.renderList.indexOf(mesh) === -1) {
-                shadownMap.renderList.push(mesh);
-            }
-        }
-        if (!this._shadowGroundPlane) {
-            if (shadowGenerator.useBlurCloseExponentialShadowMap) {
-                var shadowGroundPlane = CreatePlane("shadowGroundPlane", { size: 100 }, this.scene);
-                shadowGroundPlane.useVertexColors = false;
-                //material isn't ever used in rendering, just used to set back face culling
-                shadowGroundPlane.material = new PBRMaterial("shadowGroundPlaneMaterial", this.scene);
-                shadowGroundPlane.material.backFaceCulling = false;
-                shadowGroundPlane.rotation.x = Math.PI * 0.5;
-                shadowGroundPlane.freezeWorldMatrix();
-                this._shadowGroundPlane = shadowGroundPlane;
-                this.scene.removeMesh(shadowGroundPlane);
-            }
-        }
-        else {
-            if (!shadowGenerator.useBlurCloseExponentialShadowMap) {
-                this._shadowGroundPlane.dispose();
-                this._shadowGroundPlane = null;
-            }
-        }
-        if (this._shadowGroundPlane && shadownMap.renderList.indexOf(this._shadowGroundPlane) === -1) {
-            shadownMap.renderList.push(this._shadowGroundPlane);
-        }
-    };
-    SceneManager.prototype._updateGroundMirrorRenderList = function (model, resetList) {
-        if (this.environmentHelper && this.environmentHelper.groundMirror && this.environmentHelper.groundMirror.renderList) {
-            var focusMeshes = model ? model.meshes : this.scene.meshes;
-            var renderList = this.environmentHelper.groundMirror.renderList;
-            if (resetList) {
-                renderList.length = 0;
-            }
-            for (var index = 0; index < focusMeshes.length; index++) {
-                var mesh = focusMeshes[index];
-                if (renderList.indexOf(mesh) === -1) {
-                    renderList.push(mesh);
-                }
-            }
-        }
-    };
-    /**
-     * Gets the shadow map blur kernel according to the light configuration.
-     * @param light The light used to generate the shadows
-     * @param bufferSize The size of the shadow map
-     * @returns the kernel blur size
-     */
-    SceneManager.prototype.getBlurKernel = function (light, bufferSize) {
-        var normalizedBlurKernel = 0.05; // TODO Should come from the config.
-        if (light.getTypeID() === Light.LIGHTTYPEID_DIRECTIONALLIGHT) {
-            normalizedBlurKernel = normalizedBlurKernel / light.shadowFrustumSize;
-        }
-        else if (light.getTypeID() === Light.LIGHTTYPEID_POINTLIGHT) {
-            normalizedBlurKernel = normalizedBlurKernel / light.shadowAngle;
-        }
-        else if (light.getTypeID() === Light.LIGHTTYPEID_SPOTLIGHT) {
-            normalizedBlurKernel = normalizedBlurKernel / (light.angle * light.shadowAngleScale);
-        }
-        var minimumBlurKernel = 5 / (bufferSize / 256); //magic number that aims to keep away sawtooth shadows
-        var blurKernel = Math.max(bufferSize * normalizedBlurKernel, minimumBlurKernel);
-        return blurKernel;
-    };
-    /**
-     * Alters render settings to reduce features based on hardware feature limitations
-     * @param enableHDR Allows the viewer to run in HDR mode.
-     */
-    SceneManager.prototype._handleHardwareLimitations = function (enableHDR) {
-        if (enableHDR === void 0) { enableHDR = true; }
-        //flip rendering settings switches based on hardware support
-        var maxVaryingRows = this._engine.getCaps().maxVaryingVectors;
-        var maxFragmentSamplers = this._engine.getCaps().maxTexturesImageUnits;
-        //shadows are disabled if there's not enough varyings for a single shadow
-        if (maxVaryingRows < 8 || maxFragmentSamplers < 8) {
-            this._maxShadows = 0;
-        }
-        else {
-            this._maxShadows = 3;
-        }
-        //can we render to any >= 16-bit targets (required for HDR)
-        var caps = this._engine.getCaps();
-        var linearHalfFloatTargets = caps.textureHalfFloatRender && caps.textureHalfFloatLinearFiltering;
-        var linearFloatTargets = caps.textureFloatRender && caps.textureFloatLinearFiltering;
-        this._hdrSupport = enableHDR && !!(linearFloatTargets || linearHalfFloatTargets);
-        if (linearHalfFloatTargets) {
-            this._defaultHighpTextureType = Constants.TEXTURETYPE_HALF_FLOAT;
-            this._shadowGeneratorBias = 0.002;
-        }
-        else if (linearFloatTargets) {
-            this._defaultHighpTextureType = Constants.TEXTURETYPE_FLOAT;
-            this._shadowGeneratorBias = 0.001;
-        }
-        else {
-            this._defaultHighpTextureType = Constants.TEXTURETYPE_UNSIGNED_BYTE;
-            this._shadowGeneratorBias = 0.001;
-        }
-        this._defaultPipelineTextureType = this._hdrSupport ? this._defaultHighpTextureType : Constants.TEXTURETYPE_UNSIGNED_BYTE;
-    };
-    /**
-     * Dispose the entire viewer including the scene and the engine
-     */
-    SceneManager.prototype.dispose = function () {
-        // this.onCameraConfiguredObservable.clear();
-        this.onEnvironmentConfiguredObservable.clear();
-        this.onLightsConfiguredObservable.clear();
-        this.onModelsConfiguredObservable.clear();
-        this.onSceneConfiguredObservable.clear();
-        this.onSceneInitObservable.clear();
-        this.onSceneOptimizerConfiguredObservable.clear();
-        this.onVRConfiguredObservable.clear();
-        if (this.sceneOptimizer) {
-            this.sceneOptimizer.stop();
-            this.sceneOptimizer.dispose();
-        }
-        if (this.environmentHelper) {
-            this.environmentHelper.dispose();
-        }
-        this.models.forEach(function (model) {
-            model.dispose();
-        });
-        if (this._defaultRenderingPipeline) {
-            this._defaultRenderingPipeline.dispose();
-        }
-        this.models.length = 0;
-        if (this.scene) {
-            this.scene.dispose();
-        }
-    };
-    /**
-     * Get an environment asset url by using the configuration if the path is not absolute.
-     * @param url Asset url
-     * @returns The Asset url using the `environmentAssetsRootURL` if the url is not an absolute path.
-     */
-    SceneManager.prototype._getAssetUrl = function (url) {
-        var returnUrl = url;
-        if (url && url.toLowerCase().indexOf("//") === -1) {
-            if (!this._assetsRootURL) {
-                // Tools.Warn("Please, specify the root url of your assets before loading the configuration (labs.environmentAssetsRootURL) or disable the background through the viewer options.");
-                return url;
-            }
-            returnUrl = this._assetsRootURL + returnUrl;
-        }
-        return returnUrl;
-    };
-    SceneManager.prototype._setCameraBehavior = function (name, behaviorConfig) {
-        var behavior;
-        var type;
-        if (typeof behaviorConfig === "object") {
-            type = behaviorConfig.type;
-        }
-        else if (typeof behaviorConfig === "number") {
-            type = behaviorConfig;
-        }
-        else {
-            type = this._cameraBehaviorMapping[name];
-        }
-        if (type === undefined) {
-            return;
-        }
-        var config = typeof behaviorConfig === "object" ? behaviorConfig : {};
-        var enabled = true;
-        if (typeof behaviorConfig === "boolean") {
-            enabled = behaviorConfig;
-        }
-        // constructing behavior
-        switch (type) {
-            case 0 /* CameraBehavior.AUTOROTATION */:
-                this.camera.useAutoRotationBehavior = enabled;
-                behavior = this.camera.autoRotationBehavior;
-                break;
-            case 1 /* CameraBehavior.BOUNCING */:
-                this.camera.useBouncingBehavior = enabled;
-                behavior = this.camera.bouncingBehavior;
-                break;
-            case 2 /* CameraBehavior.FRAMING */:
-                this.camera.useFramingBehavior = enabled;
-                behavior = this.camera.framingBehavior;
-                break;
-            default:
-                behavior = null;
-                break;
-        }
-        if (behavior) {
-            this._cameraBehaviorMapping[name] = type;
-            if (typeof behaviorConfig === "object") {
-                extendClassWithConfig(behavior, behaviorConfig);
-            }
-        }
-        // post attach configuration. Some functionalities require the attached camera.
-        switch (type) {
-            case 0 /* CameraBehavior.AUTOROTATION */:
-                break;
-            case 1 /* CameraBehavior.BOUNCING */:
-                break;
-            case 2 /* CameraBehavior.FRAMING */:
-                this._observablesManager &&
-                    this._observablesManager.onModelLoadedObservable.add(function (model) {
-                        if (config.zoomOnBoundingInfo) {
-                            behavior.zoomOnMeshHierarchy(model.rootMesh);
-                        }
-                    });
-                break;
-        }
-    };
-    return SceneManager;
-}());
-export { SceneManager };
-//# sourceMappingURL=sceneManager.js.map