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

package/dist/bundle.js

@@ -106478,6 +106478,7 @@ ${shader.fragmentShader}`.replace(
   __export(index_browser_exports, {
     AXES: () => AXES,
     AnvilParser: () => AnvilParser,
+    AnvilWorldSource: () => AnvilWorldSource,
     ArchiveAssetSource: () => ArchiveAssetSource,
     AssetKey: () => AssetKey,
     AssetLoadError: () => AssetLoadError,
@@ -106580,6 +106581,8 @@ ${shader.fragmentShader}`.replace(
     Ticker: () => Ticker,
     TintColors: () => TintColors,
     UVMapper: () => UVMapper,
+    VideoExporter: () => VideoExporter,
+    WorldStreamer: () => WorldStreamer,
     WrappedImage: () => WrappedImage,
     addBox3WireframeToObject: () => addBox3WireframeToObject,
     addWireframeToMesh: () => addWireframeToMesh,
@@ -110099,6 +110102,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 +117675,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 +117872,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 +117945,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 +117970,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 +117991,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);
@@ -118851,6 +119017,137 @@ gl_FragDepth=readDepth(vUv);
     }
   };
 
+  // src/world/AnvilWorldSource.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_MineRenderError();
+  async function abortable2(promise, signal) {
+    if (!signal) return promise;
+    let abort2;
+    const cancelled = new Promise((_4, reject) => {
+      abort2 = () => reject(signal.reason);
+      signal.addEventListener("abort", abort2, { once: true });
+      if (signal.aborted) abort2();
+    });
+    try {
+      return await Promise.race([promise, cancelled]);
+    } finally {
+      signal.removeEventListener("abort", abort2);
+    }
+  }
+  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 [name2, value] of Object.entries({ maxCachedRegions: this.maxCachedRegions, maxCachedBytes: this.maxCachedBytes })) {
+        if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name2} must be a nonnegative safe integer`);
+      }
+    }
+    /** Decodes one column at absolute chunk coordinates. Aborting a caller leaves other shared readers active. */
+    async getChunk(x4, z4, signal) {
+      if (!Number.isSafeInteger(x4) || !Number.isSafeInteger(z4)) {
+        throw new RangeError("Chunk column coordinates must be safe integers");
+      }
+      const regionX = Math.floor(x4 / 32), regionZ = Math.floor(z4 / 32);
+      const data = await this.getRegion(regionX, regionZ, signal);
+      signal?.throwIfAborted();
+      if (!data) return void 0;
+      const chunk = await abortable2(AnvilParser.parseChunk(data, x4 - regionX * 32, z4 - regionZ * 32), signal);
+      signal?.throwIfAborted();
+      if (chunk && (chunk.x !== x4 || chunk.z !== z4)) {
+        throw new MineRenderError(`Anvil chunk coordinates ${chunk.x},${chunk.z} do not match requested column ${x4},${z4}`);
+      }
+      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(x4, z4, signal) {
+      signal?.throwIfAborted();
+      const key = `${x4},${z4}`;
+      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(x4, z4, 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 release2 = () => {
+          if (finished) return false;
+          finished = true;
+          signal?.removeEventListener("abort", abort2);
+          read.waiters--;
+          return true;
+        };
+        const abort2 = () => {
+          if (!release2()) 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", abort2, { once: true });
+        read.promise.then(
+          (data) => {
+            if (release2()) resolve(data);
+          },
+          (error2) => {
+            if (release2()) reject(error2);
+          }
+        );
+        if (signal?.aborted) abort2();
+      });
+    }
+    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/BlockInfo.ts
   init_dirname();
   init_buffer2();
@@ -119542,6 +119839,188 @@ gl_FragDepth=readDepth(vUv);
       );
     }
   };
+
+  // src/world/WorldChunkSource.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
+  // src/world/WorldStreamer.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  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(x4, z4) {
+      if (this.disposed) throw new Error("WorldStreamer is disposed");
+      if (![x4, z4].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 !== x4 || this.center.z !== z4) {
+        this.center = { x: x4, z: z4 };
+        this.desired = [];
+        for (let dz = -this.loadRadius; dz <= this.loadRadius; dz++) {
+          for (let dx = -this.loadRadius; dx <= this.loadRadius; dx++) {
+            this.desired.push({ x: x4 + dx, z: z4 + dz });
+          }
+        }
+        this.desired.sort((a4, b4) => (a4.x - x4) ** 2 + (a4.z - z4) ** 2 - (b4.x - x4) ** 2 - (b4.z - z4) ** 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 (error2) {
+            failed = true;
+            failure ?? (failure = error2);
+          }
+        }
+        this.missing.clear();
+        this.failed.clear();
+        if (failed) throw failure;
+      }).catch((error2) => {
+        this.disposal = void 0;
+        throw error2;
+      }));
+    }
+    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 (error2) {
+            if (!controller.signal.aborted && !this.disposed && this.within(position, this.loadRadius)) {
+              this.failed.set(this.key(position), { ...position, error: error2 });
+            }
+            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 (error2) {
+            try {
+              await this.unload(position);
+            } catch (cleanupError) {
+              const failure = error2 instanceof Error ? error2 : new Error(String(error2));
+              try {
+                Object.defineProperty(failure, "cause", { value: cleanupError, configurable: true });
+              } catch {
+                throw Object.assign(new Error(failure.message), { cause: cleanupError });
+              }
+              throw failure;
+            }
+            throw error2;
+          }
+        }
+      } 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}`;
+    }
+  };
   return __toCommonJS(index_browser_exports);
 })();
 /*! Bundled license information: