minerender 2.1.0-alpha.137 → 2.1.0-alpha.138

package/dist/bundle.js

@@ -103880,8 +103880,14 @@ gl_FragDepth=readDepth(vUv);
       }
       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();
@@ -103893,7 +103899,7 @@ gl_FragDepth=readDepth(vUv);
             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 (error2) {
               failures.set(chunk, error2);
               if (this._chunks.get(`${chunk.x}_${chunk.y}_${chunk.z}`) === chunk) this.pendingBiomes.set(chunk, void 0);
@@ -104155,15 +104161,35 @@ gl_FragDepth=readDepth(vUv);
      * Coordinates match AnvilChunk.x/z, not block positions. Missing columns are ignored.
      */
     async unloadChunkColumn(x4, z4) {
-      if (!Number.isInteger(x4) || !Number.isInteger(z4)) {
-        throw new RangeError("Chunk column coordinates must be integers");
+      return this.unloadChunkColumns([{ x: x4, z: z4 }]);
+    }
+    /**
+     * 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: x4, z: z4 } = position ?? {};
+        if (!Number.isInteger(x4) || !Number.isInteger(z4)) {
+          throw new RangeError("Chunk column coordinates must be integers");
+        }
+        columns.set(`${x4}_${z4}`, { x: x4, z: z4 });
       }
-      this.entities?.clearColumn(x4, z4);
+      if (!columns.size) return;
       await this.culling;
+      let sliceStart = performance.now();
       try {
-        await this.clearChunkColumn(x4, z4);
+        for (const { x: x4, z: z4 } of columns.values()) {
+          this.entities?.clearColumn(x4, z4);
+          await this.clearChunkColumn(x4, z4);
+          if (performance.now() - sliceStart > 8) {
+            await yieldToEventLoop();
+            sliceStart = performance.now();
+          }
+        }
       } finally {
-        const failures = await this.refreshBiomes();
+        const failures = await this.refreshBiomes(true);
         if (failures.size) log21.warn("Failed to refresh biome colors", failures.values().next().value);
         await this.updateCulling([]);
       }
@@ -104226,7 +104252,7 @@ gl_FragDepth=readDepth(vUv);
       }
       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);
@@ -104248,58 +104274,72 @@ gl_FragDepth=readDepth(vUv);
           }
         }
       }
+      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(([x4, y5, z4]) => this._chunks.get(`${chunk.x + x4}_${chunk.y + y5}_${chunk.z + z4}`));
-              const neighborAt = (x4, y5, z4) => {
-                const lx = x4 - chunk.x * 16, ly = y5 - chunk.y * 16, lz = z4 - 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, (x4, y5, z4) => {
-                const [section, i4] = neighborAt(x4, y5, z4);
-                return section?.isOccludingIndex(i4) ?? false;
-              }, culling, (x4, y5, z4) => {
-                const [section, i4] = neighborAt(x4, y5, z4);
-                return section?.visibleBlockIndex(i4);
-              });
-              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((x4, y5, z4) => {
-                    const nx = lx + x4, ny = ly + y5, nz = lz + z4;
-                    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(([x4, y5, z4]) => this._chunks.get(`${chunk.x + x4}_${chunk.y + y5}_${chunk.z + z4}`));
+                const neighborAt = (x4, y5, z4) => {
+                  const lx = x4 - chunk.x * 16, ly = y5 - chunk.y * 16, lz = z4 - 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, (x4, y5, z4) => {
+                  const [section, i4] = neighborAt(x4, y5, z4);
+                  return section?.isOccludingIndex(i4) ?? false;
+                }, culling, (x4, y5, z4) => {
+                  const [section, i4] = neighborAt(x4, y5, z4);
+                  return section?.visibleBlockIndex(i4);
+                });
+                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((x4, y5, z4) => {
+                      const nx = lx + x4, ny = ly + y5, nz = lz + z4;
+                      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 ((this._ambientOcclusion || this.ambientOcclusionPending) && performance.now() - sliceStart > 8) {
+                  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([...batch.keys()].map(async (chunk) => {
+                await chunk.rebuildSectionMesh();
+                batch.delete(chunk);
+              }));
+              const failure = builds.find((result) => result.status === "rejected");
+              if (failure?.status === "rejected") throw failure.reason;
+            } catch (error2) {
+              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 error2;
             }
-            await Promise.all(batch.map(([chunk]) => chunk.rebuildSectionMesh()));
           }
         } finally {
           this.culling = void 0;
@@ -104316,7 +104356,7 @@ gl_FragDepth=readDepth(vUv);
           x4,
           y5,
           z4,
-          (positions) => this.updateCulling(positions),
+          (positions, defer) => this.updateCulling(positions, defer),
           this.sectionModels,
           (x5, y6, z5) => {
             const cx = Math.floor(x5 / 16), cy = Math.floor(y6 / 16), cz = Math.floor(z5 / 16);
@@ -105065,11 +105105,14 @@ gl_FragDepth=readDepth(vUv);
       this.biomes = copy;
       return this.refreshBiomes();
     }
-    /** Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects. */
-    refreshBiomes(columns) {
-      return this.changeBlocks(() => this.refreshBiomeBlocks(columns), true);
+    /**
+     * Rebuilds biome-tinted blocks while preserving hidden blocks and unrelated render objects.
+     * The owning world can defer neighbor culling until all affected chunks are refreshed.
+     */
+    refreshBiomes(columns, deferCulling = false) {
+      return this.changeBlocks(() => this.refreshBiomeBlocks(columns, deferCulling), true);
     }
-    async refreshBiomeBlocks(columns) {
+    async refreshBiomeBlocks(columns, deferCulling = false) {
       const blend = columns && this.biomeBlend?.();
       const ownColumn = columns?.some((column) => column.x === this.x && column.z === this.z);
       const affected = /* @__PURE__ */ new Map();
@@ -105126,7 +105169,7 @@ gl_FragDepth=readDepth(vUv);
           this.renderedBlocks.get(index)?.object?.setVisible(false);
         }
         const positions = blocks.map(({ index }) => new Vector3(...this.positionAt(index)));
-        if (this.onBlocksChanged) await this.onBlocksChanged(positions);
+        if (this.onBlocksChanged) await this.onBlocksChanged(positions, deferCulling);
         else await this.rebuildSectionMesh();
       }
     }
@@ -105798,19 +105841,12 @@ gl_FragDepth=readDepth(vUv);
       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);
-          }
+        try {
+          await this.unloadMany([...this.owned.values()]);
+        } finally {
+          this.missing.clear();
+          this.failed.clear();
         }
