minerender 2.1.0-alpha.85 → 2.1.0-alpha.86

package/dist/bundle.js

@@ -106580,6 +106580,7 @@ ${shader.fragmentShader}`.replace(
     Ticker: () => Ticker,
     TintColors: () => TintColors,
     UVMapper: () => UVMapper,
+    VideoExporter: () => VideoExporter,
     WrappedImage: () => WrappedImage,
     addBox3WireframeToObject: () => addBox3WireframeToObject,
     addWireframeToMesh: () => addWireframeToMesh,
@@ -110099,6 +110100,134 @@ property list uchar int vertex_index
     return new Texture().copy(copySource);
   }
 
+  // src/export/VideoExporter.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var VideoExporter = class {
+    constructor(source, options) {
+      this.source = source;
+      this.chunks = [];
+      this.settled = false;
+      this.stopping = false;
+      this.onStart = () => {
+        this.timer = setTimeout(() => {
+          this.stopping = true;
+          try {
+            this.recorder.stop();
+          } catch (error2) {
+            this.cancel(error2);
+          }
+        }, this.duration * 1e3);
+      };
+      this.onData = (event) => {
+        if (event.data.size) this.chunks.push(event.data);
+      };
+      this.onStop = () => {
+        if (!this.stopping) return this.cancel(new Error("Video recording stopped before its duration elapsed"));
+        if (!this.chunks.length) return this.cancel(new Error("The browser produced no video data"));
+        const mimeType = this.chunks.find((chunk) => chunk.type)?.type || this.recorder.mimeType;
+        const blob = new Blob(this.chunks, { type: mimeType });
+        this.settled = true;
+        this.cleanup();
+        this.resolve(blob);
+      };
+      this.onError = (event) => {
+        this.cancel(event.error ?? new Error("Video recording failed"));
+      };
+      this.onAbort = () => {
+        this.cancel(this.signal.reason);
+      };
+      this.onTrackEnded = () => {
+        this.cancel(new Error("The video capture stream stopped producing frames"));
+      };
+      const fps = options.fps ?? 30;
+      if (!Number.isFinite(options.duration) || options.duration <= 0 || options.duration * 1e3 > 2147483647) {
+        throw new RangeError("Video duration must be greater than zero and at most 2147483.647 seconds");
+      }
+      if (!Number.isFinite(fps) || fps <= 0) throw new RangeError("Video fps must be a finite positive number");
+      const bitrate = options.videoBitsPerSecond;
+      if (bitrate !== void 0 && (!Number.isInteger(bitrate) || bitrate <= 0 || bitrate > 4294967295)) {
+        throw new RangeError("Video bitrate must be a positive unsigned 32-bit integer");
+      }
+      if (!source.width || !source.height) throw new Error("Cannot export video from an empty canvas");
+      options.signal?.throwIfAborted();
+      if (typeof document === "undefined" || typeof MediaRecorder === "undefined" || typeof MediaRecorder.isTypeSupported !== "function") {
+        throw new Error("Video export requires a browser with MediaRecorder support");
+      }
+      const mimeTypes2 = options.mimeType === void 0 ? ["video/webm;codecs=vp9", "video/webm;codecs=vp8", "video/webm", "video/mp4"] : [options.mimeType];
+      const mimeType = mimeTypes2.find((type) => type.startsWith("video/") && MediaRecorder.isTypeSupported(type));
+      if (!mimeType) throw new Error("The browser does not support the requested video format");
+      this.canvas = document.createElement("canvas");
+      this.canvas.width = source.width;
+      this.canvas.height = source.height;
+      if (typeof this.canvas.captureStream !== "function") throw new Error("Video export requires canvas captureStream support");
+      const context = this.canvas.getContext("2d", { alpha: false });
+      if (!context) throw new Error("Could not create a canvas for video export");
+      this.context = context;
+      this.signal = options.signal;
+      this.duration = options.duration;
+      this.result = new Promise((resolve, reject) => {
+        this.resolve = resolve;
+        this.reject = reject;
+      });
+      try {
+        this.stream = this.canvas.captureStream(fps);
+        this.recorder = new MediaRecorder(this.stream, { mimeType, videoBitsPerSecond: bitrate });
+        this.recorder.addEventListener("start", this.onStart);
+        this.recorder.addEventListener("dataavailable", this.onData);
+        this.recorder.addEventListener("stop", this.onStop);
+        this.recorder.addEventListener("error", this.onError);
+        for (const track of this.stream.getTracks()) {
+          track.addEventListener("ended", this.onTrackEnded);
+        }
+        this.signal?.addEventListener("abort", this.onAbort, { once: true });
+        this.recorder.start();
+      } catch (error2) {
+        this.cancel(error2);
+      }
+    }
+    /** Copies a freshly drawn source frame before WebGL can clear its drawing buffer. */
+    capture() {
+      if (this.settled || this.stopping) return;
+      try {
+        this.context.fillStyle = "#000000";
+        this.context.fillRect(0, 0, this.canvas.width, this.canvas.height);
+        this.context.drawImage(this.source, 0, 0, this.canvas.width, this.canvas.height);
+      } catch (error2) {
+        this.cancel(error2);
+      }
+    }
+    /** Cancels recording, releases its capture stream, and rejects {@link result}. */
+    cancel(reason = new DOMException("Video export cancelled", "AbortError")) {
+      if (this.settled) return;
+      this.settled = true;
+      this.cleanup();
+      this.reject(reason);
+    }
+    cleanup() {
+      if (this.timer !== void 0) clearTimeout(this.timer);
+      this.signal?.removeEventListener("abort", this.onAbort);
+      if (this.recorder) {
+        this.recorder.removeEventListener("start", this.onStart);
+        this.recorder.removeEventListener("dataavailable", this.onData);
+        this.recorder.removeEventListener("stop", this.onStop);
+        this.recorder.removeEventListener("error", this.onError);
+        if (this.recorder.state !== "inactive") {
+          try {
+            this.recorder.stop();
+          } catch {
+          }
+        }
+      }
+      for (const track of this.stream?.getTracks() ?? []) {
+        track.removeEventListener("ended", this.onTrackEnded);
+        track.stop();
+      }
+      this.chunks.length = 0;
+    }
+  };
+
   // src/gui/index.ts
   init_dirname();
   init_buffer2();
@@ -117544,6 +117673,9 @@ gl_FragDepth=readDepth(vUv);
         this._inAnimationLoop = true;
         try {
           this.animate(time);
+        } catch (error2) {
+          this._videoExporter?.cancel(error2);
+          throw error2;
         } finally {
           this._inAnimationLoop = false;
         }
@@ -117738,16 +117870,18 @@ gl_FragDepth=readDepth(vUv);
         if (this._frameCallbacks.get(callback) === subscription) this._frameCallbacks.delete(callback);
       };
     }
-    /** Starts or resumes the animation loop and registered frame callbacks. */
+    /** Starts or resumes the animation loop and registered frame callbacks. Has no effect while running. */
     start() {
-      if (this._disposed) return;
+      if (this._disposed || this._running) return;
       this.stop();
       this._running = true;
       if (!this._inAnimationLoop) this.renderer.setAnimationLoop(this._animationLoop);
     }
-    /** Pauses rendering and frame callbacks. Call {@link start} to resume. */
+    /** Pauses rendering and frame callbacks, and cancels video export. Call {@link start} to resume. */
     stop() {
       if (this._disposed) return;
+      this._videoExporter?.cancel();
+      this._videoExporter = void 0;
       this._running = false;
       if (this._inAnimationLoop) {
         queueMicrotask(() => {
@@ -117809,7 +117943,7 @@ gl_FragDepth=readDepth(vUv);
         this._controls.update();
       }
       if (!this._running) return;
-      if (!this.dirty && !this.options.render.renderAlways && !this._frameCallbacks.size) return;
+      if (!this.dirty && !this.options.render.renderAlways && !this._frameCallbacks.size && !this._videoExporter) return;
       const interval = this._frameInterval;
       if (interval) {
         const next = this._nextFrameTime;
@@ -117834,6 +117968,7 @@ gl_FragDepth=readDepth(vUv);
       } else {
         this.renderer.render(this.scene, this.camera);
       }
+      this._videoExporter?.capture();
       this.dirty = false;
       if (this._stats) {
         this._stats.end();
@@ -117854,6 +117989,35 @@ gl_FragDepth=readDepth(vUv);
       const canvas = trim ? trimCanvas(this.renderer.domElement) : this.renderer.domElement;
       return canvas.toDataURL(mime, quality);
     }
+    /**
+     * Records a silent browser video in real time, including frame callbacks and animated textures.
+     * Keep the tab visible; browser scheduling and `render.fpsLimit` limit the capture rate.
+     * The video keeps the initial drawing-buffer size and fills transparent pixels with black.
+     * Temporarily starts a stopped renderer. Stop, disposal, or `options.signal` cancels the export.
+     * Only one export can run at a time. Use the returned Blob's type to select a file extension.
+     */
+    async toVideo(options) {
+      if (this._disposed) throw new Error("Cannot export a video from a disposed renderer");
+      if (this._videoExporter) throw new Error("A video export is already running");
+      const exporter = new VideoExporter(this.renderer.domElement, options);
+      const wasRunning = this._running;
+      try {
+        try {
+          if (!wasRunning) this.start();
+          this._videoExporter = exporter;
+          if (this._controls?.enabled) this._controls.update();
+          this.drawFrame();
+        } catch (error2) {
+          exporter.cancel(error2);
+        }
+        return await exporter.result;
+      } finally {
+        if (this._videoExporter === exporter) {
+          this._videoExporter = void 0;
+          if (!wasRunning) this.stop();
+        }
+      }
+    }
     /** Exports visible scene meshes as OBJ text, without texture images. */
     toObj() {
       return SceneExporter.toObj(this.scene);