sceneoptimizer custom types

Viewer/src/configuration/configuration.ts

@@ -358,6 +358,7 @@ export interface ISceneOptimizerConfiguration {
         renderTarget?: ISceneOptimizerParameters;
         mergeMeshes?: ISceneOptimizerParameters;
     }
+    custom?: string;
 }
 
 export interface IObserversConfiguration {

Viewer/src/optimizer/custom/extended.ts

@@ -0,0 +1,94 @@
+import { AbstractViewer } from '../../viewer/viewer';
+import { Scalar, DefaultRenderingPipeline } from 'babylonjs';
+
+export function extendedUpgrade(viewer: AbstractViewer): boolean {
+    let pipelineConifg = <DefaultRenderingPipeline>viewer.sceneManager.getActiveRenderingPiplineByName("default");
+    // if (!this.Scene.BackgroundHelper) {
+    // 	this.Scene.EngineScene.autoClear = false;
+    // this.Scene.BackgroundHelper = true;
+    // Would require a dedicated clear color;
+    // return false;
+    // }
+    if (viewer.engine.getHardwareScalingLevel() > 1) {
+        let scaling = Scalar.Clamp(viewer.engine.getHardwareScalingLevel() - 0.25, 0, 1);
+        viewer.engine.setHardwareScalingLevel(scaling);
+        return false;
+    }
+    if (!viewer.sceneManager.scene.postProcessesEnabled) {
+        viewer.sceneManager.scene.postProcessesEnabled = true;
+        return false;
+    }
+    if (!viewer.sceneManager.groundEnabled) {
+        viewer.sceneManager.groundEnabled = true;
+        return false;
+    }
+    if (pipelineConifg && !pipelineConifg.fxaaEnabled) {
+        pipelineConifg.fxaaEnabled = true
+        return false;
+    }
+    var hardwareScalingLevel = Math.max(1 / 2, 1 / (window.devicePixelRatio || 2));
+    if (viewer.engine.getHardwareScalingLevel() > hardwareScalingLevel) {
+        let scaling = Scalar.Clamp(viewer.engine.getHardwareScalingLevel() - 0.25, 0, hardwareScalingLevel);
+        viewer.engine.setHardwareScalingLevel(scaling);
+        return false;
+    }
+    if (!viewer.sceneManager.processShadows) {
+        viewer.sceneManager.processShadows = true;
+        return false;
+    }
+    if (pipelineConifg && !pipelineConifg.bloomEnabled) {
+        pipelineConifg.bloomEnabled = true
+        return false;
+    }
+    if (!viewer.sceneManager.groundMirrorEnabled) {
+        viewer.sceneManager.groundMirrorEnabled = true;
+        return false;
+    }
+    return true;
+}
+
+export function extendedDegrade(viewer: AbstractViewer): boolean {
+    let pipelineConifg = <DefaultRenderingPipeline>viewer.sceneManager.getActiveRenderingPiplineByName("default");
+
+    if (viewer.sceneManager.groundMirrorEnabled) {
+        viewer.sceneManager.groundMirrorEnabled = false;
+        return false;
+    }
+    if (pipelineConifg && pipelineConifg.bloomEnabled) {
+        pipelineConifg.bloomEnabled = false;
+        return false;
+    }
+    if (viewer.sceneManager.processShadows) {
+        viewer.sceneManager.processShadows = false;
+        return false;
+    }
+    if (viewer.engine.getHardwareScalingLevel() < 1) {
+        let scaling = Scalar.Clamp(viewer.engine.getHardwareScalingLevel() + 0.25, 0, 1);
+        viewer.engine.setHardwareScalingLevel(scaling);
+        return false;
+    }
+    if (pipelineConifg && pipelineConifg.fxaaEnabled) {
+        pipelineConifg.fxaaEnabled = false;
+        return false;
+    }
+    if (viewer.sceneManager.groundEnabled) {
+        viewer.sceneManager.groundEnabled = false;
+        return false;
+    }
+    if (viewer.sceneManager.scene.postProcessesEnabled) {
+        viewer.sceneManager.scene.postProcessesEnabled = false;
+        return false;
+    }
+    if (viewer.engine.getHardwareScalingLevel() < 1.25) {
+        let scaling = Scalar.Clamp(viewer.engine.getHardwareScalingLevel() + 0.25, 0, 1.25);
+        viewer.engine.setHardwareScalingLevel(scaling);
+        return false;
+    }
+    // if (this.Scene.BackgroundHelper) {
+    // 	this.Scene.EngineScene.autoClear = true;
+    // this.Scene.BackgroundHelper = false;
+    // Would require a dedicated clear color;
+    // return false;
+    // }
+    return true;
+}

Viewer/src/optimizer/custom/index.ts

@@ -0,0 +1,20 @@
+import { AbstractViewer } from "../../viewer/viewer";
+import { extendedUpgrade, extendedDegrade } from "./extended";
+
+const cache: { [key: string]: (viewer: AbstractViewer) => boolean } = {};
+
+export function getCustomOptimizerByName(name: string, upgrade?: boolean) {
+    if (!cache[name]) {
+        switch (name) {
+            case 'extended':
+                if (upgrade) {
+                    return extendedUpgrade;
+                }
+                else {
+                    return extendedDegrade;
+                }
+        }
+    }
+
+    return cache[name];
+}

Viewer/src/viewer/sceneManager.ts

@@ -5,6 +5,7 @@ import { ViewerModel } from '../model/viewerModel';
 import { extendClassWithConfig } from '../helper';
 import { CameraBehavior } from '../interfaces';
 import { ViewerLabs } from '../labs/viewerLabs';
+import { getCustomOptimizerByName } from '../optimizer/custom/';
 
 /**
  * This interface describes the structure of the variable sent with the configuration observables of the scene manager.
@@ -163,6 +164,51 @@ export class SceneManager {
         this._processShadows = process;
     }
 
+    private _groundEnabled: boolean = true;
+
+    public get groundEnabled() {
+        return this._groundEnabled;
+    }
+
+    public set groundEnabled(newValue: boolean) {
+        if (newValue === this._groundEnabled) return;
+
+        this._groundEnabled = newValue;
+
+        if (this.environmentHelper && this.environmentHelper.ground) {
+            this.environmentHelper.ground.setEnabled(this._groundEnabled);
+        }
+    }
+
+    private _groundMirrorEnabled = false;
+        /**
+         * gets wether the reflection is disabled.
+         */
+        public get groundMirrorEnabled(): boolean {
+            return this._groundMirrorEnabled;
+        }
+        /**
+         * sets wether the reflection is disabled.
+         */
+        public set groundMirrorEnabled(value: boolean) {
+            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;
+                }
+            }
+        }
+
+    public getActiveRenderingPiplineByName(name: string) {
+        return this._piplines[name];
+    }
+
     /**
      * Sets the engine flags to unlock all babylon features.
      * Can also be configured using the scene.flags configuration object
@@ -488,6 +534,16 @@ export class SceneManager {
                 this.sceneOptimizer.stop();
                 this.sceneOptimizer.dispose()
             }
+            if (optimizerConfig.custom) {
+                let customOptimizer = getCustomOptimizerByName(optimizerConfig.custom, optimizerConfig.improvementMode);
+                if (customOptimizer) {
+                    optimizerOptions.addCustomOptimization(() => {
+                        return customOptimizer(this._viewer);
+                    }, () => {
+                        return `Babylon Viewer ${optimizerConfig.custom} custom optimization`;
+                    });
+                }
+            }
             this.sceneOptimizer = new SceneOptimizer(this.scene, optimizerOptions, optimizerConfig.autoGeneratePriorities, optimizerConfig.improvementMode);
             this.sceneOptimizer.start();
         }
@@ -589,7 +645,7 @@ export class SceneManager {
 
 
         const options: Partial<IEnvironmentHelperOptions> = {
-            createGround: !!groundConfiguration,
+            createGround: !!groundConfiguration && this._groundEnabled,
             createSkybox: !!skyboxConifguration,
             setupImageProcessing: false, // will be done at the scene level!,
         };
@@ -1025,6 +1081,8 @@ export class SceneManager {
             model.dispose();
         });
 
+        Object.keys(this._piplines).forEach(name => this._piplines[name].dispose());
+
         this.models.length = 0;
 
         this.scene.dispose();