@eva/plugin-stats 1.3.0-alpha.0 → 2.0.0-beta.0

package/dist/plugin-stats.esm.js

@@ -76,6 +76,8 @@ var Stats = function (style) {
     var beginTime = (performance || Date).now(), prevTime = beginTime, frames = 0;
     var fpsPanel = addPanel(Stats.Panel('FPS', '#0ff', '#002'));
     var msPanel = addPanel(Stats.Panel('MS', '#0f0', '#020'));
+    var dcPanel = addPanel(Stats.Panel('DrawCall', '#330570', '#A69700'));
+    var tcPanel = addPanel(Stats.Panel('TC:', '#A62500', '#00B454'));
     var memPanel;
     if (self.performance && self.performance.memory) {
         memPanel = addPanel(Stats.Panel('MB', '#f08', '#201'));
@@ -89,10 +91,14 @@ var Stats = function (style) {
         begin: function (time) {
             beginTime = time || (performance || Date).now();
         },
-        end: function () {
+        end: function (hook) {
             frames++;
             var time = (performance || Date).now();
             msPanel.update(time - beginTime, 200);
+            if (hook) {
+                dcPanel.update(hook.deltaDrawCalls, Math.max(50, hook.maxDeltaDrawCalls));
+                tcPanel.update(hook.texturesCount, Math.max(20, hook.maxTextureCount));
+            }
             if (time >= prevTime + 1000) {
                 fpsPanel.update((frames * 1000) / (time - prevTime), 100);
                 prevTime = time;
@@ -151,6 +157,180 @@ Stats.Panel = function (name, fg, bg) {
 };
 var Stats$1 = Stats;
 
+var GLHook = (function () {
+    function GLHook(_gl) {
+        this.drawPasses = 0;
+        this.isInit = false;
+        this.realGLDrawElements = function () { };
+        if (_gl) {
+            if (_gl.__proto__.drawElements) {
+                this.gl = _gl;
+                this.realGLDrawElements = _gl.__proto__.drawElements;
+                _gl.__proto__.drawElements = this.fakeGLdrawElements(this);
+                this.isInit = true;
+            }
+        }
+        else {
+            console.error("[GLHook] GL can't be NULL");
+        }
+    }
+    GLHook.prototype.fakeGLdrawElements = function (context) {
+        return function (mode, count, type, offset) {
+            context.drawPasses++;
+            context.realGLDrawElements.call(this, mode, count, type, offset);
+        };
+    };
+    GLHook.prototype.reset = function () {
+        this.drawPasses = 0;
+    };
+    GLHook.prototype.release = function () {
+        if (this.isInit) {
+            this.gl.__proto__.drawElements = this.realGLDrawElements;
+        }
+        this.isInit = false;
+    };
+    return GLHook;
+}());
+
+var TextureHook = (function () {
+    function TextureHook(_gl) {
+        this.createdTextures = new Array();
+        this.maxTexturesCount = 0;
+        this.isInit = false;
+        this.realGLCreateTexture = function () { };
+        this.realGLDeleteTexture = function () { };
+        if (_gl) {
+            if (_gl.__proto__.createTexture) {
+                this.gl = _gl;
+                this.realGLCreateTexture = _gl.__proto__.createTexture;
+                this.realGLDeleteTexture = _gl.__proto__.deleteTexture;
+                _gl.__proto__.createTexture = this.fakeGLCreateTexture(this);
+                _gl.__proto__.deleteTexture = this.fakeGLDeleteTexture(this);
+                this.isInit = true;
+            }
+        }
+        else {
+            console.error("[TextureHook] GL can't be NULL");
+        }
+    }
+    Object.defineProperty(TextureHook.prototype, "currentTextureCount", {
+        get: function () {
+            return this.createdTextures.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TextureHook.prototype.registerTexture = function (texture) {
+        this.createdTextures.push(texture);
+        this.maxTexturesCount = Math.max(this.createdTextures.length, this.maxTexturesCount);
+    };
+    TextureHook.prototype.fakeGLCreateTexture = function (context) {
+        return function () {
+            var texture = context.realGLCreateTexture.call(this);
+            context.registerTexture(texture);
+            return texture;
+        };
+    };
+    TextureHook.prototype.fakeGLDeleteTexture = function (context) {
+        return function (texture) {
+            var index = context.createdTextures.indexOf(texture);
+            if (index > -1) {
+                context.createdTextures.splice(index, 1);
+            }
+            context.realGLDeleteTexture.call(this, texture);
+        };
+    };
+    TextureHook.prototype.reset = function () {
+        this.createdTextures = new Array();
+        this.maxTexturesCount = 0;
+    };
+    TextureHook.prototype.release = function () {
+        if (this.isInit) {
+            this.gl.__proto__.createTexture = this.realGLCreateTexture;
+            this.gl.__proto__.deleteTexture = this.realGLDeleteTexture;
+            console.log('[TextureHook] Hook was removed!');
+        }
+        this.isInit = false;
+    };
+    return TextureHook;
+}());
+
+var BaseHooks = (function () {
+    function BaseHooks() {
+        this._drawCalls = -1;
+        this._maxDeltaDrawCalls = -1;
+    }
+    BaseHooks.prototype.attach = function (gl) {
+        this.glhook = new GLHook(gl);
+        this.texturehook = new TextureHook(gl);
+    };
+    Object.defineProperty(BaseHooks.prototype, "drawCalls", {
+        get: function () {
+            if (this.glhook && this.glhook.isInit) {
+                return this.glhook.drawPasses;
+            }
+            return -1;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseHooks.prototype, "maxDeltaDrawCalls", {
+        get: function () {
+            return this._maxDeltaDrawCalls;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseHooks.prototype, "deltaDrawCalls", {
+        get: function () {
+            if (this._drawCalls == -1) {
+                this._drawCalls = this.drawCalls;
+                return 0;
+            }
+            var dc = this.drawCalls;
+            var delta = dc - this._drawCalls;
+            this._drawCalls = dc;
+            this._maxDeltaDrawCalls = Math.max(this._maxDeltaDrawCalls, delta);
+            return delta;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseHooks.prototype, "maxTextureCount", {
+        get: function () {
+            if (this.texturehook && this.texturehook.isInit)
+                return this.texturehook.maxTexturesCount;
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseHooks.prototype, "texturesCount", {
+        get: function () {
+            if (this.texturehook && this.texturehook.isInit)
+                return this.texturehook.currentTextureCount;
+            return 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseHooks.prototype.reset = function () {
+        this._maxDeltaDrawCalls = -1;
+        this._drawCalls = -1;
+        if (this.glhook)
+            this.glhook.reset();
+        if (this.texturehook)
+            this.texturehook.reset();
+    };
+    BaseHooks.prototype.release = function () {
+        if (this.glhook)
+            this.glhook.release();
+        if (this.texturehook)
+            this.texturehook.release();
+    };
+    return BaseHooks;
+}());
+
 var StatsSystem = (function (_super) {
     __extends(StatsSystem, _super);
     function StatsSystem() {
@@ -162,6 +342,13 @@ var StatsSystem = (function (_super) {
         if (param === void 0) { param = { show: true }; }
         this.show = param.show;
         this.style = param.style;
+        this.renderSystem = this.game.getSystem('Renderer');
+        this.app = this.renderSystem.application;
+        if (this.app && this.show) {
+            var gl = this.app.renderer.gl;
+            this.hook = new BaseHooks();
+            this.hook.attach(gl);
+        }
     };
     StatsSystem.prototype.start = function () {
         if (!this.show)
@@ -175,7 +362,7 @@ var StatsSystem = (function (_super) {
     StatsSystem.prototype.lateUpdate = function () {
         if (!this.show)
             return;
-        this.stats && this.stats.end();
+        this.stats && this.stats.end(this.hook);
     };
     StatsSystem.systemName = 'Stats';
     return StatsSystem;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eva/plugin-stats",
-  "version": "1.3.0-alpha.0",
+  "version": "2.0.0-beta.0",
   "description": "@eva/plugin-stats",
   "main": "index.js",
   "module": "dist/plugin-stats.esm.js",
@@ -18,7 +18,7 @@
   "license": "MIT",
   "homepage": "https://eva.js.org",
   "dependencies": {
-    "@eva/eva.js": "1.3.0-alpha.0",
+    "@eva/eva.js": "2.0.0-beta.0",
     "lodash-es": "^4.17.21"
   }
 }

package/dist/plugin-stats.d.ts

@@ -1,37 +0,0 @@
-import { Component } from '@eva/eva.js';
-import { System } from '@eva/eva.js';
-
-declare const _default: {
-    Components: (typeof Stats)[];
-    Systems: (typeof StatsSystem)[];
-};
-export default _default;
-
-export declare class Stats extends Component {
-    static componentName: string;
-    stats: any;
-    update(): void;
-}
-
-declare interface StatsParams {
-    show?: boolean;
-    style?: {
-        width: number;
-        height: number;
-        x: number;
-        y: number;
-    };
-}
-
-export declare class StatsSystem extends System {
-    static systemName: string;
-    show: boolean;
-    stats: any;
-    style: any;
-    component: Stats;
-    init(param?: StatsParams): void;
-    start(): void;
-    lateUpdate(): void;
-}
-
-export { }