minerender 2.1.0-alpha.85 → 2.1.0-alpha.87

package/dist/browser/index.js

@@ -18688,6 +18688,7 @@ var index_browser_exports = {};
 __export(index_browser_exports, {
   AXES: () => AXES,
   AnvilParser: () => AnvilParser,
+  AnvilWorldSource: () => AnvilWorldSource,
   ArchiveAssetSource: () => ArchiveAssetSource,
   AssetKey: () => AssetKey,
   AssetLoadError: () => AssetLoadError,
@@ -18790,6 +18791,8 @@ __export(index_browser_exports, {
   Ticker: () => Ticker,
   TintColors: () => TintColors,
   UVMapper: () => UVMapper,
+  VideoExporter: () => VideoExporter,
+  WorldStreamer: () => WorldStreamer,
   WrappedImage: () => WrappedImage,
   addBox3WireframeToObject: () => addBox3WireframeToObject,
   addWireframeToMesh: () => addWireframeToMesh,
@@ -22165,6 +22168,131 @@ function copyDataTexture(source) {
   return new import_three19.Texture().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();
@@ -27474,6 +27602,9 @@ var _Renderer = class _Renderer {
       this._inAnimationLoop = true;
       try {
         this.animate(time);
+      } catch (error) {
+        this._videoExporter?.cancel(error);
+        throw error;
       } finally {
         this._inAnimationLoop = false;
       }
@@ -27668,16 +27799,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(() => {
@@ -27739,7 +27872,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;
@@ -27764,6 +27897,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();
@@ -27784,6 +27918,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);
@@ -28735,6 +28898,134 @@ var AnvilParser = class {
   }
 };
 
+// src/world/AnvilWorldSource.ts
+init_MineRenderError();
+async function abortable2(promise, signal) {
+  if (!signal) return promise;
+  let abort;
+  const cancelled = new Promise((_, reject) => {
+    abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+  try {
+    return await Promise.race([promise, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+}
+var AnvilWorldSource = class {
+  constructor(readRegion, options = {}) {
+    this.readRegion = readRegion;
+    this.regions = /* @__PURE__ */ new Map();
+    this.pending = /* @__PURE__ */ new Map();
+    this.cachedBytes = 0;
+    this.maxCachedRegions = options.maxCachedRegions ?? 4;
+    this.maxCachedBytes = options.maxCachedBytes ?? 64 * 1024 * 1024;
+    for (const [name, value] of Object.entries({ maxCachedRegions: this.maxCachedRegions, maxCachedBytes: this.maxCachedBytes })) {
+      if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name} must be a nonnegative safe integer`);
+    }
+  }
+  /** Decodes one column at absolute chunk coordinates. Aborting a caller leaves other shared readers active. */
+  async getChunk(x, z, signal) {
+    if (!Number.isSafeInteger(x) || !Number.isSafeInteger(z)) {
+      throw new RangeError("Chunk column coordinates must be safe integers");
+    }
+    const regionX = Math.floor(x / 32), regionZ = Math.floor(z / 32);
+    const data = await this.getRegion(regionX, regionZ, signal);
+    signal?.throwIfAborted();
+    if (!data) return void 0;
+    const chunk = await abortable2(AnvilParser.parseChunk(data, x - regionX * 32, z - regionZ * 32), signal);
+    signal?.throwIfAborted();
+    if (chunk && (chunk.x !== x || chunk.z !== z)) {
+      throw new MineRenderError(`Anvil chunk coordinates ${chunk.x},${chunk.z} do not match requested column ${x},${z}`);
+    }
+    return chunk;
+  }
+  /** Releases cached regions. Reads already in progress finish without repopulating this cache. */
+  clearCache() {
+    this.regions.clear();
+    this.pending.clear();
+    this.cachedBytes = 0;
+  }
+  getRegion(x, z, signal) {
+    signal?.throwIfAborted();
+    const key = `${x},${z}`;
+    const cached2 = this.regions.get(key);
+    if (cached2) {
+      this.regions.delete(key);
+      this.regions.set(key, cached2);
+      return Promise.resolve(cached2.data);
+    }
+    let loading = this.pending.get(key);
+    if (!loading) {
+      const controller = new AbortController();
+      loading = {
+        controller,
+        waiters: 0,
+        settled: false,
+        promise: Promise.resolve().then(() => {
+          controller.signal.throwIfAborted();
+          return this.readRegion(x, z, controller.signal);
+        }).then((data) => {
+          controller.signal.throwIfAborted();
+          let bytes = data instanceof Uint8Array ? data : data === void 0 ? void 0 : new Uint8Array(data);
+          if (bytes && bytes.byteLength !== bytes.buffer.byteLength) bytes = new Uint8Array(bytes);
+          if (bytes) AnvilParser.getChunkList(bytes);
+          loading.settled = true;
+          if (this.pending.get(key) === loading) this.cacheRegion(key, bytes);
+          return bytes;
+        }).finally(() => {
+          loading.settled = true;
+          if (this.pending.get(key) === loading) this.pending.delete(key);
+        })
+      };
+      this.pending.set(key, loading);
+    }
+    const read = loading;
+    read.waiters++;
+    return new Promise((resolve, reject) => {
+      let finished = false;
+      const release = () => {
+        if (finished) return false;
+        finished = true;
+        signal?.removeEventListener("abort", abort);
+        read.waiters--;
+        return true;
+      };
+      const abort = () => {
+        if (!release()) return;
+        if (!read.waiters && !read.settled) {
+          if (this.pending.get(key) === read) this.pending.delete(key);
+          read.controller.abort(signal.reason);
+        }
+        reject(signal.reason);
+      };
+      signal?.addEventListener("abort", abort, { once: true });
+      read.promise.then(
+        (data) => {
+          if (release()) resolve(data);
+        },
+        (error) => {
+          if (release()) reject(error);
+        }
+      );
+      if (signal?.aborted) abort();
+    });
+  }
+  cacheRegion(key, data) {
+    const size = data?.byteLength ?? 0;
+    if (!this.maxCachedRegions || size > this.maxCachedBytes) return;
+    this.regions.set(key, { data, size });
+    this.cachedBytes += size;
+    while (this.regions.size > this.maxCachedRegions || this.cachedBytes > this.maxCachedBytes) {
+      const oldest = this.regions.keys().next().value;
+      this.cachedBytes -= this.regions.get(oldest).size;
+      this.regions.delete(oldest);
+    }
+  }
+};
+
 // src/world/Chunk.ts
 var import_three42 = require("three");
 init_BlockStates();
@@ -29409,4 +29700,178 @@ var Chunk = class _Chunk {
     );
   }
 };
+
+// src/world/WorldStreamer.ts
+var WorldStreamer = class {
+  constructor(world, source, options = {}) {
+    this.world = world;
+    this.source = source;
+    this.loaded = /* @__PURE__ */ new Map();
+    this.owned = /* @__PURE__ */ new Map();
+    this.missing = /* @__PURE__ */ new Map();
+    this.failed = /* @__PURE__ */ new Map();
+    this.desired = [];
+    this.disposed = false;
+    this.loadRadius = options.loadRadius ?? 2;
+    this.unloadRadius = options.unloadRadius ?? Math.min(32, this.loadRadius + 1);
+    if (![this.loadRadius, this.unloadRadius].every((value) => Number.isInteger(value) && value >= 0 && value <= 32) || this.unloadRadius < this.loadRadius) {
+      throw new RangeError("Chunk radii must be integers from 0 to 32, with unloadRadius at least loadRadius");
+    }
+  }
+  /** Returns absolute coordinates of successfully placed columns, including retained columns. */
+  get loadedChunks() {
+    return [...this.loaded.values()].map((position) => ({ ...position }));
+  }
+  /** Returns source failures retained within the unload radius. Failed columns do not block other loads. */
+  get failedChunks() {
+    return [...this.failed.values()].map((failure) => ({ ...failure }));
+  }
+  /** Counts desired columns still waiting for a source read or placement, including the active column. */
+  get pendingChunks() {
+    return this.desired.filter((position) => this.needsLoad(position)).length;
+  }
+  /**
+   * Updates the center in absolute chunk coordinates. Repeated calls share the active drain.
+   * Source failures are recorded in failedChunks; other columns continue loading. Missing and failed
+   * columns are remembered within the retention radius. Call retryFailedChunks to retry source failures.
+   * Placement and unload failures reject the drain; call update again to retry those operations.
+   * Reads outside the latest load radius receive an abort signal; placement finishes before unloading.
+   * Sources should represent an unchanged world during streaming.
+   */
+  async update(x, z) {
+    if (this.disposed) throw new Error("WorldStreamer is disposed");
+    if (![x, z].every((value) => Number.isSafeInteger(value) && Number.isSafeInteger(value - this.unloadRadius) && Number.isSafeInteger(value + this.unloadRadius))) {
+      throw new RangeError("Chunk coordinates must be safe integers within the streaming radius");
+    }
+    if (!this.center || this.center.x !== x || this.center.z !== z) {
+      this.center = { x, z };
+      this.desired = [];
+      for (let dz = -this.loadRadius; dz <= this.loadRadius; dz++) {
+        for (let dx = -this.loadRadius; dx <= this.loadRadius; dx++) {
+          this.desired.push({ x: x + dx, z: z + dz });
+        }
+      }
+      this.desired.sort((a, b) => (a.x - x) ** 2 + (a.z - z) ** 2 - (b.x - x) ** 2 - (b.z - z) ** 2);
+      if (this.loading && !this.within(this.loading.position, this.loadRadius)) {
+        this.loading.controller.abort();
+      }
+    }
+    return this.running ?? (this.running = Promise.resolve().then(() => this.drain()));
+  }
+  /** Updates from a camera or view-center position in scene units. One chunk spans 256 scene units. */
+  async updatePosition(position) {
+    if (![position.x, position.z].every(Number.isFinite)) throw new RangeError("Scene coordinates must be finite");
+    return this.update(Math.floor(position.x / 256), Math.floor(position.z / 256));
+  }
+  /** Forgets recorded source failures and retries desired columns at the latest center. */
+  async retryFailedChunks() {
+    if (this.disposed) throw new Error("WorldStreamer is disposed");
+    this.failed.clear();
+    if (this.center) await this.update(this.center.x, this.center.z);
+  }
+  /** Aborts source reads, waits for active work, then unloads owned columns. The world and source remain caller-owned. */
+  dispose() {
+    this.disposed = true;
+    this.desired = [];
+    this.center = void 0;
+    this.loading?.controller.abort();
+    return this.disposal ?? (this.disposal = Promise.resolve().then(async () => {
+      await this.running?.catch(() => void 0);
+      let failure;
+      let failed = false;
+      for (const position of this.owned.values()) {
+        try {
+          await this.unload(position);
+        } catch (error) {
+          failed = true;
+          failure ?? (failure = error);
+        }
+      }
+      this.missing.clear();
+      this.failed.clear();
+      if (failed) throw failure;
+    }).catch((error) => {
+      this.disposal = void 0;
+      throw error;
+    }));
+  }
+  async drain() {
+    try {
+      while (!this.disposed) {
+        for (const [key, position2] of this.missing) {
+          if (!this.within(position2, this.unloadRadius)) this.missing.delete(key);
+        }
+        for (const [key, position2] of this.failed) {
+          if (!this.within(position2, this.unloadRadius)) this.failed.delete(key);
+        }
+        const obsolete = [...this.owned.values()].find((position2) => !this.loaded.has(this.key(position2)) || !this.within(position2, this.unloadRadius));
+        if (obsolete) {
+          await this.unload(obsolete);
+          continue;
+        }
+        const position = this.desired.find((position2) => this.needsLoad(position2));
+        if (!position) return;
+        let chunk;
+        const controller = new AbortController();
+        this.loading = { position, controller };
+        try {
+          chunk = await this.source.getChunk(position.x, position.z, controller.signal);
+          if (chunk) this.validateChunk(chunk, position);
+        } catch (error) {
+          if (!controller.signal.aborted && !this.disposed && this.within(position, this.loadRadius)) {
+            this.failed.set(this.key(position), { ...position, error });
+          }
+          continue;
+        } finally {
+          this.loading = void 0;
+        }
+        if (controller.signal.aborted || this.disposed || !this.within(position, this.loadRadius)) continue;
+        if (!chunk) {
+          this.missing.set(this.key(position), position);
+          continue;
+        }
+        this.owned.set(this.key(position), position);
+        try {
+          await this.world.placeChunk(chunk);
+          this.loaded.set(this.key(position), position);
+        } catch (error) {
+          try {
+            await this.unload(position);
+          } catch (cleanupError) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            try {
+              Object.defineProperty(failure, "cause", { value: cleanupError, configurable: true });
+            } catch {
+              throw Object.assign(new Error(failure.message), { cause: cleanupError });
+            }
+            throw failure;
+          }
+          throw error;
+        }
+      }
+    } finally {
+      this.running = void 0;
+    }
+  }
+  needsLoad(position) {
+    const key = this.key(position);
+    return !this.loaded.has(key) && !this.missing.has(key) && !this.failed.has(key);
+  }
+  async unload(position) {
+    await this.world.unloadChunkColumn(position.x, position.z);
+    this.owned.delete(this.key(position));
+    this.loaded.delete(this.key(position));
+  }
+  validateChunk(chunk, position) {
+    if (chunk.x !== position.x || chunk.z !== position.z) {
+      throw new Error(`World source returned chunk ${chunk.x},${chunk.z} for ${position.x},${position.z}`);
+    }
+  }
+  within(position, radius) {
+    return !!this.center && Math.abs(position.x - this.center.x) <= radius && Math.abs(position.z - this.center.z) <= radius;
+  }
+  key(position) {
+    return `${position.x},${position.z}`;
+  }
+};
 //# sourceMappingURL=index.js.map