minerender 2.1.0-alpha.143 → 2.1.0-alpha.144

package/dist/bundle.js

@@ -103237,6 +103237,7 @@ gl_FragDepth=readDepth(vUv);
   init_dirname();
   init_buffer2();
   init_process2();
+  init_BlockObject();
   init_three_module();
   init_BlockStates();
   init_AssetKey();
@@ -103250,6 +103251,7 @@ gl_FragDepth=readDepth(vUv);
   init_util();
   init_AssetKey();
   init_BlockStates();
+  init_BlockEntities();
   init_CubeFace();
 
   // src/world/SectionModels.ts
@@ -103350,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());
@@ -103372,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 };
     }
@@ -104080,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);
@@ -104099,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;
       }
@@ -105440,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);
@@ -105457,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);
@@ -105479,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,
@@ -105487,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() {
@@ -105501,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. */
@@ -105577,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];
     }