@gg-web-engine/core 0.0.39 → 0.0.48

package/dist/dev/performance-meter.entity.js

@@ -0,0 +1,120 @@
+import { IEntity } from '../base';
+import { takeUntil } from 'rxjs';
+export class PerformanceMeterEntity extends IEntity {
+    get avgReport() {
+        return this._avgReport;
+    }
+    get peakReport() {
+        return this._peakReport;
+    }
+    constructor(maxSamples = 60, maxRows = 15) {
+        super();
+        this.maxSamples = maxSamples;
+        this.maxRows = maxRows;
+        this.tickOrder = Number.MAX_SAFE_INTEGER;
+        this.sampleIndex = 0;
+        this.collectedData = new Map();
+        this._avgReport = { totalTime: 0, entries: [] };
+        this._peakReport = { totalTime: 0, entries: [] };
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.sampleIndex = 0;
+        const now = () => (typeof performance === 'undefined' ? Date : performance).now();
+        this.world.tickForwardTo$.pipe(takeUntil(this.onRemoved$)).subscribe(e => {
+            if (e === this)
+                return;
+            if (!this.collectedData.has(e)) {
+                this.collectedData.set(e, [[this.sampleIndex, now(), 0]]);
+            }
+            else {
+                this.collectedData.get(e).push([this.sampleIndex, now(), 0]);
+            }
+        });
+        this.world.tickForwardedTo$.pipe(takeUntil(this.onRemoved$)).subscribe(e => {
+            if (e === this)
+                return;
+            const report = this.collectedData.get(e);
+            report[report.length - 1][2] = now();
+        });
+        this.tick$.pipe(takeUntil(this.onRemoved$)).subscribe(() => {
+            this.sampleIndex++;
+            // remove oldest samples
+            const entries = Array.from(this.collectedData.entries());
+            for (const [k, v] of entries) {
+                while (v.length > 0 && v[0][0] < this.sampleIndex - this.maxSamples) {
+                    v.shift();
+                }
+                if (v.length === 0) {
+                    this.collectedData.delete(k);
+                }
+            }
+            // helper functions
+            const label = (e) => {
+                if (e instanceof IEntity) {
+                    if (e.name === '') {
+                        return e.constructor.name;
+                    }
+                    else {
+                        return e.name;
+                    }
+                }
+                else if (e === 'PHYSICS_WORLD') {
+                    return 'Physics simulation';
+                }
+                else {
+                    return e;
+                }
+            };
+            const truncateReport = (report) => {
+                let restSum = 0;
+                let restAmount = 0;
+                for (restAmount; restAmount < report.length - 2; restAmount++) {
+                    if (this.maxRows > report.length - restAmount + 1) {
+                        restAmount--;
+                        break;
+                    }
+                    restSum += report[report.length - restAmount - 1][1];
+                }
+                if (restAmount > 1) {
+                    report = report.slice(0, report.length - restAmount);
+                    report.push([`Rest (${restAmount})`, restSum]);
+                }
+                return report;
+            };
+            // build avg report
+            let totalTimeAvg = 0;
+            let avgReport = Array.from(this.collectedData.entries())
+                .map(([e, samples]) => {
+                const timeSpentAvg = samples.reduce((prev, [_, start, finish]) => prev + finish - start, 0) / this.maxSamples;
+                totalTimeAvg += timeSpentAvg;
+                return [label(e), timeSpentAvg];
+            })
+                .sort((a, b) => b[1] - a[1]);
+            avgReport = truncateReport(avgReport);
+            this._avgReport = { totalTime: totalTimeAvg, entries: avgReport };
+            // build peak report
+            let totalTimePeaks = new Map();
+            let peakReport = Array.from(this.collectedData.entries())
+                .map(([e, samples]) => {
+                let peakTime = 0;
+                for (const [sample, start, finish] of samples) {
+                    const time = finish - start;
+                    peakTime = Math.max(peakTime, time);
+                    totalTimePeaks.set(sample, time + (totalTimePeaks.get(sample) || 0));
+                }
+                return [label(e), peakTime];
+            })
+                .sort((a, b) => b[1] - a[1]);
+            peakReport = truncateReport(peakReport);
+            let totalPeak = Array.from(totalTimePeaks.values()).reduce((prev, cur) => Math.max(prev, cur), 0);
+            this._peakReport = { totalTime: totalPeak, entries: peakReport };
+        });
+    }
+    onRemoved() {
+        super.onRemoved();
+        this.collectedData = new Map();
+        this._avgReport = { totalTime: 0, entries: [] };
+        this._peakReport = { totalTime: 0, entries: [] };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/core",
-  "version": "0.0.39",
+  "version": "0.0.48",
   "description": "An attempt to create open source game engine for browser",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,12 +32,12 @@
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
-    "@types/stats.js": "^0.17.0",
-    "jest": "^29.5.0",
-    "jest-environment-jsdom": "^29.5.0",
-    "prettier": "^2.8.6",
-    "ts-jest": "^29.0.5",
-    "typescript": "~4.7.2"
+    "@types/stats.js": "^0.17.3",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.4",
+    "typescript": "~5.5.4"
   },
   "jest": {
     "moduleFileExtensions": [