-        this.missing.clear();
-        this.failed.clear();
-        if (failed) throw failure;
       }).catch((error2) => {
         this.disposal = void 0;
         throw error2;
@@ -105825,9 +105861,9 @@ gl_FragDepth=readDepth(vUv);
           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);
+          const obsolete = [...this.owned.values()].filter((position2) => !this.loaded.has(this.key(position2)) || !this.within(position2, this.unloadRadius));
+          if (obsolete.length) {
+            await this.unloadMany(obsolete);
             continue;
           }
           const position = this.desired.find((position2) => this.needsLoad(position2));
@@ -105857,7 +105893,7 @@ gl_FragDepth=readDepth(vUv);
             this.loaded.set(this.key(position), position);
           } catch (error2) {
             try {
-              await this.unload(position);
+              await this.unloadMany([position]);
             } catch (cleanupError) {
               const failure = error2 instanceof Error ? error2 : new Error(String(error2));
               try {
@@ -105878,10 +105914,18 @@ gl_FragDepth=readDepth(vUv);
       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));
+    async unloadMany(positions) {
+      if (!positions.length) return;
+      try {
+        await this.world.unloadChunkColumns(positions.map(({ x: x4, z: z4 }) => ({ x: x4, z: z4 })));
+      } catch (error2) {
+        for (const position of positions) this.loaded.delete(this.key(position));
+        throw error2;
+      }
+      for (const position of positions) {
+        this.owned.delete(this.key(position));
+        this.loaded.delete(this.key(position));
+      }
     }
     validateChunk(chunk, position) {
       if (chunk.x !== position.x || chunk.z !== position.z) {