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

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();
@@ -103239,6 +103237,7 @@ gl_FragDepth=readDepth(vUv);
   init_dirname();
   init_buffer2();
   init_process2();
+  init_BlockObject();
   init_three_module();
   init_BlockStates();
   init_AssetKey();
@@ -103252,6 +103251,7 @@ gl_FragDepth=readDepth(vUv);
   init_util();
   init_AssetKey();
   init_BlockStates();
+  init_BlockEntities();
   init_CubeFace();
 
   // src/world/SectionModels.ts
@@ -103352,6 +103352,10 @@ gl_FragDepth=readDepth(vUv);
         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());
@@ -103374,22 +103378,24 @@ gl_FragDepth=readDepth(vUv);
     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 [i4, result] of settled.entries()) {
+        if (result.status === "rejected") throw result.reason;
+        if (!result.value) return void 0;
+        prepared.set(variants[i4], result.value);
       }
       return { state, groups, choices: prepared };
     }
@@ -103867,6 +103873,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 +103987,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();
             }
@@ -104081,15 +104088,18 @@ gl_FragDepth=readDepth(vUv);
         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, i4) => [key, loaded[i4]]));
       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 [x4, y5, z4] = block.position;
           this.validatePosBounds(position.set(x4, y5, z4));
           const cx = Math.floor(x4 / 16), cy = Math.floor(y5 / 16), cz = Math.floor(z4 / 16);
@@ -104100,6 +104110,16 @@ gl_FragDepth=readDepth(vUv);
           if (!group) groups2.set(chunk, group = []);
           group.push({ index: (y5 - cy * 16) * 256 + (z4 - cz * 16) * 16 + x4 - 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;
       }
@@ -104135,7 +104155,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 +104163,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 +104280,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 +104303,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 +104338,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 +104477,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) {
@@ -105372,8 +105461,10 @@ gl_FragDepth=readDepth(vUv);
         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);
@@ -105389,7 +105480,6 @@ gl_FragDepth=readDepth(vUv);
           this.z * 16 + Math.floor(index / 16) % 16
         );
         positions.push(worldPos);
-        let object4;
         try {
           if (!readBlock) continue;
           const resolved = resolutions.get(key);
@@ -105411,7 +105501,7 @@ gl_FragDepth=readDepth(vUv);
             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,
@@ -105419,13 +105509,12 @@ gl_FragDepth=readDepth(vUv);
               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 (error2) {
           if (preserveDataOnFailure && readBlock) {
             this.renderedBlocks.set(index, { get block() {
@@ -105433,12 +105522,35 @@ gl_FragDepth=readDepth(vUv);
             }, object: void 0 });
           } else this.data.assign(index, 0);
           this.fluidCells[index] = 0;
-          object4?.removeFromScene();
-          if (!failed) failure = error2;
-          failed = true;
+          if (order < failureOrder) {
+            failureOrder = order;
+            failure = error2;
+          }
         }
       }
-      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 [i4, [index, { order, readBlock }]] of pending.entries()) {
+        const result = objects[i4];
+        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. */
@@ -105509,37 +105621,42 @@ gl_FragDepth=readDepth(vUv);
           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 Vector3(
-            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 Vector3(
+        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 [i4, { index }] of perBlocks.entries()) {
+        const result = objects[i4];
+        if (result.status === "fulfilled") {
+          this.renderedBlocks.get(index).object = result.value;
           this.objectBlocks.add(index);
-        } catch (error2) {
+        } else {
           this.data.assign(index, 0);
           this.fluidCells[index] = 0;
           this.renderedBlocks.delete(index);
           this.objectBlocks.delete(index);
-          object4?.removeFromScene();
-          if (!failed) failure = error2;
+          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];
     }
@@ -105898,6 +106015,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 +106025,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 +106070,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 +106096,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 +106126,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 +106152,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) {