minerender 2.1.0-alpha.142 → 2.1.0-alpha.143

package/dist/bundle.js

@@ -34068,8 +34068,6 @@ void main() {
     });
   }
   function yieldToEventLoop() {
-    const scheduler = globalThis.scheduler;
-    if (scheduler?.yield) return scheduler.yield();
     return new Promise((resolve) => {
       if (typeof MessageChannel !== "undefined") {
         const channel = new MessageChannel();
@@ -103867,6 +103865,7 @@ gl_FragDepth=readDepth(vUv);
   // src/world/MineRenderWorld.ts
   init_log();
   var log21 = logger("MineRenderWorld");
+  var YIELD_INTERVAL_MS = 8;
   var MineRenderWorld = class {
     constructor(scene, options = {}) {
       this._chunks = /* @__PURE__ */ new Map();
@@ -103980,7 +103979,7 @@ gl_FragDepth=readDepth(vUv);
               failures.set(chunk, error2);
               if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) === chunk) this.pendingBiomes.set(chunk, void 0);
             }
-            if (performance.now() - sliceStart > 8) {
+            if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
               await yieldToEventLoop();
               sliceStart = performance.now();
             }
@@ -104135,7 +104134,7 @@ gl_FragDepth=readDepth(vUv);
           )));
           for (const pos of positions) changes.set(`${pos.x},${pos.y},${pos.z}`, pos);
         }
-        if (performance.now() - sliceStart > 8) {
+        if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
           await yieldToEventLoop();
           sliceStart = performance.now();
         }
@@ -104143,6 +104142,62 @@ gl_FragDepth=readDepth(vUv);
     }
     /** Replaces a chunk column's blocks, biomes, and saved light and, with `renderEntities`, its supported saved mobs. */
     async placeChunk(chunk, executor) {
+      return this.placeColumn(chunk, executor);
+    }
+    /**
+     * Replaces parsed columns in input order, then refreshes neighboring geometry once.
+     * Duplicate coordinates retain their order. A failed column stops placement; queued refreshes finish before rejection.
+     */
+    async placeChunks(chunks) {
+      const columns = [];
+      for (const chunk of chunks) {
+        const { x: x4, z: z4 } = chunk ?? {};
+        if (![x4, z4].every(Number.isSafeInteger)) {
+          throw new RangeError("Chunk column coordinates must be safe integers");
+        }
+        const sections = Array.from(chunk.sections, (section) => {
+          const { y: y5 } = section ?? {};
+          if (!Number.isSafeInteger(y5)) throw new RangeError("Chunk section coordinates must be safe integers");
+          return { ...section, y: y5 };
+        });
+        columns.push({ ...chunk, x: x4, z: z4, sections });
+      }
+      if (!columns.length) return;
+      await this.culling;
+      let failed = false, failure, sliceStart = performance.now();
+      try {
+        for (const column of columns) {
+          await this.placeColumn(column, void 0, true);
+          if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
+            await yieldToEventLoop();
+            sliceStart = performance.now();
+          }
+        }
+      } catch (error2) {
+        failed = true;
+        failure = error2;
+      } finally {
+        try {
+          const failures = await this.refreshBiomes(true);
+          if (failures.size) log21.warn("Failed to refresh biome colors", failures.values().next().value);
+        } catch (error2) {
+          if (!failed) {
+            failed = true;
+            failure = error2;
+          }
+        }
+        try {
+          await this.updateCulling([]);
+        } catch (error2) {
+          if (!failed) {
+            failed = true;
+            failure = error2;
+          }
+        }
+      }
+      if (failed) throw failure;
+    }
+    async placeColumn(chunk, executor, deferCulling = false) {
       if (![chunk.x, chunk.z].every(Number.isSafeInteger)) {
         throw new RangeError("Chunk column coordinates must be safe integers");
       }
@@ -104204,7 +104259,7 @@ gl_FragDepth=readDepth(vUv);
             } finally {
               this.markSectionChanged(target);
             }
-            if (performance.now() - sliceStart > 8) {
+            if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
               await yieldToEventLoop();
               sliceStart = performance.now();
             }
@@ -104227,9 +104282,12 @@ gl_FragDepth=readDepth(vUv);
         await placeEntities?.();
       } finally {
         this.markBiomesChanged(chunk.x, chunk.z, void 0, false);
-        const failures = await this.refreshBiomes();
-        if (failures.size) log21.warn("Failed to refresh biome colors", failures.values().next().value);
-        await this.updateCulling([...changes.values()]);
+        if (deferCulling) await this.updateCulling([...changes.values()], true);
+        else {
+          const failures = await this.refreshBiomes();
+          if (failures.size) log21.warn("Failed to refresh biome colors", failures.values().next().value);
+          await this.updateCulling([...changes.values()]);
+        }
       }
     }
     /**
@@ -104259,7 +104317,7 @@ gl_FragDepth=readDepth(vUv);
         for (const { x: x4, z: z4 } of columns.values()) {
           this.entities?.clearColumn(x4, z4);
           await this.clearChunkColumn(x4, z4);
-          if (performance.now() - sliceStart > 8) {
+          if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
             await yieldToEventLoop();
             sliceStart = performance.now();
           }
@@ -104398,15 +104456,25 @@ gl_FragDepth=readDepth(vUv);
                 for (const [index, mask] of masks) await chunk.setCullMaskIndex(index, mask);
                 await chunk.refreshLight(indices === "all" ? void 0 : indices);
                 chunk.refreshAmbientOcclusion(this._ambientOcclusion);
-                if ((this._ambientOcclusion || this.ambientOcclusionPending) && performance.now() - sliceStart > 8) {
+                if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
                   await yieldToEventLoop();
                   sliceStart = performance.now();
                 }
               }
-              const builds = await Promise.allSettled([...batch.keys()].map(async (chunk) => {
-                await chunk.rebuildSectionMesh();
-                batch.delete(chunk);
-              }));
+              const pending = [];
+              for (const chunk of [...batch.keys()]) {
+                const build = (async () => {
+                  await chunk.rebuildSectionMesh();
+                  batch.delete(chunk);
+                })();
+                void build.catch(() => void 0);
+                pending.push(build);
+                if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
+                  await yieldToEventLoop();
+                  sliceStart = performance.now();
+                }
+              }
+              const builds = await Promise.allSettled(pending);
               const failure = builds.find((result) => result.status === "rejected");
               if (failure?.status === "rejected") throw failure.reason;
             } catch (error2) {
@@ -105898,6 +105966,7 @@ gl_FragDepth=readDepth(vUv);
   init_dirname();
   init_buffer2();
   init_process2();
+  var MAX_PREFETCHED_COLUMNS = 4;
   var WorldStreamer = class {
     constructor(world, source, options = {}) {
       this.world = world;
@@ -105907,6 +105976,7 @@ gl_FragDepth=readDepth(vUv);
       this.missing = /* @__PURE__ */ new Map();
       this.failed = /* @__PURE__ */ new Map();
       this.desired = [];
+      this.reads = /* @__PURE__ */ new Map();
       this.disposed = false;
       this.loadRadius = options.loadRadius ?? 2;
       this.unloadRadius = options.unloadRadius ?? Math.min(32, this.loadRadius + 1);
@@ -105951,6 +106021,12 @@ gl_FragDepth=readDepth(vUv);
         if (this.loading && !this.within(this.loading.position, this.loadRadius)) {
           this.loading.controller.abort();
         }
+        for (const [key, read] of this.reads) {
+          if (!this.within(read.position, this.loadRadius)) {
+            read.controller.abort();
+            if (read.ready) this.reads.delete(key);
+          }
+        }
       }
       return this.running ?? (this.running = Promise.resolve().then(() => this.drain()));
     }
@@ -105971,8 +106047,11 @@ gl_FragDepth=readDepth(vUv);
       this.desired = [];
       this.center = void 0;
       this.loading?.controller.abort();
