minerender 2.1.0-alpha.142 → 2.1.0-alpha.144

package/dist/node/index.mjs

@@ -184,8 +184,6 @@ async function sleep(timeout) {
   });
 }
 function yieldToEventLoop() {
-  const scheduler = globalThis.scheduler;
-  if (scheduler?.yield) return scheduler.yield();
   return new Promise((resolve) => {
     if (typeof MessageChannel !== "undefined") {
       const channel = new MessageChannel();
@@ -17924,6 +17922,7 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
+init_BlockObject();
 import { Color as Color13, Vector3 as Vector321 } from "three";
 init_BlockStates();
 init_AssetKey();
@@ -17934,6 +17933,7 @@ init_util();
 import { Vector3 as Vector319 } from "three";
 init_AssetKey();
 init_BlockStates();
+init_BlockEntities();
 init_CubeFace();
 
 // src/world/SectionModels.ts
@@ -18031,6 +18031,10 @@ var SectionModels = class {
       biomeTint: source ? [...templates.values()].some((template) => template.biomeTint?.some((value) => value === 1)) || void 0 : void 0
     };
   }
+  /** Starts loading the state's models and atlases so a later `prepareState` with the same properties finds them loaded. */
+  async preload(blockState3, properties = {}) {
+    await this.state(blockState3, properties);
+  }
   async state(blockState3, properties) {
     let states = this.states.get(blockState3);
     if (!states) this.states.set(blockState3, states = /* @__PURE__ */ new Map());
@@ -18053,22 +18057,24 @@ var SectionModels = class {
   async prepare(blockState3, properties) {
     const state = { ...await BlockStateResolver.defaults(blockState3), ...properties };
     const groups = BlockStateResolver.matching(blockState3, state);
-    if (!groups.length) return void 0;
+    if (!groups.length || groups.some((group) => Array.isArray(group) && !group.length)) return void 0;
+    const variants = groups.flatMap((group) => Array.isArray(group) ? group : [group]);
+    if (variants.some((variant) => !variant.model)) return void 0;
+    const settled = await Promise.allSettled(variants.map(async (variant) => {
+      const modelKey = AssetKey.parse("models", variant.model);
+      modelKey.root = blockState3.key?.root;
+      const model = await Models.getMerged(modelKey);
+      if (!model?.elements?.length) return void 0;
+      const atlas = await UVMapper.getAtlas(model);
+      const rotation = BlockStateResolver.rotation(variant);
+      if (!atlas || atlas.image.width > this.maxAtlasSize || atlas.image.height > this.maxAtlasSize) return void 0;
+      return { model, atlas, rotation };
+    }));
     const prepared = /* @__PURE__ */ new Map();
-    for (const group of groups) {
-      const choices = Array.isArray(group) ? group : [group];
-      if (!choices.length) return void 0;
-      for (const variant of choices) {
-        if (!variant.model) return void 0;
-        const modelKey = AssetKey.parse("models", variant.model);
-        modelKey.root = blockState3.key?.root;
-        const model = await Models.getMerged(modelKey);
-        if (!model?.elements?.length) return void 0;
-        const atlas = await UVMapper.getAtlas(model);
-        const rotation = BlockStateResolver.rotation(variant);
-        if (!atlas || atlas.image.width > this.maxAtlasSize || atlas.image.height > this.maxAtlasSize) return void 0;
-        prepared.set(variant, { model, atlas, rotation });
-      }
+    for (const [i, result] of settled.entries()) {
+      if (result.status === "rejected") throw result.reason;
+      if (!result.value) return void 0;
+      prepared.set(variants[i], result.value);
     }
     return { state, groups, choices: prepared };
   }
@@ -18528,6 +18534,7 @@ function skipsBlockFace(data, rule, block, neighbor, face) {
 // src/world/MineRenderWorld.ts
 init_log();
 var log18 = logger("MineRenderWorld");
+var YIELD_INTERVAL_MS = 8;
 var MineRenderWorld = class {
   constructor(scene, options = {}) {
     this._chunks = /* @__PURE__ */ new Map();
@@ -18641,7 +18648,7 @@ var MineRenderWorld = class {
             failures.set(chunk, error);
             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();
           }
@@ -18742,15 +18749,18 @@ var MineRenderWorld = class {
       const key = AssetKey.parse("blockstates", block.type);
       keys.set(key.serialize(), key);
     }
-    await BlockStates.getAll(keys.values());
+    const loaded = await BlockStates.getAll(keys.values());
+    const states = new Map([...keys.keys()].map((key, i) => [key, loaded[i]]));
     if (!useBatches) {
       for (const block of multiblock.blocks) await place(block);
       return;
     }
     if (!executor) {
       const groups2 = /* @__PURE__ */ new Map();
+      const distinct = /* @__PURE__ */ new Map();
       const position = new Vector319();
       for (const block of multiblock.blocks) {
+        if (this.sectionModels && !Chunk.isAir(block)) distinct.set(ChunkData.paletteKey(block), block);
         const [x, y, z] = block.position;
         this.validatePosBounds(position.set(x, y, z));
         const cx = Math.floor(x / 16), cy = Math.floor(y / 16), cz = Math.floor(z / 16);
@@ -18761,6 +18771,16 @@ var MineRenderWorld = class {
         if (!group) groups2.set(chunk, group = []);
         group.push({ index: (y - cy * 16) * 256 + (z - cz * 16) * 16 + x - cx * 16, block });
       }
+      if (this.sectionModels) {
+        for (const block of distinct.values()) {
+          const state = states.get(AssetKey.parse("blockstates", block.type).serialize());
+          if (!state) continue;
+          void (async () => {
+            if (state.key && BlockEntities.entry(await BlockEntities.getIndex(state.key.root), state.key.toNamespacedString())) return;
+            await this.sectionModels.preload(state, block.properties);
+          })().catch(() => void 0);
+        }
+      }
       await this.placeChunkGroups(groups2, changes);
       return;
     }
@@ -18796,7 +18816,7 @@ var MineRenderWorld = class {
         ));
         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();
       }
@@ -18804,6 +18824,62 @@ var MineRenderWorld = class {
   }
   /** 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, z } = chunk ?? {};
+      if (![x, z].every(Number.isSafeInteger)) {
+        throw new RangeError("Chunk column coordinates must be safe integers");
+      }
+      const sections = Array.from(chunk.sections, (section) => {
+        const { y } = section ?? {};
+        if (!Number.isSafeInteger(y)) throw new RangeError("Chunk section coordinates must be safe integers");
+        return { ...section, y };
+      });
+      columns.push({ ...chunk, x, z, 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 (error) {
+      failed = true;
+      failure = error;
+    } finally {
+      try {
+        const failures = await this.refreshBiomes(true);
+        if (failures.size) log18.warn("Failed to refresh biome colors", failures.values().next().value);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+      try {
+        await this.updateCulling([]);
+      } catch (error) {
+        if (!failed) {
+          failed = true;
+          failure = error;
+        }
+      }
+    }
+    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");
     }
@@ -18865,7 +18941,7 @@ var MineRenderWorld = class {
           } finally {
             this.markSectionChanged(target);
           }
-          if (performance.now() - sliceStart > 8) {
+          if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
             await yieldToEventLoop();
             sliceStart = performance.now();
           }
@@ -18888,9 +18964,12 @@ var MineRenderWorld = class {
       await placeEntities?.();
     } finally {
       this.markBiomesChanged(chunk.x, chunk.z, void 0, false);
-      const failures = await this.refreshBiomes();
-      if (failures.size) log18.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) log18.warn("Failed to refresh biome colors", failures.values().next().value);
+        await this.updateCulling([...changes.values()]);
+      }
     }
   }
   /**
@@ -18920,7 +18999,7 @@ var MineRenderWorld = class {
       for (const { x, z } of columns.values()) {
         this.entities?.clearColumn(x, z);
         await this.clearChunkColumn(x, z);
-        if (performance.now() - sliceStart > 8) {
+        if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
           await yieldToEventLoop();
           sliceStart = performance.now();
         }
@@ -19059,15 +19138,25 @@ var MineRenderWorld = class {
               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 (error) {
@@ -20019,8 +20108,10 @@ var Chunk = class _Chunk {
       if (rejected?.status === "rejected") throw rejected.reason;
     }
     const positions = [];
-    let failed = false, failure;
-    for (const { index, key, block } of placements) {
+    const jobs = /* @__PURE__ */ new Map();
+    let failureOrder = Infinity, failure;
+    for (const [order, { index, key, block }] of placements.entries()) {
+      jobs.delete(index);
       this.hiddenBlocks.delete(index);
       this.data.assign(index, this.data.intern(block), block?.nbt);
       const readBlock = this.data.snapshot(index);
@@ -20036,7 +20127,6 @@ var Chunk = class _Chunk {
         this.z * 16 + Math.floor(index / 16) % 16
       );
       positions.push(worldPos);
-      let object4;
       try {
         if (!readBlock) continue;
         const resolved = resolutions.get(key);
@@ -20058,7 +20148,7 @@ var Chunk = class _Chunk {
           this.sectionBlocks.set(index, templates.map((template) => ({ index, template, cullMask: 0, biomeTint: context?.tint })));
           this.meshDirty = true;
         } else {
-          object4 = await this.scene.addBlock(blockState3, {
+          jobs.set(index, { order, readBlock, blockState: blockState3, position: MineRenderWorld.worldToScenePosition(worldPos), options: {
             mergeMeshes: true,
             instanceMeshes: true,
             maxInstanceCount: 2e3,
@@ -20066,13 +20156,12 @@ var Chunk = class _Chunk {
             variantPosition,
             biome: context?.biome,
             biomePosition: this.biomePosition(index, blockState3, stored)
-          });
-          object4.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
+          } });
+          continue;
         }
         this.renderedBlocks.set(index, { get block() {
           return readBlock();
-        }, object: object4 });
-        if (object4) this.objectBlocks.add(index);
+        }, object: void 0 });
       } catch (error) {
         if (preserveDataOnFailure && readBlock) {
           this.renderedBlocks.set(index, { get block() {
@@ -20080,12 +20169,35 @@ var Chunk = class _Chunk {
           }, object: void 0 });
         } else this.data.assign(index, 0);
         this.fluidCells[index] = 0;
-        object4?.removeFromScene();
-        if (!failed) failure = error;
-        failed = true;
+        if (order < failureOrder) {
+          failureOrder = order;
+          failure = error;
+        }
       }
     }
-    if (failed) throw failure;
+    const pending = [...jobs];
+    const objects = await Promise.allSettled(pending.map(([, job]) => this.createBlockObject(job.blockState, job.position, job.options)));
+    for (const [i, [index, { order, readBlock }]] of pending.entries()) {
+      const result = objects[i];
+      if (result.status === "fulfilled") {
+        this.renderedBlocks.set(index, { get block() {
+          return readBlock();
+        }, object: result.value });
+        this.objectBlocks.add(index);
+      } else {
+        if (preserveDataOnFailure) {
+          this.renderedBlocks.set(index, { get block() {
+            return readBlock();
+          }, object: void 0 });
+        } else this.data.assign(index, 0);
+        this.fluidCells[index] = 0;
+        if (order < failureOrder) {
+          failureOrder = order;
+          failure = result.reason;
+        }
+      }
+    }
+    if (failureOrder < Infinity) throw failure;
     return positions;
   }
   /** Replaces every cell from parsed section data. The caller refreshes neighbor culling. */
@@ -20156,37 +20268,42 @@ var Chunk = class _Chunk {
         failed = true;
       }
     }
-    for (const { index, blockState: blockState3, biome } of perBlocks) {
-      let object4;
-      try {
-        object4 = await this.scene.addBlock(blockState3, {
-          mergeMeshes: true,
-          instanceMeshes: true,
-          maxInstanceCount: 2e3,
-          initialState: this.data.stateAt(this.data.idAt(index)).properties,
-          variantPosition: this.positionAt(index),
-          biome,
-          biomePosition: this.biomePosition(index, blockState3, this.data.stateAt(this.data.idAt(index)))
-        });
-        object4.setPosition(new Vector321(
-          this.x * 256 + index % 16 * 16,
-          this.y * 256 + Math.floor(index / 256) * 16,
-          this.z * 256 + Math.floor(index / 16) % 16 * 16
-        ));
-        this.renderedBlocks.get(index).object = object4;
+    const objects = await Promise.allSettled(perBlocks.map(({ index, blockState: blockState3, biome }) => this.createBlockObject(blockState3, new Vector321(
+      this.x * 256 + index % 16 * 16,
+      this.y * 256 + Math.floor(index / 256) * 16,
+      this.z * 256 + Math.floor(index / 16) % 16 * 16
+    ), {
+      mergeMeshes: true,
+      instanceMeshes: true,
+      maxInstanceCount: 2e3,
+      initialState: this.data.stateAt(this.data.idAt(index)).properties,
+      variantPosition: this.positionAt(index),
+      biome,
+      biomePosition: this.biomePosition(index, blockState3, this.data.stateAt(this.data.idAt(index)))
+    })));
+    for (const [i, { index }] of perBlocks.entries()) {
+      const result = objects[i];
+      if (result.status === "fulfilled") {
+        this.renderedBlocks.get(index).object = result.value;
         this.objectBlocks.add(index);
-      } catch (error) {
+      } else {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
         this.renderedBlocks.delete(index);
         this.objectBlocks.delete(index);
-        object4?.removeFromScene();
-        if (!failed) failure = error;
+        if (!failed) failure = result.reason;
         failed = true;
       }
     }
     if (failed) throw failure;
   }
+  createBlockObject(blockState3, position, options) {
+    return this.scene.addSceneObject(blockState3, () => {
+      const object4 = new BlockObject(blockState3, options);
+      object4.position.copy(position);
+      return object4;
+    }, options);
+  }
   positionAt(index) {
     return [this.x * 16 + index % 16, this.y * 16 + Math.floor(index / 256), this.z * 16 + Math.floor(index / 16) % 16];
   }
@@ -20527,6 +20644,7 @@ var Chunk = class _Chunk {
 };
 
 // src/world/WorldStreamer.ts
+var MAX_PREFETCHED_COLUMNS = 4;
 var WorldStreamer = class {
   constructor(world, source, options = {}) {
     this.world = world;
@@ -20536,6 +20654,7 @@ var WorldStreamer = class {
     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);
@@ -20580,6 +20699,12 @@ var WorldStreamer = class {
       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 ??= Promise.resolve().then(() => this.drain());
   }
@@ -20600,8 +20725,11 @@ var WorldStreamer = class {
     this.desired = [];
     this.center = void 0;
     this.loading?.controller.abort();
+    for (const read of this.reads.values()) read.controller.abort();
     return 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 {
@@ -20627,6 +20755,10 @@ var WorldStreamer = class {
           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;
@@ -20649,26 +20781,105 @@ var WorldStreamer = class {
           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 (error) {
-          try {
-            await this.unloadMany([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;
+          read.failed = true;
+          read.error = error;
+        } finally {
+          read.ready = true;
+          if (read.controller.signal.aborted || this.disposed || !this.within(position, this.loadRadius)) {
+            this.reads.delete(key);
           }
-          throw error;
+        }
+      })();
+    }
+  }
+  /** 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 (error) {
+      try {
+        await this.unloadMany(positions);
+      } 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;
     }
   }
   needsLoad(position) {