minerender 2.1.0-alpha.86 → 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,
@@ -106581,6 +106582,7 @@ ${shader.fragmentShader}`.replace(
     TintColors: () => TintColors,
     UVMapper: () => UVMapper,
     VideoExporter: () => VideoExporter,
+    WorldStreamer: () => WorldStreamer,
     WrappedImage: () => WrappedImage,
     addBox3WireframeToObject: () => addBox3WireframeToObject,
     addWireframeToMesh: () => addWireframeToMesh,
@@ -119015,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();
@@ -119706,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: