further unit tests and fixes

Viewer/src/configuration/configuration.ts

@@ -215,6 +215,9 @@ export interface ISceneConfiguration {
     colorGrading?: IColorGradingConfiguration;
     environmentRotationY?: number;
     glow?: boolean | IGlowLayerOptions;
+    disableHdr?: boolean;
+    renderInBackground?: boolean;
+    disableCameraControl?: boolean;
     animationPropertiesOverride?: {
         [propName: string]: any;
     }

Viewer/src/configuration/types/shadowLight.ts

@@ -31,7 +31,7 @@ export const shadowSpotlLightConfiguration: ViewerConfiguration = {
             target: { x: 0, y: 0, z: 0 },
             position: { x: 0, y: 2.1, z: 2.7 },
             angle: 1,
-            shadowOrthoScale: 0.1,
+            shadowOrthoScale: 0.5,
             shadowBufferSize: 1024,
             shadowMinZ: 0.1,
             shadowMaxZ: 50.0,

Viewer/src/viewer/sceneManager.ts

@@ -389,6 +389,18 @@ export class SceneManager {
             }
         }
 
+        if (sceneConfig.disableHdr) {
+            this._handleHardwareLimitations(false);
+        }
+
+        this._viewer.renderInBackground = !!sceneConfig.renderInBackground;
+
+        if (this.camera && sceneConfig.disableCameraControl) {
+            this.camera.detachControl(this._viewer.canvas);
+        } else if (this.camera && sceneConfig.disableCameraControl === false) {
+            this.camera.attachControl(this._viewer.canvas);
+        }
+
         this.onSceneConfiguredObservable.notifyObservers({
             sceneManager: this,
             object: this.scene,
@@ -468,7 +480,11 @@ export class SceneManager {
         let focusMeshes = model ? model.meshes : this.scene.meshes;
 
         if (!this.scene.activeCamera) {
-            this.scene.createDefaultCamera(true, true, true);
+            let attachControl = true;
+            if (this._viewer.configuration.scene && this._viewer.configuration.scene.disableCameraControl) {
+                attachControl = false;
+            }
+            this.scene.createDefaultCamera(true, true, attachControl);
             this.camera = <ArcRotateCamera>this.scene.activeCamera!;
             this.camera.setTarget(Vector3.Zero());
         }

Viewer/src/viewer/viewer.ts

@@ -197,6 +197,11 @@ export abstract class AbstractViewer {
         this.onModelLoadedObservable.add((model) => {
             this.updateConfiguration(this._configuration, model);
         });
+
+        this.onInitDoneObservable.add(() => {
+            this._isInit = true;
+            this.engine.runRenderLoop(this._render);
+        });
     }
 
     /**
@@ -283,7 +288,7 @@ export abstract class AbstractViewer {
                 this.engine.performanceMonitor.disable();
 
                 // TODO - is this needed?
-                // this.sceneManager.scene.activeCamera && this.sceneManager.scene.activeCamera.update();
+                this.sceneManager.scene.activeCamera && this.sceneManager.scene.activeCamera.update();
             }
         }
     }
@@ -454,8 +459,6 @@ export abstract class AbstractViewer {
                 }
                 return this.onSceneInitObservable.notifyObserversWithPromise(scene);
             }).then(() => {
-                this._isInit = true;
-                this.engine.runRenderLoop(this._render);
                 return this.onInitDoneObservable.notifyObserversWithPromise(this);
             }).catch(e => {
                 Tools.Warn(e.toString());

Viewer/tests/commons/boot.ts

@@ -6,7 +6,6 @@ export class Boot {
     public static AppendResult = false;
 
     public static main() {
-        console.log("main")
         //let babylonSource = Boot.loadSync('base/js/babylon.viewer.max.js');
         //let spectreSource = Boot.loadSync('base/js/spectreonly.js');
 
@@ -20,7 +19,8 @@ export class Boot {
             //clear DOM and create canvas and container
             document.getElementById('working-div')!.innerHTML = `<div style="font-size:30px;">WORKING CANVASES.</div> 
 				<div id="viewer-testing" style="width:512px;height:512px;">
-					<div id="renderCanvas" width="512" height="512" style="width:512px;height:512px;"></div>
+                    <div id="renderCanvas" width="512" height="512" style="width:512px;height:512px;">
+                    <canvas width="512" height="512" style="width:512px;height:512px;"></canvas></div>
 					<canvas id="referenceCanvas" width="512" height="512" style="width:512px;height:512px;"></canvas>
 				</div>
 			`;

Viewer/tests/commons/helper.ts

@@ -1,4 +1,4 @@
-import { AbstractViewer, DefaultViewer, ViewerModel, viewerGlobals, AnimationPlayMode, AnimationState } from "../../src";
+import { BABYLON, AbstractViewer, DefaultViewer, ViewerModel, viewerGlobals, AnimationPlayMode, AnimationState } from "../../src";
 import { ViewerConfiguration } from "../../src/configuration/configuration";
 import { IModelAnimation } from "../../src/model/modelAnimation";
 
@@ -130,6 +130,10 @@ export class NullEngineAbstractViewer extends AbstractViewer {
 
         this.engine = new BABYLON.NullEngine(config.engineOptions);
 
+        this.engine.getRenderingCanvas = () => {
+            return this.canvas;
+        }
+
         // Disable manifest checking
         BABYLON.Database.IDBStorageEnabled = false;
 
@@ -166,6 +170,9 @@ export class NullEngineDefaultViewer extends DefaultViewer {
         config.engineOptions.renderWidth = 500;
 
         this.engine = new BABYLON.NullEngine(config.engineOptions);
+        this.engine.getRenderingCanvas = () => {
+            return this.canvas;
+        }
 
         // Disable manifest checking
         BABYLON.Database.IDBStorageEnabled = false;

Viewer/tests/unit/src/Viewer/viewer.ts

@@ -1,5 +1,5 @@
 import { Helper } from "../../../commons/helper";
-import { assert, expect } from "../viewerReference";
+import { assert, expect, should } from "../viewerReference";
 import { DefaultViewer, AbstractViewer, Version } from "../../../../src";
 
 export let name = "viewer Tests";
@@ -146,92 +146,89 @@ describe('Viewer', function () {
             assert.equal(resizeCount, 1, "Engine should not resize when if Viewer has been disposed.");
             done();
         });
-    })
-});
-
-//}
-
-
-
-/*QUnit.test('Viewer HDR', function (assert) {
-    let done = assert.async();
-
-    //override _handleHardwareLimitations with no-op to ensure HDR isn't disabled
-    (<any>AbstractViewer.prototype)._handleHardwareLimitations = () => { };
-
-    let viewer: AbstractViewer;
+    });
 
-    let frameCount = 0;
-    viewer = new DefaultViewer(Helper.getCanvas(), {
-        hdr: true,
-        renderCallback: () => {
-            frameCount++;
-            if (frameCount === 30) {
-                viewer.dispose();
-                viewer = null;
-                assert.ok(true, 'Successfully rendered 30 HDR frames and disposed');
-                done();
-            }
-        }
+    it('should render in background if set to true', (done) => {
+        let viewer = Helper.getNewViewerInstance();
+        viewer.onInitDoneObservable.add(() => {
+            assert.isFalse(viewer.engine.renderEvenInBackground, "Engine is rendering in background");
+            viewer.updateConfiguration({
+                scene: {
+                    renderInBackground: true
+                }
+            });
+            assert.isTrue(viewer.engine.renderEvenInBackground, "Engine is not rendering in background");
+            viewer.dispose();
+            done();
+        });
     });
-    viewer.onInitDoneObservable.add(() => {
-        assert.ok(true, "not initialized");
+
+    it('should attach and detach camera control correctly', (done) => {
+        let viewer = Helper.getNewViewerInstance();
+        viewer.onInitDoneObservable.add(() => {
+            assert.isDefined(viewer.sceneManager.camera.inputs.attachedElement, "Camera is not attached per default");
+            viewer.updateConfiguration({
+                scene: {
+                    disableCameraControl: true
+                }
+            });
+            assert.isNull(viewer.sceneManager.camera.inputs.attachedElement, "Camera is still attached");
+            viewer.updateConfiguration({
+                scene: {
+                    disableCameraControl: false
+                }
+            });
+            assert.isDefined(viewer.sceneManager.camera.inputs.attachedElement, "Camera not attached");
+            viewer.dispose();
+            done();
+        });
     });
-});
 
-QUnit.test('Viewer LDR', function (assert) {
-    let done = assert.async();
+    it('should take screenshot when called', (done) => {
+        let viewer = Helper.getNewViewerInstance();
+        viewer.onInitDoneObservable.add(() => {
+            Helper.MockScreenCapture(viewer, Helper.mockScreenCaptureData());
 
-    let viewer: AbstractViewer;
+            viewer.takeScreenshot(function (data) {
+                assert.equal(data, Helper.mockScreenCaptureData(), "Screenshot failed.");
 
-    let frameCount = 0;
-    viewer = new DefaultViewer(Helper.getCanvas(), {
-        hdr: false,
-        renderCallback: () => {
-            frameCount++;
-            if (frameCount === 30) {
                 viewer.dispose();
-                viewer = null;
-                assert.ok(true, 'Successfully rendered 30 LDR frames and disposed');
                 done();
-            }
-        }
-    });
-});
-
-QUnit.test('Viewer disable render in background', function (assert) {
-    let viewer = new DefaultViewer(Helper.getCanvas());
-
-    QUnit.assert.ok(viewer.RenderInBackground, "Viewer renders in background default.");
-
-    viewer.dispose();
-    viewer = null;
-
-    viewer = new DefaultViewer(Helper.getCanvas(), {
-        disableRenderInBackground: true
+            });
+        });
     });
 
-    QUnit.assert.ok(viewer.RenderInBackground === false, "Viewer does not render in background with disableRenderInBackground set to true.");
+    it('should notify observers correctly during init', (done) => {
+        let viewer = Helper.getNewViewerInstance();
 
-    viewer.dispose();
-});
+        let shouldBeRendering = false;
 
-QUnit.test('Viewer disable camera control', function (assert) {
-    let viewer = new DefaultViewer(Helper.getCanvas());
+        viewer.onFrameRenderedObservable.add(() => {
+            assert.isTrue(shouldBeRendering, "rendered before init done");
+            viewer.dispose();
+            done();
+        });
 
-    QUnit.assert.ok(viewer.Scene.Camera.inputs.attachedElement, "Viewer should attach camera control by default.");
+        viewer.onEngineInitObservable.add((engine) => {
+            assert.equal(engine, viewer.engine, "engine instance is not the same");
+            assert.isUndefined(viewer.sceneManager.scene, "scene exists before initScene");
+        });
 
-    viewer.dispose();
-    viewer = null;
+        viewer.onSceneInitObservable.add((scene) => {
+            assert.equal(scene, viewer.sceneManager.scene, "scene instance is not the same");
+        })
 
-    viewer = new DefaultViewer(Helper.getCanvas(), {
-        disableCameraControl: true
+        viewer.onInitDoneObservable.add((viewerInstance) => {
+            assert.isDefined(viewerInstance.sceneManager.scene, "scene is not defined");
+            //scene exists, it should now start rendering
+            shouldBeRendering = true;
+        });
     });
+});
 
-    QUnit.assert.ok(!viewer.Scene.Camera.inputs.attachedElement, "Viewer should not attach camera control with disableCameraControl set to true.");
+//}
+/*
 
-    viewer.dispose();
-});
 
 QUnit.test('Viewer disable ctrl for panning', function (assert) {
     let viewer = new DefaultViewer(Helper.getCanvas());
@@ -397,15 +394,4 @@ QUnit.test('unlockBabylonFeatures', function () {
     QUnit.assert.ok(viewer.Scene.EngineScene.audioEnabled, "audioEnabled");
 });
 
-QUnit.test('Take Screenshot', function (assert) {
-    let viewer = Helper.createViewer();
-    let done = assert.async();
-
-    Helper.MockScreenCapture(viewer, Helper.mockScreenCaptureData());
-
-    viewer.takeScreenshot(function (data) {
-        QUnit.assert.ok(data === Helper.mockScreenCaptureData(), "Screenshot failed.");
-        done();
-    });
-});
 */