minerender 2.1.0-beta.6 → 2.1.0-beta.8

package/dist/browser/esm/world/MineRenderWorld.mjs

@@ -3,8 +3,10 @@ import { Vector3 } from "three";
 import { isTripleArray } from "../model/Model.mjs";
 import { yieldToEventLoop } from "../util/util.mjs";
 import { Chunk } from "./Chunk.mjs";
+import { ChunkData } from "./ChunkData.mjs";
 import { AssetKey } from "../assets/AssetKey.mjs";
 import { BlockStates } from "../assets/BlockStates.mjs";
+import { BlockEntities } from "../assets/BlockEntities.mjs";
 import { CUBE_FACE_OFFSETS } from "../CubeFace.mjs";
 import { SectionModels } from "./SectionModels.mjs";
 import { WorldEntities } from "./_entities/WorldEntities.mjs";
@@ -12,6 +14,9 @@ import { fluidKindOf } from "../model/fluid/FluidQuads.mjs";
 import { BiomeBlend, validateBiomeBlendRadius } from "./_biomes/BiomeBlend.mjs";
 import { copySectionLight, sampleSectionLight } from "./WorldLight.mjs";
 import { loadBlockCulling } from "./_culling/BlockCulling.mjs";
+import { logger } from "../util/log.mjs";
+var log = logger("MineRenderWorld");
+var YIELD_INTERVAL_MS = 8;
 var MineRenderWorld = class {
   constructor(scene, options = {}) {
     this._chunks = /* @__PURE__ */ new Map();
@@ -101,8 +106,14 @@ var MineRenderWorld = class {
     }
     return queued;
   }
-  async refreshBiomes() {
-    if (this.biomeRefreshing) await this.biomeRefreshing;
+  async refreshBiomes(deferCulling = false) {
+    if (this.biomeRefreshing) {
+      await this.biomeRefreshing;
+      if (!deferCulling) {
+        if (this.pendingCulling.size) await this.updateCulling([]);
+        else await this.culling;
+      }
+    }
     if (!this.pendingBiomes.size) return /* @__PURE__ */ new Map();
     return this.biomeRefreshing ?? (this.biomeRefreshing = Promise.resolve().then(async () => {
       const failures = /* @__PURE__ */ new Map();
@@ -114,12 +125,12 @@ var MineRenderWorld = class {
           this.pendingBiomes.delete(chunk);
           if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) !== chunk) continue;
           try {
-            await chunk.refreshBiomes(columns);
+            await chunk.refreshBiomes(columns, deferCulling);
           } catch (error) {
             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();
           }
@@ -220,15 +231,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 Vector3();
       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);
@@ -239,6 +253,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;
     }
@@ -274,7 +298,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();
       }
@@ -282,6 +306,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) log.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");
     }
@@ -343,7 +423,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();
           }
@@ -366,9 +446,12 @@ var MineRenderWorld = class {
       await placeEntities?.();
     } finally {
       this.markBiomesChanged(chunk.x, chunk.z, void 0, false);
-      const failures = await this.refreshBiomes();
-      if (failures.size) console.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) log.warn("Failed to refresh biome colors", failures.values().next().value);
+        await this.updateCulling([...changes.values()]);
+      }
     }
   }
   /**
@@ -376,16 +459,36 @@ var MineRenderWorld = class {
    * Coordinates match AnvilChunk.x/z, not block positions. Missing columns are ignored.
    */
   async unloadChunkColumn(x, z) {
-    if (!Number.isInteger(x) || !Number.isInteger(z)) {
-      throw new RangeError("Chunk column coordinates must be integers");
+    return this.unloadChunkColumns([{ x, z }]);
+  }
+  /**
+   * Removes chunk columns together and refreshes surviving neighbors once.
+   * Coordinates are absolute chunk columns. Duplicate and missing columns are ignored.
+   */
+  async unloadChunkColumns(positions) {
+    const columns = /* @__PURE__ */ new Map();
+    for (const position of positions) {
+      const { x, z } = position ?? {};
+      if (!Number.isInteger(x) || !Number.isInteger(z)) {
+        throw new RangeError("Chunk column coordinates must be integers");
+      }
+      columns.set(`${x}_${z}`, { x, z });
     }
-    this.entities?.clearColumn(x, z);
+    if (!columns.size) return;
     await this.culling;
+    let sliceStart = performance.now();
     try {
-      await this.clearChunkColumn(x, z);
+      for (const { x, z } of columns.values()) {
+        this.entities?.clearColumn(x, z);
+        await this.clearChunkColumn(x, z);
+        if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
+          await yieldToEventLoop();
+          sliceStart = performance.now();
+        }
+      }
     } finally {
-      const failures = await this.refreshBiomes();
-      if (failures.size) console.warn("Failed to refresh biome colors", failures.values().next().value);
+      const failures = await this.refreshBiomes(true);
+      if (failures.size) log.warn("Failed to refresh biome colors", failures.values().next().value);
       await this.updateCulling([]);
     }
   }
