Merge pull request #4299 from RaananW/viewer-tests

Viewer unit tests for configuration updates (scene and optimizer)

Viewer/src/configuration/configuration.ts

@@ -267,7 +267,7 @@ export interface IGroundConfiguration {
 export interface ISceneConfiguration {
     debug?: boolean;
     clearColor?: { r: number, g: number, b: number, a: number };
-    mainColor?: { r: number, g: number, b: number };
+    mainColor?: { r?: number, g?: number, b?: number };
     imageProcessingConfiguration?: IImageProcessingConfiguration;
     environmentTexture?: string;
     colorGrading?: IColorGradingConfiguration;

Viewer/src/viewer/sceneManager.ts

@@ -374,7 +374,7 @@ export class SceneManager {
         }
 
         // optimizer
-        if (newConfiguration.optimizer) {
+        if (newConfiguration.optimizer !== undefined) {
             this._configureOptimizer(newConfiguration.optimizer);
         }
 
@@ -563,9 +563,9 @@ export class SceneManager {
             }
         }
 
-        if (sceneConfig.debug) {
+        if (sceneConfig.debug === true) {
             this.scene.debugLayer.show();
-        } else {
+        } else if (sceneConfig.debug === false) {
             if (this.scene.debugLayer.isVisible()) {
                 this.scene.debugLayer.hide();
             }

Viewer/tests/unit/src/configuration/updateConfiguration.ts

@@ -0,0 +1,314 @@
+import { Helper } from "../../../commons/helper";
+import { assert, expect, should } from "../viewerReference";
+
+export let name = "configuration update";
+
+describe(name + " scene", () => {
+
+    it("should be used as a template for the following tests", (done) => {
+        let viewer = Helper.getNewViewerInstance(undefined, { extends: "none" });
+
+        viewer.onInitDoneObservable.add(() => {
+
+            viewer.dispose();
+            done();
+        });
+    });
+
+    it("should enable and disable the debug layer", (done) => {
+        let viewer = Helper.getNewViewerInstance(undefined, { extends: "none" });
+        let showCalled = 0;
+        let hideCalled = 0;
+        let isVisible = false;
+        viewer.onSceneInitObservable.add((scene) => {
+            scene.debugLayer.show = () => {
+                showCalled++;
+                isVisible = true;
+            }
+
+            scene.debugLayer.hide = () => {
+                hideCalled++;
+                isVisible = false;
+            }
+
+            scene.debugLayer.isVisible = () => {
+                return isVisible;
+            }
+        })
+        viewer.onInitDoneObservable.add(() => {
+            assert.isUndefined(viewer.configuration.scene);
+            assert.equal(showCalled, 0);
+            assert.equal(hideCalled, 0);
+            viewer.updateConfiguration({
+                scene: {
+                    debug: true
+                }
+            });
+            assert.equal(showCalled, 1);
+
+            viewer.updateConfiguration({
+                scene: {
+                    debug: false
+                }
+            });
+            assert.equal(showCalled, 1);
+            assert.equal(hideCalled, 1);
+            viewer.dispose();
+            done();
+        });
+    });
+
+    it("should update the image processing configuration values", (done) => {
+        let viewer = Helper.getNewViewerInstance(undefined, { extends: "none" });
+
+        viewer.onInitDoneObservable.add(() => {
+
+            // check babylon defaults
+            assert.isFalse(viewer.sceneManager.scene.imageProcessingConfiguration.applyByPostProcess);
+            assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.exposure, 1);
+            assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.contrast, 1);
+            assert.isFalse(viewer.sceneManager.scene.imageProcessingConfiguration.colorGradingEnabled);
+            if (viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves) {
+                assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves.globalDensity, 0);
+                assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves.globalHue, 30);
+                assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves.globalSaturation, 0);
+            } else {
+                assert.fail(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves, {}, "color curves was not initialized");
+            }
+
+            // update with fixed values
+
+            viewer.updateConfiguration({
+                scene: {
+                    imageProcessingConfiguration: {
+                        applyByPostProcess: true,
+                        exposure: 0,
+                        contrast: 0,
+                        colorGradingEnabled: true,
+                        colorCurves: {
+                            globalDensity: 1,
+                            globalHue: 0.2,
+                            globalSaturation: 0.5
+                        }
+
+                    }
+                }
+            });
+
+            assert.isTrue(viewer.sceneManager.scene.imageProcessingConfiguration.applyByPostProcess, "apply by post process should be true");
+            assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.exposure, 0);
+            assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.contrast, 0);
+            assert.isTrue(viewer.sceneManager.scene.imageProcessingConfiguration.colorGradingEnabled);
+            if (viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves) {
+                assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves.globalDensity, 1);
+                assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves.globalHue, 0.2);
+                assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves.globalSaturation, 0.5);
+            } else {
+                assert.fail(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves, {}, "color curves was not initialized");
+            }
+
+            let randoms = [0, 1, 2, 3, 4].map(n => Math.random());
+
+            viewer.updateConfiguration({
+                scene: {
+                    imageProcessingConfiguration: {
+                        exposure: randoms[0],
+                        contrast: randoms[1],
+                        colorCurves: {
+                            highlightsDensity: randoms[2],
+                            highlightsHue: randoms[3],
+                            highlightsSaturation: randoms[4]
+                        }
+
+                    }
+                }
+            });
+
+            assert.isTrue(viewer.sceneManager.scene.imageProcessingConfiguration.applyByPostProcess, "apply by post process should be true");
+            assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.exposure, randoms[0]);
+            assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.contrast, randoms[1]);
+            assert.isTrue(viewer.sceneManager.scene.imageProcessingConfiguration.colorGradingEnabled);
+            if (viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves) {
+                assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves.highlightsDensity, randoms[2]);
+                assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves.highlightsHue, randoms[3]);
+                assert.equal(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves.highlightsSaturation, randoms[4]);
+            } else {
+                assert.fail(viewer.sceneManager.scene.imageProcessingConfiguration.colorCurves, {}, "color curves was not initialized");
+            }
+
+            viewer.dispose();
+            done();
+        });
+    });
+
+    it("should update main color and reflection color", (done) => {
+        let viewer = Helper.getNewViewerInstance(undefined, { extends: "none" });
+
+        viewer.onInitDoneObservable.add(() => {
+
+            assert.equal(viewer.sceneManager.mainColor.r, 1);
+            assert.equal(viewer.sceneManager.mainColor.g, 1);
+            assert.equal(viewer.sceneManager.mainColor.b, 1);
+
+            assert.equal(viewer.sceneManager.reflectionColor.r, 1);
+            assert.equal(viewer.sceneManager.reflectionColor.g, 1);
+            assert.equal(viewer.sceneManager.reflectionColor.b, 1);
+
+            viewer.updateConfiguration({
+                scene: {
+                    mainColor: {
+                        r: 0.5,
+                        g: 0.5,
+                        b: 0.5
+                    }
+                },
+                lab: {
+                    environmentMap: {
+                        tintLevel: 1,
+                        texture: "",
+                        rotationY: 0
+                    }
+                }
+            });
+
+            assert.equal(viewer.sceneManager.mainColor.r, 0.5);
+            assert.equal(viewer.sceneManager.mainColor.g, 0.5);
+            assert.equal(viewer.sceneManager.mainColor.b, 0.5);
+
+            // to black
+            viewer.updateConfiguration({
+                scene: {
+                    mainColor: {
+                        r: 0,
+                        g: 0,
+                        b: 0
+                    }
+                }
+            });
+
+            assert.equal(viewer.sceneManager.mainColor.r, 0);
+            assert.equal(viewer.sceneManager.mainColor.g, 0);
+            assert.equal(viewer.sceneManager.mainColor.b, 0);
+
+            assert.equal(viewer.sceneManager.reflectionColor.r, 0);
+            assert.equal(viewer.sceneManager.reflectionColor.g, 0);
+            assert.equal(viewer.sceneManager.reflectionColor.b, 0);
+
+            let randomColor = Math.random();
+
+            //only update red
+            viewer.updateConfiguration({
+                scene: {
+                    mainColor: {
+                        r: randomColor
+                    }
+                }
+            });
+
+            assert.equal(viewer.sceneManager.mainColor.r, randomColor);
+            assert.equal(viewer.sceneManager.mainColor.g, 0);
+            assert.equal(viewer.sceneManager.mainColor.b, 0);
+
+            viewer.dispose();
+            done();
+        });
+    });
+
+    it("should update the flags correctly", (done) => {
+        let viewer = Helper.getNewViewerInstance(undefined, { extends: "none" });
+
+        viewer.onInitDoneObservable.add(() => {
+
+            viewer.updateConfiguration({
+                scene: {
+                    flags: {
+                        audioEnabled: false
+                    }
+                }
+            });
+
+            assert.isFalse(viewer.sceneManager.scene.audioEnabled);
+
+            viewer.updateConfiguration({
+                scene: {
+                    flags: {
+                        audioEnabled: true,
+                        lightsEnabled: false
+                    }
+                }
+            });
+
+            assert.isTrue(viewer.sceneManager.scene.audioEnabled);
+            assert.isFalse(viewer.sceneManager.scene.lightsEnabled);
+
+            viewer.updateConfiguration({
+                scene: {
+                    flags: {
+                        lightsEnabled: true,
+                        shadowsEnabled: false
+                    }
+                }
+            });
+
+            assert.isTrue(viewer.sceneManager.scene.audioEnabled);
+            assert.isTrue(viewer.sceneManager.scene.lightsEnabled);
+            assert.isFalse(viewer.sceneManager.scene.shadowsEnabled);
+
+            viewer.dispose();
+            done();
+        });
+    });
+});
+
+describe(name + " scene optimizer", () => {
+
+    it("should be enabled and disabled with booleans", (done) => {
+        let viewer = Helper.getNewViewerInstance(undefined, { extends: "none" });
+
+        let started = false;
+        let constructed = false;
+
+        let optimizerFunction = BABYLON.SceneOptimizer;
+
+        //mock!
+        (<any>BABYLON.SceneOptimizer) = function () {
+            constructed = true;
+        }
+
+        BABYLON.SceneOptimizer.prototype.start = function () {
+            started = true;
+        }
+
+        BABYLON.SceneOptimizer.prototype.stop = function () {
+            started = false;
+        }
+
+        BABYLON.SceneOptimizer.prototype.dispose = function () {
+        }
+
+        viewer.onInitDoneObservable.add(() => {
+
+            assert.isUndefined(viewer.sceneManager.sceneOptimizer);
+
+            viewer.updateConfiguration({
+                optimizer: true
+            });
+
+            assert.isDefined(viewer.sceneManager.sceneOptimizer);
+            assert.isTrue(started);
+            assert.isTrue(constructed);
+
+            viewer.updateConfiguration({
+                optimizer: false
+            });
+
+            assert.isUndefined(viewer.sceneManager.sceneOptimizer);
+            assert.isFalse(started);
+
+            BABYLON.SceneOptimizer = optimizerFunction;
+
+            viewer.dispose();
+            done();
+        });
+    });
+});

Viewer/tests/unit/src/index.ts

@@ -7,4 +7,5 @@ import './viewer/viewerManager';
 import './configuration/mappers';
 import './configuration/loader';
 import './helper';
+import './configuration/updateConfiguration';
 export * from '../../../src'