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

package/dist/node/index.mjs

@@ -22078,6 +22078,131 @@ function copyDataTexture(source) {
   return new Texture3().copy(copySource);
 }
 
+// src/export/VideoExporter.ts
+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 (error) {
+          this.cancel(error);
+        }
+      }, 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 mimeTypes = options.mimeType === void 0 ? ["video/webm;codecs=vp9", "video/webm;codecs=vp8", "video/webm", "video/mp4"] : [options.mimeType];
+    const mimeType = mimeTypes.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 (error) {
+      this.cancel(error);
+    }
+  }
+  /** 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 (error) {
+      this.cancel(error);
+    }
+  }
+  /** 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/GuiHelper.ts
 init_AssetKey();
 init_ModelTextures();
@@ -27397,6 +27522,9 @@ var Renderer = class _Renderer {
       this._inAnimationLoop = true;
       try {
         this.animate(time);
+      } catch (error) {
+        this._videoExporter?.cancel(error);
+        throw error;
       } finally {
         this._inAnimationLoop = false;
       }
@@ -27631,16 +27759,18 @@ var Renderer = class _Renderer {
       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(() => {
@@ -27702,7 +27832,7 @@ var Renderer = class _Renderer {
       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;
@@ -27727,6 +27857,7 @@ var Renderer = class _Renderer {
     } else {
       this.renderer.render(this.scene, this.camera);
     }
+    this._videoExporter?.capture();
     this.dirty = false;
     if (this._stats) {
       this._stats.end();
@@ -27747,6 +27878,35 @@ var Renderer = class _Renderer {
     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 (error) {
+        exporter.cancel(error);
+      }
+      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);
@@ -29438,6 +29598,7 @@ export {
   Ticker,
   TintColors,
   UVMapper,
+  VideoExporter,
   WrappedImage,
   addBox3WireframeToObject,
   addWireframeToMesh,