1681-engine 0.0.0-stage → 0.5.9

package/dist/debug/DebugOverlay.js

@@ -0,0 +1,93 @@
+import { Container as c, Sprite as d, Texture as f, Graphics as p, Text as w } from "pixi.js";
+import { DrawCallCounter as x } from "./DrawCallCounter.js";
+import { ErrorLog as m } from "./ErrorLog.js";
+import { FrameStats as u } from "./FrameStats.js";
+import { inspectWorld as g } from "./inspectWorld.js";
+const h = 180, o = 40, y = 250;
+class F {
+  constructor(t, s = {}) {
+    this.engine = t, this.options = s, this.errors = new m(s.errors ?? 8), this.draws = new x(t.app.renderer), this.back.tint = 0, this.back.alpha = 0.7, this.graph.position.set(6, 6), this.text.position.set(6, o + 12), this.panel.addChild(this.back, this.graph, this.text), this.boxLayer.addChild(this.boxes), this.cleanup.push(t.events.on("error", ({ where: n, error: a }) => this.errors.add(n, a)));
+    const e = s.target ?? window, i = s.key ?? "Backquote", r = (n) => {
+      const a = n;
+      a.code === i && (a.preventDefault(), a.repeat || this.toggle());
+    };
+    e.addEventListener("keydown", r), this.cleanup.push(() => e.removeEventListener("keydown", r));
+  }
+  engine;
+  options;
+  errors;
+  stats = new u(h / 2);
+  panel = new c();
+  back = new d(f.WHITE);
+  graph = new p();
+  text = new w({ text: "", style: { fontFamily: "monospace", fontSize: 11, fill: 15263976, lineHeight: 13 } });
+  boxes = new p();
+  boxLayer = new c();
+  draws;
+  cleanup = [];
+  offFrame = null;
+  lastText = -1 / 0;
+  drawCalls = 0;
+  shown = !1;
+  drawBox = (t, s, e, i, r = 4259680) => {
+    this.boxes.rect(t, s, e, i).stroke({ width: 1, color: r, alpha: 0.9, pixelLine: !0 });
+  };
+  drawLine = (t, s, e, i, r = 4259680) => {
+    this.boxes.moveTo(t, s).lineTo(e, i).stroke({ width: 1, color: r, alpha: 0.9, pixelLine: !0 });
+  };
+  get visible() {
+    return this.shown;
+  }
+  toggle() {
+    this.shown ? this.hide() : this.show();
+  }
+  show() {
+    if (this.shown) return;
+    this.shown = !0;
+    const t = this.engine.stage;
+    t.screen.addChild(this.boxLayer, this.panel), t.cameras.main.follow(this.boxLayer), this.draws.install(), this.draws.take(), this.stats.clear(), this.lastText = -1 / 0, this.offFrame = this.engine.events.on("frame", ({ now: s, dt: e }) => this.frame(s, e));
+  }
+  hide() {
+    this.shown && (this.shown = !1, this.offFrame?.(), this.offFrame = null, this.draws.uninstall(), this.engine.stage.cameras.main.unfollow(this.boxLayer), this.panel.removeFromParent(), this.boxLayer.removeFromParent(), this.boxes.clear());
+  }
+  destroy() {
+    this.hide();
+    for (const t of this.cleanup.splice(0)) t();
+    this.panel.destroy({ children: !0 }), this.boxLayer.destroy({ children: !0 });
+  }
+  frame(t, s) {
+    this.stats.push(s * 1e3), this.drawCalls = this.draws.take(), this.paintGraph(), this.boxes.clear(), this.options.colliders && this.options.colliders(this.drawBox, this.drawLine), t - this.lastText >= y && (this.lastText = t, this.paintText());
+  }
+  paintGraph() {
+    const t = this.graph.clear();
+    t.rect(0, 0, h, o).fill({ color: 2105376 });
+    for (const e of [1e3 / 60, 1e3 / 30]) t.rect(0, o - e / 50 * o, h, 1).fill({ color: 5263440 });
+    const s = this.stats.count;
+    for (let e = 0; e < s; e++) {
+      const i = this.stats.at(e), r = Math.max(1, Math.min(o, Math.round(i / 50 * o))), n = i > 1e3 / 30 ? 16732240 : i > 1e3 / 55 ? 16760896 : 6348912;
+      t.rect(e * 2, o - r, 2, r).fill({ color: n });
+    }
+  }
+  paintText() {
+    const t = this.engine.app.renderer, s = this.options.world ? this.options.world() : this.engine.scene?.world, e = [
+      `${this.stats.fps.toFixed(0)} fps  avg ${this.stats.average.toFixed(1)} ms  max ${this.stats.max.toFixed(1)} ms`,
+      `draw calls ${this.draws.supported ? this.drawCalls : "n/a"}  textures ${b(t)}`,
+      `entities ${s ? s.size : "-"}  scene ${this.engine.scene?.constructor.name ?? "-"}`
+    ];
+    if (s)
+      for (const i of g(s, this.options.components, this.options.inspectLimit ?? 12)) e.push(`#${i.entity} ${i.components.join(" | ")}`);
+    if (this.errors.entries.length) {
+      e.push("errors:");
+      for (const i of this.errors.entries) e.push(`${i.count > 1 ? `${i.count}x ` : ""}${i.where}: ${i.message}`.slice(0, 120));
+    }
+    this.text.text = e.join(`
+`), this.back.width = Math.max(h + 12, Math.ceil(this.text.width) + 12), this.back.height = Math.ceil(this.text.y + this.text.height + 6);
+  }
+}
+function b(l) {
+  const t = l.texture.managedTextures;
+  return t ? t.length : "n/a";
+}
+export {
+  F as DebugOverlay
+};

