entangled-worlds-orbiters-shared 3.0.0 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entangled-worlds-orbiters-shared",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Shared library for entangled worlds orbiters - contains core world rendering, moons system, and UI components",
   "type": "module",
   "main": "src/index.js",

package/src/render/viewportCompositor.js

@@ -158,6 +158,10 @@ export function createViewportCompositor({
   let grid = null;
   let raf = null;
   let disposed = false;
+  // A load meter's watch on the realm's frames (`setFrameProbe`): null when nobody is watching.
+  let frameProbe = null;
+  let frameProbeAt = 0;
+  let probePixel = null;
   let lastCanvasW = 0;
   let lastCanvasH = 0;
   let viewportH = 0; // per-cell cull band (CSS px), refreshed with the rects
@@ -514,7 +518,60 @@ export function createViewportCompositor({
     // at half the realm's rate. Skipping the whole frame instead leaves every cell showing the last
     // frame that was drawn — together, which is the only way a shared canvas can be consistent.
     if (performanceOn && !frameBudget.shouldRender(nowMs)) return;
-    renderOnce();
+    if (!frameProbe) {
+      renderOnce();
+      return;
+    }
+    const probe = frameProbe;
+    probe.onFrame?.(nowMs);
+    const timed = nowMs - frameProbeAt >= probe.everyMs;
+    if (!timed) {
+      renderOnce();
+      return;
+    }
+    frameProbeAt = nowMs;
+    // Every cell's draw counted together: one composited frame is several renders.
+    const info = renderer.info;
+    const autoReset = info.autoReset;
+    info.autoReset = false;
+    info.reset();
+    try {
+      const started = performance.now();
+      renderOnce();
+      // A lost context draws nothing and answers nothing: no reading, not a good one.
+      if (waitForDraw()) {
+        const drawn = performance.now();
+        // Asked again with nothing left to draw: what the asking itself costs, taken off the reading.
+        waitForDraw();
+        probe.onDraw(Math.max(0, drawn - started - (performance.now() - drawn)), info.render.calls, info.render.triangles);
+      }
+    } finally {
+      // Put back as it was, even when a voice throws mid-frame.
+      info.autoReset = autoReset;
+    }
+  }
+
+  /** Block until the graphics chip has drawn what was sent: reading a pixel back is the one wait every
+   *  browser honours. False when there is no context to ask. */
+  function waitForDraw() {
+    const gl = renderer.getContext?.();
+    if (!gl || gl.isContextLost()) return false;
+    probePixel ??= new Uint8Array(4);
+    gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, probePixel);
+    return true;
+  }
+
+  /**
+   * Watch the realm's frames, for a load meter: `onFrame(nowMs)` for every frame drawn, and one frame
+   * every `everyMs` timed to the end of its drawing (`onDraw(workMs, calls, triangles)`, every cell
+   * together). Only the timed frame waits for the graphics chip; every other frame is untouched.
+   * `null` stops it.
+   *
+   * @param {{ everyMs: number, onFrame?: (nowMs: number) => void, onDraw: (workMs: number, calls: number, triangles: number) => void } | null} probe
+   */
+  function setFrameProbe(probe) {
+    frameProbe = probe ?? null;
+    frameProbeAt = 0;
   }
 
   /**
@@ -572,6 +629,7 @@ export function createViewportCompositor({
     removeVoice,
     renderOnce,
     setPerformanceMode,
+    setFrameProbe,
     dispose,
   };
   // Dev handle: lets tooling force a composited frame when rAF is throttled (e.g. a hidden/background