+      for (const read of this.reads.values()) read.controller.abort();
       return this.disposal ?? (this.disposal = Promise.resolve().then(async () => {
         await this.running?.catch(() => void 0);
+        await Promise.all([...this.reads.values()].map((read) => read.promise));
+        this.reads.clear();
         try {
           await this.unloadMany([...this.owned.values()]);
         } finally {
@@ -105998,6 +106077,10 @@ gl_FragDepth=readDepth(vUv);
             await this.unloadMany(obsolete);
             continue;
           }
+          if (this.world.placeChunks) {
+            if (await this.placeReadyChunks()) continue;
+            return;
+          }
           const position = this.desired.find((position2) => this.needsLoad(position2));
           if (!position) return;
           let chunk;
@@ -106020,26 +106103,105 @@ gl_FragDepth=readDepth(vUv);
             continue;
           }
           this.owned.set(this.key(position), position);
+          await this.placeOwnedColumns([position], () => this.world.placeChunk(chunk));
+        }
+      } finally {
+        for (const [key, read] of this.reads) {
+          read.controller.abort();
+          if (read.ready) this.reads.delete(key);
+        }
+        this.running = void 0;
+      }
+    }
+    fillReadSlots() {
+      while (!this.disposed && this.reads.size < MAX_PREFETCHED_COLUMNS) {
+        const position = this.desired.find((position2) => this.needsLoad(position2) && !this.reads.has(this.key(position2)));
+        if (!position) return;
+        const key = this.key(position);
+        const read = {
+          position,
+          controller: new AbortController(),
+          promise: Promise.resolve(),
+          ready: false,
+          failed: false
+        };
+        this.reads.set(key, read);
+        read.promise = (async () => {
           try {
-            await this.world.placeChunk(chunk);
-            this.loaded.set(this.key(position), position);
+            read.chunk = await this.source.getChunk(position.x, position.z, read.controller.signal);
+            if (read.chunk) this.validateChunk(read.chunk, position);
           } catch (error2) {
-            try {
-              await this.unloadMany([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;
+            read.failed = true;
+            read.error = error2;
+          } finally {
+            read.ready = true;
+            if (read.controller.signal.aborted || this.disposed || !this.within(position, this.loadRadius)) {
+              this.reads.delete(key);
             }
-            throw error2;
+          }
+        })();
+      }
+    }
+    /** Places only the ready prefix, so later source reads cannot delay the nearest ready column. */
+    async placeReadyChunks() {
+      this.fillReadSlots();
+      const position = this.desired.find((position2) => this.needsLoad(position2));
+      if (!position) {
+        if (!this.reads.size) return false;
+        await Promise.all([...this.reads.values()].map((read) => read.promise));
+        return true;
+      }
+      const head = this.reads.get(this.key(position));
+      if (!head) {
+        for (let index = this.desired.length - 1; index >= 0; index--) {
+          const key = this.key(this.desired[index]);
+          if (this.reads.get(key)?.ready) {
+            this.reads.delete(key);
+            return true;
           }
         }
-      } finally {
-        this.running = void 0;
+        await Promise.race([...this.reads.values()].map((read) => read.promise));
+        return true;
+      }
+      if (!head.ready) {
+        await head.promise;
+        return true;
+      }
+      const chunks = [], positions = [];
+      for (const desired of this.desired) {
+        if (!this.needsLoad(desired)) continue;
+        const key = this.key(desired), read = this.reads.get(key);
+        if (!read?.ready) break;
+        this.reads.delete(key);
+        if (read.failed) this.failed.set(key, { ...desired, error: read.error });
+        else if (!read.chunk) this.missing.set(key, desired);
+        else {
+          chunks.push(read.chunk);
+          positions.push(desired);
+        }
+      }
+      if (!chunks.length) return true;
+      for (const position2 of positions) this.owned.set(this.key(position2), position2);
+      await this.placeOwnedColumns(positions, () => this.world.placeChunks(chunks));
+      return true;
+    }
+    async placeOwnedColumns(positions, place) {
+      try {
+        await place();
+        for (const position of positions) this.loaded.set(this.key(position), position);
+      } catch (error2) {
+        try {
+          await this.unloadMany(positions);
+        } 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;
       }
     }
     needsLoad(position) {