minerender 2.1.0-alpha.36 → 2.1.0-alpha.37

package/dist/browser/index.mjs

@@ -32,8 +32,8 @@ var require_dist = __commonJS({
       __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
           s = arguments[i];
-          for (var p12 in s) if (Object.prototype.hasOwnProperty.call(s, p12))
-            t[p12] = s[p12];
+          for (var p11 in s) if (Object.prototype.hasOwnProperty.call(s, p11))
+            t[p11] = s[p11];
         }
         return t;
       };
@@ -1165,12 +1165,12 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
     return a.join("/");
   }
   getFullPath() {
-    let p12 = [];
+    let p11 = [];
     if (this.type) {
-      p12.push(this.type);
+      p11.push(this.type);
     }
-    p12.push(this.path);
-    return p12.join("/");
+    p11.push(this.path);
+    return p11.join("/");
   }
   toNamespacedString() {
     return this.namespace + ":" + this.getFullPath();
@@ -1257,7 +1257,7 @@ var ModelMerger = class {
         merged.display = { ...inheritedDisplay, ...DisplayTransforms.withHandFallbacks(source.display) };
       }
     }
-    merged.hierarchy = models.map((m) => m.parent).filter((p12) => `${p12}`);
+    merged.hierarchy = models.map((m) => m.parent).filter((p11) => `${p11}`);
     merged.hierarchy.push(`${merged.parent}`);
     return merged;
   }
