@eva/plugin-stats 1.2.7-editor.9 → 1.2.8-alpha.0

package/dist/miniprogram.js

@@ -0,0 +1,395 @@
+import { __extends, __assign } from 'tslib';
+import { Component, System } from '@eva/eva.js/dist/miniprogram';
+import { documentAlias, performance, windowAlias } from '@eva/miniprogram-adapter';
+
+var StatsComponent = function (_super) {
+  __extends(StatsComponent, _super);
+
+  function StatsComponent() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+
+  StatsComponent.prototype.update = function () {
+    this.stats && this.stats.begin();
+  };
+
+  StatsComponent.componentName = 'Stats';
+  return StatsComponent;
+}(Component);
+
+var Stats$2 = StatsComponent;
+
+var Stats = function Stats(style) {
+  style = __assign({
+    width: 20,
+    height: 12,
+    x: 0,
+    y: 0
+  }, style);
+  var width = style.width,
+      height = style.height,
+      x = style.x,
+      y = style.y;
+  var mode = 0;
+  var container = documentAlias.createElement('div');
+  container.style.cssText = "position:fixed;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000;width: " + width + "vw;height: " + height + "vw;left: " + x + "vw;top: " + y + "vw;";
+  container.addEventListener('click', function (event) {
+    event.preventDefault();
+    showPanel(++mode % container.children.length);
+  }, false);
+
+  function addPanel(panel) {
+    container.appendChild(panel.dom);
+    return panel;
+  }
+
+  function showPanel(id) {
+    for (var i = 0; i < container.children.length; i++) {
+      container.children[i].style.display = i === id ? 'block' : 'none';
+    }
+
+    mode = id;
+  }
+
+  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'));
+  }
+
+  showPanel(0);
+  return {
+    REVISION: 16,
+    dom: container,
+    addPanel: addPanel,
+    showPanel: showPanel,
+    begin: function begin(time) {
+      beginTime = time || (performance || Date).now();
+    },
+    end: function end(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;
+        frames = 0;
+
+        if (memPanel) {
+          var memory = performance.memory;
+          memPanel.update(memory.usedJSHeapSize / 1048576, memory.jsHeapSizeLimit / 1048576);
+        }
+      }
+
+      return time;
+    },
+    update: function update() {
+      beginTime = this.end();
+    },
+    domElement: container,
+    setMode: showPanel
+  };
+};
+
+Stats.Panel = function (name, fg, bg) {
+  var min = Infinity,
+      max = 0;
+  var round = Math.round;
+  var PR = round(windowAlias.devicePixelRatio || 1);
+  var WIDTH = 80 * PR,
+      HEIGHT = 48 * PR,
+      TEXT_X = 3 * PR,
+      TEXT_Y = 2 * PR,
+      GRAPH_X = 3 * PR,
+      GRAPH_Y = 15 * PR,
+      GRAPH_WIDTH = 74 * PR,
+      GRAPH_HEIGHT = 30 * PR;
+  var canvas = documentAlias.createElement('canvas');
+  canvas.width = WIDTH;
+  canvas.height = HEIGHT;
+  canvas.style.cssText = 'width:100%;height:100%';
+  var context = canvas.getContext('2d');
+  context.font = 'bold ' + 9 * PR + 'px Helvetica,Arial,sans-serif';
+  context.textBaseline = 'top';
+  context.fillStyle = bg;
+  context.fillRect(0, 0, WIDTH, HEIGHT);
+  context.fillStyle = fg;
+  context.fillText(name, TEXT_X, TEXT_Y);
+  context.fillRect(GRAPH_X, GRAPH_Y, GRAPH_WIDTH, GRAPH_HEIGHT);
+  context.fillStyle = bg;
+  context.globalAlpha = 0.9;
+  context.fillRect(GRAPH_X, GRAPH_Y, GRAPH_WIDTH, GRAPH_HEIGHT);
+  return {
+    dom: canvas,
+    update: function update(value, maxValue) {
+      min = Math.min(min, value);
+      max = Math.max(max, value);
+      context.fillStyle = bg;
+      context.globalAlpha = 1;
+      context.fillRect(0, 0, WIDTH, GRAPH_Y);
+      context.fillStyle = fg;
+      context.fillText(round(value) + ' ' + name + ' (' + round(min) + '-' + round(max) + ')', TEXT_X, TEXT_Y);
+      context.drawImage(canvas, GRAPH_X + PR, GRAPH_Y, GRAPH_WIDTH - PR, GRAPH_HEIGHT, GRAPH_X, GRAPH_Y, GRAPH_WIDTH - PR, GRAPH_HEIGHT);
+      context.fillRect(GRAPH_X + GRAPH_WIDTH - PR, GRAPH_Y, PR, GRAPH_HEIGHT);
+      context.fillStyle = bg;
+      context.globalAlpha = 0.9;
+      context.fillRect(GRAPH_X + GRAPH_WIDTH - PR, GRAPH_Y, PR, round((1 - value / maxValue) * GRAPH_HEIGHT));
+    }
+  };
+};
+
+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.bind(this);
+        this.isInit = true;
+      }
+    } else {
+      console.error("[GLHook] GL can't be NULL");
+    }
+  }
+
+  GLHook.prototype.fakeGLdrawElements = function (mode, count, type, offset) {
+    this.drawPasses++;
+    this.realGLDrawElements.call(this.gl, 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.bind(this);
+        _gl.__proto__.deleteTexture = this.fakeGLDeleteTexture.bind(this);
+        this.isInit = true;
+      }
+    } else {
+      console.error("[TextureHook] GL can't be NULL");
+    }
+  }
+
+  Object.defineProperty(TextureHook.prototype, "currentTextureCount", {
+    get: function get() {
+      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 () {
+    var texture = this.realGLCreateTexture.call(this.gl);
+    this.registerTexture(texture);
+    return texture;
+  };
+
+  TextureHook.prototype.fakeGLDeleteTexture = function (texture) {
+    var index = this.createdTextures.indexOf(texture);
+
+    if (index > -1) {
+      this.createdTextures.splice(index, 1);
+    }
+
+    this.realGLDeleteTexture.call(this.gl, 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 get() {
+      if (this.glhook && this.glhook.isInit) {
+        return this.glhook.drawPasses;
+      }
+
+      return -1;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(BaseHooks.prototype, "maxDeltaDrawCalls", {
+    get: function get() {
+      return this._maxDeltaDrawCalls;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(BaseHooks.prototype, "deltaDrawCalls", {
+    get: function get() {
+      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 get() {
+      if (this.texturehook && this.texturehook.isInit) return this.texturehook.maxTexturesCount;
+      return 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(BaseHooks.prototype, "texturesCount", {
+    get: function get() {
+      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() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+
+    _this.show = true;
+    return _this;
+  }
+
+  StatsSystem.prototype.init = function (param) {
+    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) return;
+    this.component = this.game.scene.addComponent(new Stats$2());
+    this.stats = Stats$1(this.style);
+    this.component.stats = this.stats;
+    this.stats.showPanel(0);
+    documentAlias.body.appendChild(this.stats.dom);
+  };
+
+  StatsSystem.prototype.lateUpdate = function () {
+    if (!this.show) return;
+    this.stats && this.stats.end(this.hook);
+  };
+
+  StatsSystem.systemName = 'Stats';
+  return StatsSystem;
+}(System);
+
+var StatsSystem$1 = StatsSystem;
+var index = {
+  Components: [Stats$2],
+  Systems: [StatsSystem$1]
+};
+export { Stats$2 as Stats, StatsSystem$1 as StatsSystem, index as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eva/plugin-stats",
-  "version": "1.2.7-editor.9",
+  "version": "1.2.8-alpha.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.2.7-editor.9",
+    "@eva/eva.js": "1.2.8-alpha.0",
     "lodash-es": "^4.17.21"
   }
 }