@@ -447,7 +550,7 @@ var MineRenderWorld = class {
     }
     this.sectionModels?.clear();
   }
-  updateCulling(positions) {
+  updateCulling(positions, defer = false) {
     const neighbor = new Vector3();
     for (const pos of positions) {
       const cx = Math.floor(pos.x / 16), cy = Math.floor(pos.y / 16), cz = Math.floor(pos.z / 16);
@@ -469,58 +572,82 @@ var MineRenderWorld = class {
         }
       }
     }
+    if (defer) return Promise.resolve();
     return this.culling ?? (this.culling = Promise.resolve().then(async () => {
       let sliceStart = performance.now();
       try {
         const culling = await loadBlockCulling();
         while (this.pendingCulling.size) {
-          const batch = [...this.pendingCulling];
+          const batch = new Map(this.pendingCulling);
           this.pendingCulling.clear();
-          for (const [chunk, indices] of batch) {
-            const neighbors = CUBE_FACE_OFFSETS.map(([x, y, z]) => this._chunks.get(`${chunk.x + x}_${chunk.y + y}_${chunk.z + z}`));
-            const neighborAt = (x, y, z) => {
-              const lx = x - chunk.x * 16, ly = y - chunk.y * 16, lz = z - chunk.z * 16;
-              const section = neighbors[lx >= 16 ? 0 : lx < 0 ? 1 : ly >= 16 ? 2 : ly < 0 ? 3 : lz >= 16 ? 4 : 5];
-              return [section, (ly & 15) * 256 + (lz & 15) * 16 + (lx & 15)];
-            };
-            const masks = chunk.updateCullMasks(indices === "all" ? void 0 : indices, (x, y, z) => {
-              const [section, i] = neighborAt(x, y, z);
-              return section?.isOccludingIndex(i) ?? false;
-            }, culling, (x, y, z) => {
-              const [section, i] = neighborAt(x, y, z);
-              return section?.visibleBlockIndex(i);
-            });
-            const fluidIndices = indices === "all" ? function* () {
-              for (let index = 0; index < 4096; index++) yield index;
-            }() : indices;
-            for (const index of fluidIndices) {
-              if (!chunk.fluidByteIndex(index) || !chunk.isBlockVisibleIndex(index)) continue;
-              const lx = index % 16, ly = Math.floor(index / 256), lz = Math.floor(index / 16) % 16;
-              const wx = chunk.x * 16 + lx, wy = chunk.y * 16 + ly, wz = chunk.z * 16 + lz;
-              const block = chunk.getBlockAt(neighbor.set(wx, wy, wz));
-              if (block.object?.fluidKind) {
-                await block.object.updateFluid((x, y, z) => {
-                  const nx = lx + x, ny = ly + y, nz = lz + z;
-                  const section = nx >= 0 && nx < 16 && ny >= 0 && ny < 16 && nz >= 0 && nz < 16 ? chunk : this._chunks.get(`${chunk.x + Math.floor(nx / 16)}_${chunk.y + Math.floor(ny / 16)}_${chunk.z + Math.floor(nz / 16)}`);
-                  const neighborIndex = (ny & 15) * 256 + (nz & 15) * 16 + (nx & 15);
-                  const byte = section?.fluidByteIndex(neighborIndex) ?? 0;
-                  return {
-                    fluid: fluidKindOf(byte),
-                    level: byte & 15,
-                    solid: section?.isOccludingIndex(neighborIndex) ?? false
-                  };
-                });
+          try {
+            for (const [chunk, indices] of batch) {
+              const neighbors = CUBE_FACE_OFFSETS.map(([x, y, z]) => this._chunks.get(`${chunk.x + x}_${chunk.y + y}_${chunk.z + z}`));
+              const neighborAt = (x, y, z) => {
+                const lx = x - chunk.x * 16, ly = y - chunk.y * 16, lz = z - chunk.z * 16;
+                const section = neighbors[lx >= 16 ? 0 : lx < 0 ? 1 : ly >= 16 ? 2 : ly < 0 ? 3 : lz >= 16 ? 4 : 5];
+                return [section, (ly & 15) * 256 + (lz & 15) * 16 + (lx & 15)];
+              };
+              const masks = chunk.updateCullMasks(indices === "all" ? void 0 : indices, (x, y, z) => {
+                const [section, i] = neighborAt(x, y, z);
+                return section?.isOccludingIndex(i) ?? false;
+              }, culling, (x, y, z) => {
+                const [section, i] = neighborAt(x, y, z);
+                return section?.visibleBlockIndex(i);
+              });
+              const fluidIndices = indices === "all" ? function* () {
+                for (let index = 0; index < 4096; index++) yield index;
+              }() : indices;
+              for (const index of fluidIndices) {
+                if (!chunk.fluidByteIndex(index) || !chunk.isBlockVisibleIndex(index)) continue;
+                const lx = index % 16, ly = Math.floor(index / 256), lz = Math.floor(index / 16) % 16;
+                const wx = chunk.x * 16 + lx, wy = chunk.y * 16 + ly, wz = chunk.z * 16 + lz;
+                const block = chunk.getBlockAt(neighbor.set(wx, wy, wz));
+                if (block.object?.fluidKind) {
+                  await block.object.updateFluid((x, y, z) => {
+                    const nx = lx + x, ny = ly + y, nz = lz + z;
+                    const section = nx >= 0 && nx < 16 && ny >= 0 && ny < 16 && nz >= 0 && nz < 16 ? chunk : this._chunks.get(`${chunk.x + Math.floor(nx / 16)}_${chunk.y + Math.floor(ny / 16)}_${chunk.z + Math.floor(nz / 16)}`);
+                    const neighborIndex = (ny & 15) * 256 + (nz & 15) * 16 + (nx & 15);
+                    const byte = section?.fluidByteIndex(neighborIndex) ?? 0;
+                    return {
+                      fluid: fluidKindOf(byte),
+                      level: byte & 15,
+                      solid: section?.isOccludingIndex(neighborIndex) ?? false
+                    };
+                  });
+                }
+              }
+              for (const [index, mask] of masks) await chunk.setCullMaskIndex(index, mask);
+              await chunk.refreshLight(indices === "all" ? void 0 : indices);
+              chunk.refreshAmbientOcclusion(this._ambientOcclusion);
+              if (performance.now() - sliceStart > YIELD_INTERVAL_MS) {
+                await yieldToEventLoop();
+                sliceStart = performance.now();
+              }
+            }
+            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();
               }
             }
-            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) {
-              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) {
+            for (const [chunk, indices] of batch) {
+              const pending = this.pendingCulling.get(chunk);
+              this.pendingCulling.set(chunk, indices === "all" || pending === "all" ? "all" : /* @__PURE__ */ new Set([...indices, ...pending ?? []]));
             }
+            throw error;
           }
-          await Promise.all(batch.map(([chunk]) => chunk.rebuildSectionMesh()));
         }
       } finally {
         this.culling = void 0;
@@ -537,7 +664,7 @@ var MineRenderWorld = class {
         x,
         y,
         z,
-        (positions) => this.updateCulling(positions),
+        (positions, defer) => this.updateCulling(positions, defer),
         this.sectionModels,
         (x2, y2, z2) => {
           const cx = Math.floor(x2 / 16), cy = Math.floor(y2 / 16), cz = Math.floor(z2 / 16);