@@ -7191,6 +7191,87 @@ var Skins = class {
 // src/world/Chunk.ts
 import { Vector3 as Vector311 } from "three";
 
+// src/world/ChunkData.ts
+var ChunkData = class _ChunkData {
+  constructor() {
+    this.indices = new Uint16Array(4096);
+    this.palette = [void 0];
+    this.paletteIds = /* @__PURE__ */ new Map();
+    this.freeIds = [];
+    this.nbt = /* @__PURE__ */ new Map();
+  }
+  get(index) {
+    _ChunkData.validateIndex(index);
+    const entry = this.palette[this.indices[index]];
+    return entry ? _ChunkData.copyBlock(entry.state, this.nbt.get(index)) : void 0;
+  }
+  snapshot(index) {
+    _ChunkData.validateIndex(index);
+    const entry = this.palette[this.indices[index]];
+    return entry ? _ChunkData.copyBlock.bind(void 0, entry.state, this.nbt.get(index)) : void 0;
+  }
+  set(index, block) {
+    _ChunkData.validateIndex(index);
+    let state;
+    let key;
+    let nbt;
+    if (block && !_ChunkData.isAir(block)) {
+      const type = AssetKey.parse("blockstates", block.type).toNamespacedString();
+      const properties = Object.fromEntries(Object.keys(block.properties ?? {}).sort().map((name) => [name, block.properties[name]]));
+      state = Object.freeze(Object.keys(properties).length ? { type, properties: Object.freeze(properties) } : { type });
+      key = JSON.stringify([type, properties]);
+      if (block.nbt !== void 0) nbt = structuredClone(block.nbt);
+    }
+    const previousId = this.indices[index];
+    if (previousId !== 0) {
+      const previous = this.palette[previousId];
+      if (--previous.references === 0) {
+        this.paletteIds.delete(previous.key);
+        this.palette[previousId] = void 0;
+        this.freeIds.push(previousId);
+      }
+    }
+    let id = 0;
+    if (state && key !== void 0) {
+      const existingId = this.paletteIds.get(key);
+      if (existingId !== void 0) {
+        id = existingId;
+        this.palette[id].references++;
+      } else {
+        id = this.freeIds.pop() ?? this.palette.length;
+        this.palette[id] = { key, state, references: 1 };
+        this.paletteIds.set(key, id);
+      }
+    }
+    this.indices[index] = id;
+    if (nbt !== void 0) this.nbt.set(index, nbt);
+    else this.nbt.delete(index);
+  }
+  clear() {
+    this.indices.fill(0);
+    this.palette.length = 1;
+    this.paletteIds.clear();
+    this.freeIds.length = 0;
+    this.nbt.clear();
+  }
+  static isAir(block) {
+    if (typeof block === "undefined" || typeof block.type === "undefined") return true;
+    const key = AssetKey.parse("blockstates", block.type);
+    return key.namespace === "minecraft" && !key.type && ["air", "cave_air", "void_air"].includes(key.path);
+  }
+  static copyBlock(state, nbt) {
+    const block = { type: state.type };
+    if (state.properties) block.properties = { ...state.properties };
+    if (nbt !== void 0) block.nbt = structuredClone(nbt);
+    return block;
+  }
+  static validateIndex(index) {
+    if (!Number.isInteger(index) || index < 0 || index >= 4096) {
+      throw new RangeError("Block index must be an integer from 0 to 4095");
+    }
+  }
+};
+
 // src/world/MineRenderWorld.ts
 import { Vector3 as Vector310 } from "three";
 var MineRenderWorld = class {
@@ -7301,10 +7382,10 @@ var MineRenderWorld = class {
 };
 
 // src/world/Chunk.ts
-var p11 = prefix("Chunk");
 var Chunk = class _Chunk {
   constructor(scene, x, y, z) {
-    this._blocks = [];
+    this.data = new ChunkData();
+    this.renderedBlocks = /* @__PURE__ */ new Map();
     this.scene = scene;
     this.x = x;
     this.y = y;
@@ -7319,7 +7400,7 @@ var Chunk = class _Chunk {
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
-    return this._blocks[index];
+    return this.renderedBlocks.get(index);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
@@ -7341,44 +7422,47 @@ var Chunk = class _Chunk {
       worldPos = this.chunkPosToWorldPos(pos);
     }
     const index = _Chunk.chunkPosToBlockIndex(pos);
-    const current = this._blocks[index];
-    if (typeof current !== "undefined") {
-      console.debug(p11, "deleting existing block at", pos, worldPos, index);
-      current.object.removeFromScene();
-      delete this._blocks[index];
-    }
-    if (!block || _Chunk.isAir(block)) return void 0;
-    const blockState = await BlockStates.get(AssetKey.parse("blockstates", block.type));
-    if (blockState) {
-      const blockObject = await this.scene.addBlock(blockState, {
+    this.data.set(index, block);
+    const readBlock = this.data.snapshot(index);
+    this.renderedBlocks.get(index)?.object.removeFromScene();
+    this.renderedBlocks.delete(index);
+    if (!readBlock) return void 0;
+    const stored = readBlock();
+    let object;
+    try {
+      const blockState = await BlockStates.get(AssetKey.parse("blockstates", stored.type));
+      if (!blockState) {
+        this.data.set(index, void 0);
+        return void 0;
+      }
+      object = await this.scene.addBlock(blockState, {
         mergeMeshes: true,
         instanceMeshes: true,
         maxInstanceCount: 2e3
       });
-      if (block.properties) {
-        await blockObject.setState(block.properties);
-      }
-      const scenePos = MineRenderWorld.worldToScenePosition(worldPos);
-      blockObject.setPosition(scenePos);
-      this._blocks[index] = {
-        block,
-        object: blockObject
-      };
-      return this._blocks[index];
+      if (stored.properties) await object.setState(stored.properties);
+      object.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
+      const info = { get block() {
+        return readBlock();
+      }, object };
+      this.renderedBlocks.set(index, info);
+      return info;
+    } catch (error) {
+      this.data.set(index, void 0);
+      object?.removeFromScene();
+      throw error;
     }
-    return void 0;
   }
   async clear() {
-    this._blocks.forEach((block) => block.object.removeFromScene());
-    this._blocks.length = 0;
+    for (const info of this.renderedBlocks.values()) info.object.removeFromScene();
+    this.renderedBlocks.clear();
+    this.data.clear();
   }
   async dispose() {
     await this.clear();
   }
   static isAir(block) {
-    if (typeof block === "undefined" || typeof block.type === "undefined") return true;
-    const key = AssetKey.parse("blockstates", block.type);
-    return key.namespace === "minecraft" && !key.type && ["air", "cave_air", "void_air"].includes(key.path);
+    return ChunkData.isAir(block);
   }
   static chunkPosToBlockIndex(pos) {
     if ([pos.x, pos.y, pos.z].some((value) => !Number.isInteger(value) || value < 0 || value >= 16)) {
@@ -7425,6 +7509,7 @@ export {
   Caching,
   CanvasImage,
   Chunk,
+  ChunkData,
   CubeFace,
   CubeFaceIndex,
   DEFAULT_ELEMENTS,