making sure telemetry manager works with null engine

Viewer/src/telemetryManager.ts

@@ -46,11 +46,15 @@ export class TelemetryManager {
 
         while (logErrors) {
             let gl = (<any>engine)._gl;
-            let error = gl.getError();
-            if (error === gl.NO_ERROR) {
-                logErrors = false;
+            if (gl && gl.getError) {
+                let error = gl.getError();
+                if (error === gl.NO_ERROR) {
+                    logErrors = false;
+                } else {
+                    this.broadcast("WebGL Error", viewer, { error: error });
+                }
             } else {
-                this.broadcast("WebGL Error", viewer, { error: error });
+                logErrors = false;
             }
         }
     }

Viewer/src/viewer/viewer.ts

@@ -280,7 +280,7 @@ export abstract class AbstractViewer {
      */
     protected _render = (force: boolean = false): void => {
         if (force || (this.sceneManager.scene && this.sceneManager.scene.activeCamera)) {
-            if (this.runRenderLoop) {
+            if (this.runRenderLoop || force) {
                 this.engine.performanceMonitor.enable();
                 this.sceneManager.scene.render();
                 this.onFrameRenderedObservable.notifyObservers(this);
@@ -344,7 +344,7 @@ export abstract class AbstractViewer {
                 if (newConfiguration.loaderPlugins && newConfiguration.loaderPlugins[name]) {
                     this.modelLoader.addPlugin(name);
                 }
-            }))
+            }));
         }
     }
 
@@ -448,6 +448,7 @@ export abstract class AbstractViewer {
             return this._initEngine().then((engine) => {
                 return this.onEngineInitObservable.notifyObserversWithPromise(engine);
             }).then(() => {
+                this._initTelemetryEvents();
                 if (autoLoad) {
                     return this.loadModel(this._configuration.model!).catch(e => { }).then(() => { return this.sceneManager.scene });
                 } else {
@@ -596,14 +597,14 @@ export abstract class AbstractViewer {
 
     private _fpsTimeout: number;
 
-    protected initTelemetryEvents() {
+    protected _initTelemetryEvents() {
         telemetryManager.broadcast("Engine Capabilities", this, this.engine.getCaps());
         telemetryManager.broadcast("Platform Details", this, {
             userAgent: navigator.userAgent,
             platform: navigator.platform
         });
 
-        telemetryManager.flushWebGLErrors(this);
+        // telemetryManager.flushWebGLErrors(this);
 
         let trackFPS: Function = () => {
             telemetryManager.broadcast("Current FPS", this, { fps: this.engine.getFps() });

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

@@ -1,6 +1,6 @@
 import { Helper } from "../../../commons/helper";
 import { assert, expect, should } from "../viewerReference";
-import { DefaultViewer, AbstractViewer, Version } from "../../../../src";
+import { DefaultViewer, AbstractViewer, Version, viewerManager } from "../../../../src";
 
 export let name = "viewer Tests";
 
@@ -9,10 +9,33 @@ export let name = "viewer Tests";
  */
 
 describe('Viewer', function () {
-    it('should initialize a new viewer', (done) => {
+    it('should initialize a new viewer and its internal variables', (done) => {
         let viewer = Helper.getNewViewerInstance();
+        assert.isDefined(viewer.baseId, "base id should be defined");
+        assert.isDefined(viewer.templateManager, "template manager should be defined");
+        assert.isDefined(viewer.sceneManager, "scene manager should be defined");
+        assert.isDefined(viewer.modelLoader, "model loader should be defined");
         viewer.onInitDoneObservable.add(() => {
-            assert.isTrue(viewer != undefined, "Viewer can not be instantiated.");
+            assert.isDefined(viewer, "Viewer can not be instantiated.");
+            viewer.dispose();
+            done();
+        });
+    });
+
+    it('should be added to the viewer manager', (done) => {
+        let viewer = Helper.getNewViewerInstance();
+        viewer.onInitDoneObservable.add(() => {
+            assert.isDefined(viewerManager.getViewerById(viewer.baseId), "Viewer was not added to the viewer manager.");
+            viewer.dispose();
+            done();
+        });
+    });
+
+    it('should have a defined canvas', (done) => {
+        let viewer = Helper.getNewViewerInstance();
+        viewer.onInitDoneObservable.add(() => {
+            assert.isDefined(viewer.canvas, "Canvas is not defined");
+            assert.isTrue(viewer.canvas instanceof HTMLCanvasElement, "Canvas is not a canvas");
             viewer.dispose();
             done();
         });
@@ -224,6 +247,19 @@ describe('Viewer', function () {
             shouldBeRendering = true;
         });
     });
+
+    it('should render if forceRender was called', (done) => {
+        let viewer = Helper.getNewViewerInstance();
+        viewer.runRenderLoop = false;
+        viewer.onInitDoneObservable.add(() => {
+            viewer.onFrameRenderedObservable.add(() => {
+                assert.isTrue(true, "not rendered");
+                viewer.dispose();
+                done();
+            });
+            viewer.forceRender();
+        });
+    });
 });
 
 //}