New SceneInstrumentation

Tools/Gulp/config.json

@@ -229,8 +229,9 @@
         },    
         "instrumentation": {
             "files": [
-                "../../src/Engine/babylon.engineInstrumentation.js",
-                "../../src/Engine/babylon.timeToken.js"
+                "../../src/Instrumentation/babylon.engineInstrumentation.js",
+                "../../src/Instrumentation/babylon.sceneInstrumentation.js",
+                "../../src/Instrumentation/babylon.timeToken.js"
             ],
             "dependUpon": [
                 "core"

dist/preview release/what's new.md

@@ -18,6 +18,7 @@
 - Added support for Particle animation in ParticleSystem. [Doc here](http://doc.babylonjs.com/tutorials/particles#particle-animation) ([Ibraheem Osama](https://github.com/IbraheemOsama))
 - More robust TypeScript code with *strictNullChecks*, *noImplicitAny*, *noImplicitThis* and *noImplicitReturns* compiler options ([deltakosh](https://github.com/deltakosh))
 - Introduced `NullEngine` which can be used to use Babylon.js in headless mode. [Doc here](http://doc.babylonjs.com/generals/nullengine) ([deltakosh](https://github.com/deltakosh))
+- New instrumentations tools. [Doc here](http://doc.babylonjs.com/how_to/optimizing_your_scene#instrumentation) ([deltakosh](https://github.com/deltakosh))
 
 ## Updates
 - Support for non uniform scaling. Normals are now correctly computed ([deltakosh](https://github.com/deltakosh))

inspector/src/tabs/StatsTab.ts

@@ -16,6 +16,8 @@ module INSPECTOR {
 
         private _updateLoopHandler : any;
 
+        private _sceneInstrumentation: BABYLON.SceneInstrumentation;
+
         constructor(tabbar:TabBar, insp:Inspector) {
             super(tabbar, 'Stats');        
 
@@ -25,6 +27,9 @@ module INSPECTOR {
             this._engine            = this._scene.getEngine();
             this._glInfo            = this._engine.getGlInfo();
 
+            this._sceneInstrumentation = new BABYLON.SceneInstrumentation(this._scene);
+            this._sceneInstrumentation.captureActiveMeshesEvaluationTime = true;
+
             // Build the stats panel: a div that will contains all stats
             this._panel             = Helpers.CreateDiv('tab-panel') as HTMLDivElement; 
             this._panel.classList.add("stats-panel")
@@ -125,7 +130,7 @@ module INSPECTOR {
                 let elemValue = Helpers.CreateDiv('stat-value', this._panel);
                 this._updatableProperties.push({ 
                     elem:elemValue, 
-                    updateFct:() => { return BABYLON.Tools.Format(this._scene.getEvaluateActiveMeshesDuration())}
+                    updateFct:() => { return BABYLON.Tools.Format(this._sceneInstrumentation.currentActiveMeshesEvaluationTime)}
                 });
                 elemLabel = this._createStatLabel("Render targets", this._panel);
                 elemValue = Helpers.CreateDiv('stat-value', this._panel);
@@ -296,6 +301,7 @@ module INSPECTOR {
 
         public dispose() {
             this._scene.unregisterAfterRender(this._updateLoopHandler);
+            this._sceneInstrumentation.dispose();
         }
 
         public active(b: boolean){

src/Engine/babylon.engineInstrumentation.ts

@@ -18,21 +18,21 @@ module BABYLON {
 
         // Properties
         /**
-         * Get the perf counter used for GPU frame time
+         * Gets the perf counter used for GPU frame time
          */
         public get gpuFrameTimeCounter(): PerfCounter {
             return this._gpuFrameTime;
         }
 
         /**
-         * Get the current GPU frame time (in nanoseconds)
+         * Gets the current GPU frame time (in nanoseconds)
          */
         public get currentGPUFrameTime(): number {
             return this._gpuFrameTime.current;
         }
 
         /**
-         * Get the average GPU frame time (in nanoseconds)
+         * Gets the average GPU frame time (in nanoseconds)
          */        
         public get averageGPUFrameTime(): number {
             return this._gpuFrameTime.average;
@@ -81,35 +81,35 @@ module BABYLON {
         }
 
         /**
-         * Get the perf counter used for shader compilation time
+         * Gets the perf counter used for shader compilation time
          */
         public get shaderCompilationTimeCounter(): PerfCounter {
             return this._shaderCompilationTime;
         }
 
         /**
-         * Get the current shader compilation time (in milliseconds)
+         * Gets the current shader compilation time (in milliseconds)
          */
         public get currentShaderCompilationTime(): number {
             return this._shaderCompilationTime.current;
         }
 
         /**
-         * Get the average shader compilation time (in milliseconds)
+         * Gets the average shader compilation time (in milliseconds)
          */        
         public get averageShaderCompilationTime(): number {
             return this._shaderCompilationTime.average;
         }
 
         /**
-         * Get the total shader compilation time (in milliseconds)
+         * Gets the total shader compilation time (in milliseconds)
          */        
         public get totalShaderCompilationTime(): number {
             return this._shaderCompilationTime.total;
         }               
 
         /**
-         * Get the number of compiled shaders
+         * Gets the number of compiled shaders
          */        
         public get compiledShadersCount(): number {
             return this._shaderCompilationTime.count;
@@ -148,29 +148,20 @@ module BABYLON {
         }
 
         public constructor(public engine: Engine) {
-
         }
 
         public dispose() {
-            if (this._onBeginFrameObserver) {
-                this.engine.onBeginFrameObservable.remove(this._onBeginFrameObserver);
-                this._onBeginFrameObserver = null;
-            }
+            this.engine.onBeginFrameObservable.remove(this._onBeginFrameObserver);
+            this._onBeginFrameObserver = null;
 
-            if (this._onEndFrameObserver) {
-                this.engine.onEndFrameObservable.remove(this._onEndFrameObserver);
-                this._onEndFrameObserver = null;
-            }
+            this.engine.onEndFrameObservable.remove(this._onEndFrameObserver);
+            this._onEndFrameObserver = null;
 
-            if (this._onBeforeShaderCompilationObserver) {
-                this.engine.onBeforeShaderCompilationObservable.remove(this._onBeforeShaderCompilationObserver);
-                this._onBeforeShaderCompilationObserver = null;
-            }
+            this.engine.onBeforeShaderCompilationObservable.remove(this._onBeforeShaderCompilationObserver);
+            this._onBeforeShaderCompilationObserver = null;
 
-            if (this._onAfterShaderCompilationObserver) {
-                this.engine.onAfterShaderCompilationObservable.remove(this._onAfterShaderCompilationObserver);
-                this._onAfterShaderCompilationObserver = null;     
-            }       
+            this.engine.onAfterShaderCompilationObservable.remove(this._onAfterShaderCompilationObserver);
+            this._onAfterShaderCompilationObserver = null;     
 
             (<any>this.engine) = null;
         }

src/Instrumentation/babylon.sceneInstrumentation.ts

@@ -0,0 +1,82 @@
+module BABYLON {
+    /**
+     * This class can be used to get instrumentation data from a Babylon engine
+     */
+    export class SceneInstrumentation implements IDisposable {
+        private _captureActiveMeshesEvaluationTime = false;
+        private _activeMeshesEvaluationTime = new PerfCounter();  
+
+        // Observers
+        private _onBeforeActiveMeshesEvaluationObserver: Nullable<Observer<Scene>> = null;
+        private _onAfterActiveMeshesEvaluationObserver: Nullable<Observer<Scene>> = null;
+                
+        // Properties
+        /**
+         * Gets the perf counter used for active meshes evaluation time
+         */
+        public get activeMeshesEvaluationTime(): PerfCounter {
+            return this._activeMeshesEvaluationTime;
+        }
+
+        /**
+         * Gets the current active meshes evaluation time (in milliseconds)
+         */
+        public get currentActiveMeshesEvaluationTime(): number {
+            return this._activeMeshesEvaluationTime.current;
+        }
+
+        /**
+         * Gets the average active meshes evaluation time (in milliseconds)
+         */        
+        public get averageActiveMeshesEvaluationTime(): number {
+            return this._activeMeshesEvaluationTime.average;
+        }
+
+        /**
+         * Gets the current active meshes evaluation time capture status
+         */
+        public get captureActiveMeshesEvaluationTime(): boolean {
+            return this._captureActiveMeshesEvaluationTime;
+        }
+
+        /**
+         * Enable or disable the active meshes evaluation time capture
+         */        
+        public set captureActiveMeshesEvaluationTime(value: boolean) {
+            if (value === this._captureActiveMeshesEvaluationTime) {
+                return;
+            }
+
+            if (value) {
+                this._onBeforeActiveMeshesEvaluationObserver = this.scene.onBeforeActiveMeshesEvaluationObservable.add(()=>{
+                    Tools.StartPerformanceCounter("Active meshes evaluation");
+                    this._activeMeshesEvaluationTime.beginMonitoring();
+                });
+
+                this._onAfterActiveMeshesEvaluationObserver = this.scene.onAfterActiveMeshesEvaluationObservable.add(()=>{                    
+                    Tools.EndPerformanceCounter("Active meshes evaluation");
+                    this._activeMeshesEvaluationTime.endMonitoring();
+                });
+            } else {
+                this.scene.onBeforeActiveMeshesEvaluationObservable.remove(this._onBeforeActiveMeshesEvaluationObserver);
+                this._onBeforeActiveMeshesEvaluationObserver = null;
+
+                this.scene.onAfterActiveMeshesEvaluationObservable.remove(this._onAfterActiveMeshesEvaluationObserver);
+                this._onAfterActiveMeshesEvaluationObserver = null;
+            }
+        }
+    
+        public constructor(public scene: Scene) {
+        }
+
+        public dispose() {
+            this.scene.onBeforeActiveMeshesEvaluationObservable.remove(this._onBeforeActiveMeshesEvaluationObserver);
+            this._onBeforeActiveMeshesEvaluationObserver = null;
+
+            this.scene.onAfterActiveMeshesEvaluationObservable.remove(this._onAfterActiveMeshesEvaluationObserver);
+            this._onAfterActiveMeshesEvaluationObserver = null;
+        
+            (<any>this.scene) = null;
+        }
+    }
+}

src/babylon.scene.ts

@@ -285,6 +285,18 @@
         }
 
         /**
+        * An event triggered when active meshes evaluation is about to start
+        * @type {BABYLON.Observable}
+        */
+        public onBeforeActiveMeshesEvaluationObservable = new Observable<Scene>();        
+
+        /**
+        * An event triggered when active meshes evaluation is done
+        * @type {BABYLON.Observable}
+        */
+        public onAfterActiveMeshesEvaluationObservable = new Observable<Scene>();           
+
+        /**
         * An event triggered when a camera is created
         * @type {BABYLON.Observable}
         */
@@ -723,16 +735,11 @@
         private _engine: Engine;
 
         // Performance counters
-        private _totalMeshesCounter = new PerfCounter();
-        private _totalLightsCounter = new PerfCounter();
-        private _totalMaterialsCounter = new PerfCounter();
-        private _totalTexturesCounter = new PerfCounter();
         private _totalVertices = new PerfCounter();
         public _activeIndices = new PerfCounter();
         public _activeParticles = new PerfCounter();
         private _interFrameDuration = new PerfCounter();
         private _lastFrameDuration = new PerfCounter();
-        private _evaluateActiveMeshesDuration = new PerfCounter();
         private _renderTargetsDuration = new PerfCounter();
         public _particlesDuration = new PerfCounter();
         private _renderDuration = new PerfCounter();
@@ -994,13 +1001,14 @@
         }
 
         public getEvaluateActiveMeshesDuration(): number {
-            return this._evaluateActiveMeshesDuration.current;
+            Tools.Log("getEvaluateActiveMeshesDuration is deprecated. Please use SceneInstrumentation class");
+            return 0;
         }
 
-        public get evaluateActiveMeshesDurationPerfCounter(): PerfCounter {
-            return this._evaluateActiveMeshesDuration;
+        public get evaluateActiveMeshesDurationPerfCounter(): Nullable<PerfCounter> {
+            Tools.Log("evaluateActiveMeshesDurationPerfCounter is deprecated. Please use SceneInstrumentation class");
+            return null;
         }
-
         public getActiveMeshes(): SmartArray<AbstractMesh> {
             return this._activeMeshes;
         }
@@ -2769,6 +2777,8 @@
                 return;
             }
 
+            this.onBeforeActiveMeshesEvaluationObservable.notifyObservers(this);
+
             this.activeCamera._activeMeshes.reset();
             this._activeMeshes.reset();
             this._renderingManager.reset();
@@ -2835,6 +2845,8 @@
                 }
             }
 
+            this.onAfterActiveMeshesEvaluationObservable.notifyObservers(this);
+
             // Particle systems
             this._particlesDuration.beginMonitoring();
             if (this.particlesEnabled) {
@@ -2942,11 +2954,7 @@
             this.onBeforeCameraRenderObservable.notifyObservers(this.activeCamera);
 
             // Meshes
-            this._evaluateActiveMeshesDuration.beginMonitoring();
-            Tools.StartPerformanceCounter("Active meshes evaluation");
             this._evaluateActiveMeshes();
-            this._evaluateActiveMeshesDuration.endMonitoring(false);
-            Tools.EndPerformanceCounter("Active meshes evaluation");
 
             // Software skinning
             for (var softwareSkinnedMeshIndex = 0; softwareSkinnedMeshIndex < this._softwareSkinnedMeshes.length; softwareSkinnedMeshIndex++) {
@@ -3183,7 +3191,6 @@
             this._activeParticles.fetchNewFrame();
             this._renderDuration.fetchNewFrame();
             this._renderTargetsDuration.fetchNewFrame();
-            this._evaluateActiveMeshesDuration.fetchNewFrame();
             this._totalVertices.fetchNewFrame();
             this._activeIndices.fetchNewFrame();
             this._activeBones.fetchNewFrame();
@@ -3396,10 +3403,6 @@
             Tools.EndPerformanceCounter("Scene rendering");
             this._interFrameDuration.beginMonitoring();           
             this._lastFrameDuration.endMonitoring();
-            this._totalMeshesCounter.addCount(this.meshes.length, true);
-            this._totalLightsCounter.addCount(this.lights.length, true);
-            this._totalMaterialsCounter.addCount(this.materials.length, true);
-            this._totalTexturesCounter.addCount(this.textures.length, true);
             this._activeBones.addCount(0, true);
             this._activeIndices.addCount(0, true);
             this._activeParticles.addCount(0, true);