minerender 2.1.0-alpha.39 → 2.1.0-alpha.40

package/dist/node/index.mjs

@@ -4719,19 +4719,19 @@ var BlockObject = class _BlockObject extends SceneObject {
         for (let k in defaultState) {
           state[k] = defaultState[k].default;
         }
-        await this.setState(state);
+        this._setState(state);
       } else {
         if (this.blockState.variants) {
-          await this.setState(Object.keys(this.blockState.variants)[0]);
+          this._setState(Object.keys(this.blockState.variants)[0]);
         } else if (this.blockState.multipart) {
           const condition = this.blockState.multipart.map((part) => part.when).find((when) => when !== void 0 && Object.values(when).every((value) => typeof value === "string"));
           const state = Object.fromEntries(Object.entries(condition ?? {}).map(([key, value]) => [key, value.split("|")[0]]));
-          await this.setState(state);
+          this._setState(state);
         }
       }
-    } else {
-      await this.recreateModels();
     }
+    if (this.options.initialState !== void 0) this._setState(this.options.initialState);
+    await this.recreateModels();
   }
   dispose() {
     this.clearModels();
@@ -9420,12 +9420,26 @@ var MineRenderWorld = class {
     if (isTripleArray(posOrX)) {
       return this.setBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
-    this.validatePosBounds(posOrX);
-    const value = yOrBlock;
-    const chunk = Chunk.isAir(value) ? this.getChunkAt(posOrX) : this.getOrCreateChunkAt(posOrX);
-    return chunk?.setBlockAt(posOrX, value);
+    return this.placeBlock(posOrX, yOrBlock);
+  }
+  async placeBlock(pos, value, onBlocksChanged) {
+    this.validatePosBounds(pos);
+    const chunk = Chunk.isAir(value) ? this.getChunkAt(pos) : this.getOrCreateChunkAt(pos);
+    return chunk?.setBlockInChunkAt(chunk.worldPosToChunkPos(pos), value, pos, onBlocksChanged);
   }
   async placeMultiBlock(multiblock, useBatches = true, executor) {
+    const changes = /* @__PURE__ */ new Map();
+    try {
+      await this.placeBlocks(multiblock, useBatches, executor, changes);
+    } finally {
+      await this.updateCulling([...changes.values()]);
+    }
+  }
+  async placeBlocks(multiblock, useBatches, executor, changes) {
+    const collect = async (positions2) => {
+      for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
+    };
+    const place = (block) => this.placeBlock(new Vector311(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -9434,7 +9448,7 @@ var MineRenderWorld = class {
     }
     await BlockStates.getAll(keys.values());
     if (!useBatches) {
-      for (const block of multiblock.blocks) await this.setBlockAt(block.position, block);
+      for (const block of multiblock.blocks) await place(block);
       return;
     }
     const positions = /* @__PURE__ */ new Map();
@@ -9450,7 +9464,7 @@ var MineRenderWorld = class {
       for (let i = 0; i < groups.length; i += queue.batch) {
         const results = await Promise.allSettled(groups.slice(i, i + queue.batch).map(
           (blocks) => queue.submit(async () => {
-            for (const block of blocks) await this.setBlockAt(block.position, block);
+            for (const block of blocks) await place(block);
           })
         ));
         const failure = results.find((result) => result.status === "rejected");
@@ -9462,25 +9476,32 @@ var MineRenderWorld = class {
   }
   /** Replaces one chunk column's blocks. Entity NBT remains available on the parsed chunk. */
   async placeChunk(chunk, executor) {
-    const previous = [...this._chunks.entries()].filter(([, section]) => section.x === chunk.x && section.z === chunk.z);
-    for (const [key, section] of previous) {
-      this._chunks.delete(key);
-      await section.dispose();
-    }
-    for (const section of chunk.sections) {
-      const blocks = [];
-      for (let index = 0; index < 4096; index++) {
-        const block = section.data.get(index);
-        if (block) blocks.push({
-          ...block,
-          position: [
-            chunk.x * 16 + index % 16,
-            section.y * 16 + Math.floor(index / 256),
-            chunk.z * 16 + Math.floor(index / 16) % 16
-          ]
+    const changes = /* @__PURE__ */ new Map();
+    try {
+      const previous = [...this._chunks.entries()].filter(([, section]) => section.x === chunk.x && section.z === chunk.z);
+      for (const [key, section] of previous) {
+        this._chunks.delete(key);
+        await section.clear(async (positions) => {
+          for (const pos of positions) changes.set(pos.toArray().join(","), pos);
         });
       }
-      await this.placeMultiBlock({ size: [16, 16, 16], blocks }, true, executor);
+      for (const section of chunk.sections) {
+        const blocks = [];
+        for (let index = 0; index < 4096; index++) {
+          const block = section.data.get(index);
+          if (block) blocks.push({
+            ...block,
+            position: [
+              chunk.x * 16 + index % 16,
+              section.y * 16 + Math.floor(index / 256),
+              chunk.z * 16 + Math.floor(index / 16) % 16
+            ]
+          });
+        }
+        await this.placeBlocks({ size: [16, 16, 16], blocks }, true, executor, changes);
+      }
+    } finally {
+      await this.updateCulling([...changes.values()]);
     }
   }
   async clear() {
@@ -9603,7 +9624,7 @@ var Chunk = class _Chunk {
   /**
    * Set a block at integer chunk-local coordinates from 0 to 15.
    */
-  async setBlockInChunkAt(pos, block, worldPos) {
+  async setBlockInChunkAt(pos, block, worldPos, onBlocksChanged = this.onBlocksChanged) {
     if (typeof worldPos === "undefined") {
       worldPos = this.chunkPosToWorldPos(pos);
     }
@@ -9624,9 +9645,9 @@ var Chunk = class _Chunk {
       object = await this.scene.addBlock(blockState, {
         mergeMeshes: true,
         instanceMeshes: true,
-        maxInstanceCount: 2e3
+        maxInstanceCount: 2e3,
+        initialState: stored.properties
       });
-      if (stored.properties) await object.setState(stored.properties);
       object.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
       const info = { get block() {
         return readBlock();
@@ -9638,17 +9659,17 @@ var Chunk = class _Chunk {
       object?.removeFromScene();
       throw error;
     } finally {
-      await this.onBlocksChanged?.([worldPos]);
+      await onBlocksChanged?.([worldPos]);
     }
   }
-  async clear() {
+  async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
       new Vector312(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
     for (const info of this.renderedBlocks.values()) info.object.removeFromScene();
     this.renderedBlocks.clear();
     this.data.clear();
-    await this.onBlocksChanged?.(positions);
+    await onBlocksChanged?.(positions);
   }
   async dispose() {
     await this.clear();