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

package/dist/bundle.js

@@ -83177,19 +83177,19 @@ ${key}` : key;
           for (let k4 in defaultState) {
             state[k4] = defaultState[k4].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();
@@ -89740,12 +89740,26 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       if (isTripleArray(posOrX)) {
         return this.setBlockAt(new Vector3(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 Vector3(...block.position), block, collect);
       const keys = /* @__PURE__ */ new Map();
       for (const block of multiblock.blocks) {
         if (Chunk.isAir(block)) continue;
@@ -89754,7 +89768,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
       }
       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();
@@ -89770,7 +89784,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         for (let i4 = 0; i4 < groups.length; i4 += queue2.batch) {
           const results = await Promise.allSettled(groups.slice(i4, i4 + queue2.batch).map(
             (blocks) => queue2.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");
@@ -89782,25 +89796,32 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
     }
     /** 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() {
@@ -89923,7 +89944,7 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
     /**
      * 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);
       }
@@ -89944,9 +89965,9 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         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();
@@ -89958,17 +89979,17 @@ uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuf
         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 Vector3(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();