package/dist/debug/DrawCallCounter.js

@@ -0,0 +1,44 @@
+const u = ["drawElements", "drawArrays", "drawElementsInstanced", "drawArraysInstanced", "drawRangeElements"];
+class f {
+  constructor(r) {
+    this.renderer = r;
+  }
+  renderer;
+  /** Draw calls since the last `take`. */
+  calls = 0;
+  restore = null;
+  /** Whether this renderer can be counted (WebGL). */
+  get supported() {
+    return c(this.renderer) !== null;
+  }
+  install() {
+    const r = c(this.renderer);
+    if (!r || this.restore) return;
+    const n = r, o = [];
+    let a = !0;
+    for (const t of u) {
+      const e = n[t];
+      if (typeof e != "function") continue;
+      const s = (...i) => (a && this.calls++, e.apply(r, i));
+      o.push([t, e, s]), n[t] = s;
+    }
+    this.restore = () => {
+      a = !1;
+      for (const [t, e, s] of o) n[t] === s && (n[t] = e);
+    };
+  }
+  uninstall() {
+    this.restore?.(), this.restore = null;
+  }
+  /** Draw calls since the last call, and starts counting again. */
+  take() {
+    const r = this.calls;
+    return this.calls = 0, r;
+  }
+}
+function c(l) {
+  return l.gl ?? null;
+}
+export {
+  f as DrawCallCounter
+};

package/dist/debug/ErrorLog.js

