minerender 2.1.0-alpha.51 → 2.1.0-alpha.52

package/dist/bundle.js

@@ -86781,7 +86781,7 @@ property list uchar int vertex_index
     }
     init() {
       this.statsContainer.classList.add("minerender-stats");
-      setInterval(() => {
+      this.interval = setInterval(() => {
         for (let line of this.lines) {
           line.update();
         }
@@ -86790,6 +86790,13 @@ property list uchar int vertex_index
     appendTo(el) {
       el.append(this.statsContainer);
     }
+    dispose() {
+      clearInterval(this.interval);
+      this.interval = void 0;
+      this.lines.length = 0;
+      this.statsContainer.replaceChildren();
+      this.statsContainer.remove();
+    }
     add(line) {
       if (typeof line !== "undefined") {
         this.lines.push(line);
@@ -92921,7 +92928,10 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
     constructor(options) {
       this._dirty = true;
       this._resizeListener = void 0;
+      this._running = false;
+      this._inAnimationLoop = false;
       this._disposed = false;
+      this._frameCallbacks = /* @__PURE__ */ new Map();
       this._debugHelpers = [];
       this._eventDispatchers = /* @__PURE__ */ new Map();
       this._changeListener = () => {
@@ -92932,7 +92942,14 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       if (!Number.isFinite(pixelRatio) || pixelRatio <= 0) {
         throw new RangeError("render.pixelRatio must be a finite positive number");
       }
-      this._animationLoop = this.animate.bind(this);
+      this._animationLoop = (time) => {
+        this._inAnimationLoop = true;
+        try {
+          this.animate(time);
+        } finally {
+          this._inAnimationLoop = false;
+        }
+      };
       this._frameInterval = this.options.render.fpsLimit > 0 ? 1e3 / this.options.render.fpsLimit : void 0;
       this._scene = this.createScene();
       this._camera = this.createCamera();
@@ -93107,15 +93124,39 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       this._dirty = dirty;
       this.scene.dirty = dirty;
     }
+    /**
+     * Calls a synchronous animation update before each FPS-limited draw while started.
+     * Subscriptions keep the scene drawing without manual dirty flags. Returns an unsubscribe function.
+     * Registering the same callback twice has no effect. Image exports do not invoke callbacks.
+     */
+    onFrame(callback) {
+      if (this._disposed) return () => {
+      };
+      const subscription = this._frameCallbacks.get(callback) ?? {};
+      this._frameCallbacks.set(callback, subscription);
+      return () => {
+        if (this._frameCallbacks.get(callback) === subscription) this._frameCallbacks.delete(callback);
+      };
+    }
     start() {
       if (this._disposed) return;
       this.stop();
-      this.renderer.setAnimationLoop(this._animationLoop);
+      this._running = true;
+      if (!this._inAnimationLoop) this.renderer.setAnimationLoop(this._animationLoop);
     }
     stop() {
       if (this._disposed) return;
-      this.renderer.setAnimationLoop(null);
+      this._running = false;
+      if (this._inAnimationLoop) {
+        queueMicrotask(() => {
+          this.renderer.setAnimationLoop(null);
+          if (this._running) this.renderer.setAnimationLoop(this._animationLoop);
+        });
+      } else {
+        this.renderer.setAnimationLoop(null);
+      }
       this._nextFrameTime = void 0;
+      for (const subscription of this._frameCallbacks.values()) subscription.previous = void 0;
     }
     /**
      * Stops rendering and releases owned resources. Repeated calls have no effect, and a disposed
@@ -93126,6 +93167,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       if (this._disposed) return;
       this.stop();
       this._disposed = true;
+      this._frameCallbacks.clear();
       if (this._resizeListener) {
         window.removeEventListener("resize", this._resizeListener);
         this._resizeListener = void 0;
@@ -93160,18 +93202,25 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       this.renderer.forceContextLoss();
     }
     animate(t5 = performance.now()) {
-      if (this._disposed) return;
+      if (!this._running) return;
       if (this._controls?.enabled) {
         this._controls.update();
       }
-      if (this._disposed) return;
-      if (!this.dirty && !this.options.render.renderAlways) return;
+      if (!this._running) return;
+      if (!this.dirty && !this.options.render.renderAlways && !this._frameCallbacks.size) return;
       const interval = this._frameInterval;
       if (interval) {
         const next = this._nextFrameTime;
         if (next !== void 0 && t5 + 0.1 < next) return;
         this._nextFrameTime = next !== void 0 && t5 - next < interval ? next + interval : t5 + interval;
       }
+      for (const [callback, subscription] of [...this._frameCallbacks]) {
+        if (this._frameCallbacks.get(callback) !== subscription) continue;
+        const previous = subscription.previous;
+        subscription.previous = t5;
+        callback({ time: t5 / 1e3, delta: previous === void 0 ? 0 : (t5 - previous) / 1e3 });
+        if (!this._running) return;
+      }
       this.drawFrame();
     }
     drawFrame() {