@@ -0,0 +1,21 @@
+class h {
+  constructor(s = 10) {
+    this.limit = s;
+  }
+  limit;
+  entries = [];
+  add(s, e, i = Date.now()) {
+    const n = e instanceof Error ? e.message : String(e), t = this.entries[this.entries.length - 1];
+    if (t && t.where === s && t.message === n) {
+      t.count++, t.at = i;
+      return;
+    }
+    this.entries.push({ where: s, message: n, count: 1, at: i }), this.entries.length > this.limit && this.entries.shift();
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+}
+export {
+  h as ErrorLog
+};

package/dist/debug/FrameStats.js

@@ -0,0 +1,41 @@
+class s {
+  constructor(t = 120) {
+    this.size = t, this.times = new Float32Array(t);
+  }
+  size;
+  times;
+  head = 0;
+  filled = 0;
+  /** Records one frame's length in ms. */
+  push(t) {
+    this.times[this.head] = t, this.head = (this.head + 1) % this.size, this.filled < this.size && this.filled++;
+  }
+  get count() {
+    return this.filled;
+  }
+  /** The `i`-th frame, oldest first. */
+  at(t) {
+    return this.times[(this.head - this.filled + t + this.size) % this.size];
+  }
+  get average() {
+    if (this.filled === 0) return 0;
+    let t = 0;
+    for (let i = 0; i < this.filled; i++) t += this.times[i];
+    return t / this.filled;
+  }
+  get max() {
+    let t = 0;
+    for (let i = 0; i < this.filled; i++) this.times[i] > t && (t = this.times[i]);
+    return t;
+  }
+  get fps() {
+    const t = this.average;
+    return t > 0 ? 1e3 / t : 0;
+  }
+  clear() {
+    this.head = 0, this.filled = 0;
+  }
+}
+export {
+  s as FrameStats
+};

package/dist/debug/inspectWorld.js

@@ -0,0 +1,28 @@
+function p(t, r, s = 20, n = 40) {
+  if (!r?.length)
+    return t.entities().slice(0, s).map((e) => ({ entity: e, components: t.componentsOf(e).map((i) => f(i, t.get(e, i), n)) }));
+  const o = /* @__PURE__ */ new Map();
+  for (const e of r)
+    t.each(e, (i, u) => {
+      let c = o.get(i);
+      if (!c) {
+        if (o.size >= s) return;
+        c = { entity: i, components: [] }, o.set(i, c);
+      }
+      c.components.push(f(e, u, n));
+    });
+  return [...o.values()].sort((e, i) => e.entity - i.entity);
+}
+function f(t, r, s) {
+  if ("fields" in t) return t.name;
+  let n;
+  try {
+    n = typeof r == "object" && r !== null ? JSON.stringify(r) : String(r);
+  } catch {
+    n = "[unprintable]";
+  }
+  return n === void 0 ? t.name : `${t.name} ${n.length > s ? n.slice(0, s - 1) + "…" : n}`;
+}
+export {
+  p as inspectWorld
+};

package/dist/diagnostics/ErrorDeduper.js

@@ -0,0 +1,26 @@
+class n {
+  constructor(t = 10, e = 120) {
+    this.max = t, this.keyLength = e;
+  }
+  max;
+  keyLength;
+  seen = /* @__PURE__ */ new Set();
+  /** The key to report under, or null when this error was already let through or the allowance is spent. */
+  admit(t) {
+    const e = t.slice(0, this.keyLength);
+    return this.seen.has(e) || this.seen.size >= this.max ? null : (this.seen.add(e), e);
+  }
+  /** Forgets what was let through (a new session). */
+  reset() {
+    this.seen.clear();
+  }
+}
+function i(s, t = 4, e = 600) {
+  return (s ?? "").split(`
+`).slice(0, t).join(`
+`).slice(0, e);
+}
+export {
+  n as ErrorDeduper,
+  i as trimStack
+};

package/dist/diagnostics/FrameSampler.js

@@ -0,0 +1,41 @@
+import { UPDATE_PRIORITY as h } from "pixi.js";
+import { summarizeFrames as r, looksThrottled as o } from "./frameStats.js";
+class c {
+  constructor(t, s = {}) {
+    this.onSample = t, this.opts = {
+      windowMs: s.windowMs ?? 6e4,
+      hitchMs: s.hitchMs ?? 50,
+      minFrames: s.minFrames ?? 30,
+      throttledMedianMs: s.throttledMedianMs ?? 500
+    }, this.paused = s.paused ?? (() => typeof document < "u" && document.hidden), this.now = s.now ?? (() => performance.now()), this.since = this.now();
+  }
+  onSample;
+  frames = [];
+  since;
+  opts;
+  paused;
+  now;
+  /** One frame of `deltaMs`; sums the window once it is full. */
+  push(t) {
+    if (this.paused()) return;
+    this.frames.push(t);
+    const s = this.now(), e = s - this.since;
+    if (e < this.opts.windowMs) return;
+    const i = this.frames;
+    if (this.frames = [], this.since = s, i.length < this.opts.minFrames) return;
+    const n = r(i, e, this.opts.hitchMs);
+    o(n, this.opts.throttledMedianMs) || this.onSample(n);
+  }
+  /** Starts a fresh window, dropping what was counted (after a scene change, say). */
+  reset() {
+    this.frames = [], this.since = this.now();
+  }
+  /** Feeds the sampler from a Pixi ticker, after the render; returns the detach. */
+  attach(t) {
+    const s = () => this.push(t.deltaMS);
+    return t.add(s, void 0, h.UTILITY), () => t.remove(s);
+  }
+}
+export {
+  c as FrameSampler
+};

package/dist/diagnostics/bootWatch.js

@@ -0,0 +1,20 @@
+function c(o, i, n = () => performance.now()) {
+  const a = n(), t = [{ name: "init", atMs: 0 }];
+  let s = !1;
+  const r = setTimeout(() => {
+    if (s) return;
+    const e = t[t.length - 1].name;
+    i({ step: e, steps: t.slice(), detail: `stuck: ${e}` });
+  }, o);
+  return {
+    step(e) {
+      s || t.push({ name: e, atMs: Math.round(n() - a) });
+    },
+    done() {
+      s = !0, clearTimeout(r);
+    }
+  };
+}
+export {
+  c as bootWatch
+};

package/dist/diagnostics/captureErrors.js

@@ -0,0 +1,26 @@
+import { Stage as r } from "../core/Stage.js";
+import { ErrorDeduper as l, trimStack as v } from "./ErrorDeduper.js";
+function k(m, t = {}) {
+  const g = t.deduper ?? new l(t.max ?? 10), a = (e, n, s) => {
+    const u = g.admit(e);
+    u !== null && m({ message: u, stack: v(n), source: s });
+  }, i = (e) => a(e.message || String(e.error), e.error?.stack, "uncaught"), c = (e) => {
+    const n = e.reason;
+    a(n?.message ?? String(e.reason), n?.stack, "rejection");
+  }, f = (e, n) => {
+    const s = n;
+    a(`${e}: ${s?.message ?? String(n)}`, s?.stack, "frame");
+  }, o = typeof window < "u" ? window : void 0;
+  o?.addEventListener("error", i), o?.addEventListener("unhandledrejection", c);
+  const d = r.onCaught;
+  t.frames !== !1 && (r.onCaught = (e, n) => {
+    d?.(e, n), f(e, n);
+  });
+  const h = r.onCaught;
+  return () => {
+    o?.removeEventListener("error", i), o?.removeEventListener("unhandledrejection", c), t.frames !== !1 && r.onCaught === h && (r.onCaught = d);
+  };
+}
+export {
+  k as captureErrors
+};

package/dist/diagnostics/contextLoss.js

@@ -0,0 +1,24 @@
+function u(e, s, t = !1, d = {}) {
+  const { maxLosses: c = 3, windowMs: r = 12e4 } = d, o = e.filter((l) => s - l < r), n = t ? o : o.concat(s);
+  return { losses: n, giveUp: n.length > c, delayMs: f(n.length) };
+}
+function f(e) {
+  return e <= 1 ? 250 : e === 2 ? 2e3 : 5e3;
+}
+function w(e, s, t = {}) {
+  const d = t.now ?? (() => performance.now()), c = t.hidden ?? (() => typeof document < "u" && document.hidden);
+  let r = [];
+  const o = (l) => {
+    l.preventDefault();
+    const i = u(r, d(), c(), t);
+    r = i.losses, s(i);
+  }, n = () => t.onRestored?.();
+  return e.addEventListener("webglcontextlost", o), e.addEventListener("webglcontextrestored", n), () => {
+    e.removeEventListener("webglcontextlost", o), e.removeEventListener("webglcontextrestored", n);
+  };
+}
+export {
+  u as noteContextLoss,
+  f as rebuildDelayMs,
+  w as watchContextLoss
+};

package/dist/diagnostics/frameStats.js

@@ -0,0 +1,30 @@
+function h(t, n) {
+  return t.length === 0 ? 0 : t[Math.min(t.length - 1, Math.max(0, Math.floor(t.length * n)))];
+}
+function f(t, n) {
+  let o = 0;
+  for (const e of t) e > n && o++;
+  return o;
+}
+const r = (t) => Math.round(t * 10) / 10;
+function a(t, n, o = 50) {
+  const e = [...t].sort((i, u) => i - u);
+  return {
+    frames: t.length,
+    fps: n > 0 ? r(t.length * 1e3 / n) : 0,
+    fpsLow: r(1e3 / Math.max(1, h(e, 0.99))),
+    frameP95: r(h(e, 0.95)),
+    frameMedian: r(h(e, 0.5)),
+    worstMs: r(e[e.length - 1] ?? 0),
+    hitches: f(t, o)
+  };
+}
+function c(t, n = 500) {
+  return t.frameMedian > n;
+}
+export {
+  f as countHitches,
+  c as looksThrottled,
+  h as percentile,
+  a as summarizeFrames
+};

package/dist/diagnostics/gpuInfo.js

@@ -0,0 +1,21 @@
+function u(n) {
+  return n.gl;
+}
+function l(n) {
+  const t = u(n);
+  if (!t) return null;
+  const e = Number(t.getParameter(t.MAX_TEXTURE_SIZE));
+  return Number.isFinite(e) && e > 0 ? e : null;
+}
+function i(n, t = 80) {
+  try {
+    const e = u(n), r = e?.getExtension("WEBGL_debug_renderer_info");
+    return e && r ? String(e.getParameter(r.UNMASKED_RENDERER_WEBGL)).slice(0, t) : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  i as gpuName,
+  l as maxTextureSize
+};

package/dist/diagnostics/renderGuard.js

@@ -0,0 +1,23 @@
+import { UPDATE_PRIORITY as c } from "pixi.js";
+function f(e, t = 160) {
+  const r = e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+  return r.length > t ? `${r.slice(0, t)}…` : r;
+}
+function l(e, t, r = 30) {
+  e.ticker.remove(e.render, e);
+  let n = 0, d = !1;
+  const i = () => {
+    try {
+      e.render(), n = 0;
+    } catch (o) {
+      n++, n === 1 && console.error("[render] frame failed", o), n >= r && !d && (d = !0, t(`render: ${f(o)}`, o));
+    }
+  };
+  return e.ticker.add(i, void 0, c.LOW), () => {
+    e.ticker.remove(i), e.ticker.add(e.render, e, c.LOW);
+  };
+}
+export {
+  f as describeError,
+  l as guardRender
+};

package/dist/ecs/SparseSet.js

@@ -0,0 +1,54 @@
+class n {
+  sparse = new Int32Array(64).fill(-1);
+  /** Packed entity ids, in the same order as `values`. */
+  entities = [];
+  values = [];
+  /** Bumped whenever an entity joins or leaves the set (not when a value changes): query caches key on it. */
+  version = 0;
+  get size() {
+    return this.entities.length;
+  }
+  has(s) {
+    return s < this.sparse.length && this.sparse[s] >= 0;
+  }
+  /** The value at slot `index`, or undefined. */
+  get(s) {
+    if (s >= this.sparse.length) return;
+    const t = this.sparse[s];
+    return t >= 0 ? this.values[t] : void 0;
+  }
+  set(s, t, e) {
+    this.grow(s);
+    const i = this.sparse[s];
+    if (i >= 0) {
+      this.values[i] = e, this.entities[i] = t;
+      return;
+    }
+    this.sparse[s] = this.entities.length, this.version++, this.entities.push(t), this.values.push(e);
+  }
+  /** Removes slot `index`; true if it was there. */
+  delete(s, t) {
+    if (s >= this.sparse.length) return !1;
+    const e = this.sparse[s];
+    if (e < 0) return !1;
+    const i = this.entities.length - 1;
+    if (e !== i) {
+      const h = this.entities[i];
+      this.entities[e] = h, this.values[e] = this.values[i], this.sparse[t(h)] = e;
+    }
+    return this.entities.pop(), this.values.pop(), this.sparse[s] = -1, this.version++, !0;
+  }
+  clear() {
+    this.version++, this.sparse.fill(-1), this.entities.length = 0, this.values.length = 0;
+  }
+  grow(s) {
+    if (s < this.sparse.length) return;
+    let t = this.sparse.length;
+    for (; t <= s; ) t *= 2;
+    const e = new Int32Array(t).fill(-1);
+    e.set(this.sparse), this.sparse = e;
+  }
+}
+export {
+  n as SparseSet
+};