minerender 2.1.0-alpha.36 → 2.1.0-alpha.38

package/dist/node/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;
       };
@@ -278,6 +278,14 @@ var CubeFaceIndex = /* @__PURE__ */ ((CubeFaceIndex2) => {
   return CubeFaceIndex2;
 })(CubeFaceIndex || {});
 var CUBE_FACES = Object.values(CubeFace);
+var CUBE_FACE_OFFSETS = [
+  [1, 0, 0],
+  [-1, 0, 0],
+  [0, 1, 0],
+  [0, -1, 0],
+  [0, 0, 1],
+  [0, 0, -1]
+];
 
 // src/Disposable.ts
 function isDisposable(obj) {
@@ -1172,12 +1180,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();
@@ -1264,7 +1272,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;
   }
@@ -3849,6 +3857,42 @@ function isQuadArray(obj) {
   return Array.isArray(obj) && obj.length === 4;
 }
 
+// src/model/ModelCulling.ts
+import { Vector3 as Vector36 } from "three";
+var ModelCulling = class {
+  static toLocalMask(worldMask, rotation) {
+    let localMask = 0;
+    for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
+      const normal = new Vector36(...offset).applyEuler(rotation);
+      const worldFace = CUBE_FACE_OFFSETS.findIndex(([x, y, z]) => Math.abs(normal.x - x) < 1e-6 && Math.abs(normal.y - y) < 1e-6 && Math.abs(normal.z - z) < 1e-6);
+      if (worldFace < 0) return 0;
+      if (worldMask & 1 << worldFace) localMask |= 1 << localFace;
+    }
+    return localMask;
+  }
+  static isOpaqueFullCube(atlas) {
+    if (!atlas || atlas.hasTransparency !== false || atlas.model.elements?.length !== 1) return false;
+    const element = atlas.model.elements[0];
+    if (element.from.length !== 3 || !element.from.every((value) => value === 0) || element.to.length !== 3 || !element.to.every((value) => value === 16) || element.rotation && element.rotation.angle !== 0 || element.mappedUv?.length !== 48 || !element.mappedUv.every(Number.isFinite)) return false;
+    if (!(atlas.image.width > 0 && atlas.image.height > 0)) return false;
+    return CUBE_FACES.every((face, faceIndex) => {
+      const texture = element.faces[face]?.texture;
+      if (!texture?.startsWith("#")) return false;
+      const key = texture.slice(1);
+      const position = atlas.positions[key];
+      const size = atlas.sizes[key];
+      if (position?.length !== 2 || !position.every(Number.isFinite) || size?.length !== 2 || !size.every((value) => value > 0 && Number.isFinite(value))) return false;
+      for (let vertex = 0; vertex < 4; vertex++) {
+        const uvIndex = (faceIndex * 4 + vertex) * 2;
+        const x = element.mappedUv[uvIndex] * atlas.image.width;
+        const y = (1 - element.mappedUv[uvIndex + 1]) * atlas.image.height;
+        if (x < position[0] - 1e-6 || x > position[0] + size[0] + 1e-6 || y < position[1] - 1e-6 || y > position[1] + size[1] + 1e-6) return false;
+      }
+      return true;
+    });
+  }
+};
+
 // src/model/block/blockTints.json
 var blockTints_default = {
   "minecraft:large_fern": { source: "grass" },
@@ -3935,7 +3979,7 @@ var BlockTints = class {
 };
 
 // src/model/scene/ModelObject.ts
-import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute4, Color as Color3, Euler as Euler4, Matrix4 as Matrix44 } from "three";
+import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute4, Color as Color3, Euler as Euler5, Matrix4 as Matrix44 } from "three";
 
 // src/three/BufferGeometryUtils.js
 import {
@@ -3947,7 +3991,7 @@ import {
   TriangleFanDrawMode,
   TriangleStripDrawMode,
   TrianglesDrawMode,
-  Vector3 as Vector36
+  Vector3 as Vector37
 } from "three";
 function computeTangents(geometry) {
   geometry.computeTangents();
@@ -4266,15 +4310,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new Vector36();
-  const _vB = new Vector36();
-  const _vC = new Vector36();
-  const _tempA = new Vector36();
-  const _tempB = new Vector36();
-  const _tempC = new Vector36();
-  const _morphA = new Vector36();
-  const _morphB = new Vector36();
-  const _morphC = new Vector36();
+  const _vA = new Vector37();
+  const _vB = new Vector37();
+  const _vC = new Vector37();
+  const _tempA = new Vector37();
+  const _tempB = new Vector37();
+  const _tempC = new Vector37();
+  const _morphA = new Vector37();
+  const _morphB = new Vector37();
+  const _morphC = new Vector37();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4503,6 +4547,9 @@ var ModelObject = class _ModelObject extends SceneObject {
   get textureAtlas() {
     return this.atlas;
   }
+  get isOpaqueFullCube() {
+    return !this.options.displayPosition && ModelCulling.isOpaqueFullCube(this.atlas);
+  }
   //TODO: support for replacing textures
   async loadTextures() {
     this.atlas = await UVMapper.getAtlas(this.originalModel);
@@ -4516,8 +4563,17 @@ var ModelObject = class _ModelObject extends SceneObject {
       if (this.atlas.model.elements) {
         this.atlas.model.elements?.forEach((el) => {
           const elGeo = this._getBoxGeometryFromElement(el).clone();
+          if (this.options.cullMask) {
+            const indices = Array.from(elGeo.getIndex().array);
+            elGeo.setIndex(indices.filter((_, index) => {
+              const face = CUBE_FACES[Math.floor(index / 6)];
+              const direction = CUBE_FACES.findIndex((name) => name === el.faces[face]?.cullface);
+              return direction < 0 || !(this.options.cullMask & 1 << direction);
+            }));
+            elGeo.clearGroups();
+          }
           if (this.options.uvLockRotation) {
-            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler4(...this.options.uvLockRotation));
+            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler5(...this.options.uvLockRotation));
           }
           if (this.options.tints) {
             const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4613,7 +4669,7 @@ function isModelObject(obj) {
 
 // src/model/block/scene/BlockObject.ts
 var import_ts_deepmerge6 = __toESM(require_dist());
-import { Euler as Euler5, Matrix4 as Matrix45 } from "three";
+import { Euler as Euler6, Matrix4 as Matrix45, Quaternion as Quaternion4, Vector3 as Vector38 } from "three";
 var p10 = prefix("BlockObject");
 function matchesCondition(condition, state) {
   return Object.entries(condition).every(([key, value]) => {
@@ -4638,6 +4694,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     this._instanceModel = [];
     this._variants = [];
     this._models = [];
+    this._cullMask = 0;
     this.options = (0, import_ts_deepmerge6.default)({}, _BlockObject.DEFAULT_OPTIONS, options ?? {});
   }
   static {
@@ -4676,12 +4733,69 @@ var BlockObject = class _BlockObject extends SceneObject {
     super.removeFromScene();
   }
   clearModels() {
-    for (const model of this._models.splice(0)) {
+    this.removeModels(this._models.splice(0));
+    this._isInstanced = false;
+    this._instanceCounter = 0;
+  }
+  removeModels(models) {
+    for (const model of models) {
       model.removeFromScene();
       if (!isInstanceReference(model)) model.dispose();
     }
-    this._isInstanced = false;
-    this._instanceCounter = 0;
+  }
+  get isOccluding() {
+    return this._models.some((model) => {
+      const object = isInstanceReference(model) ? model.instanceable : model;
+      return object.isOpaqueFullCube && this.getModelCullMask(model, 63) === 63;
+    });
+  }
+  getModelMatrix(model) {
+    if (isInstanceReference(model)) return model.getMatrix();
+    if (model.matrixAutoUpdate) model.updateMatrix();
+    return model.matrix.clone();
+  }
+  getModelCullMask(model, worldMask) {
+    const object = isInstanceReference(model) ? model.instanceable : model;
+    if (object.options.displayPosition) return 0;
+    const position = new Vector38();
+    const rotation = new Quaternion4();
+    const scale = new Vector38();
+    this.getModelMatrix(model).decompose(position, rotation, scale);
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new Vector38(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new Euler6().setFromQuaternion(rotation));
+  }
+  async setCullMask(worldMask) {
+    worldMask &= 63;
+    const replacements = [];
+    try {
+      for (const model of this._models) {
+        const object = isInstanceReference(model) ? model.instanceable : model;
+        const cullMask = this.getModelCullMask(model, worldMask);
+        if (cullMask === (object.options.cullMask ?? 0)) {
+          replacements.push(model);
+          continue;
+        }
+        const matrix = this.getModelMatrix(model);
+        const replacement = await this.scene.addModel(object.originalModel, { ...object.options, cullMask });
+        replacements.push(replacement);
+        if (isInstanceReference(replacement)) {
+          replacement.setMatrix(matrix);
+        } else {
+          replacement.matrix.copy(matrix);
+          matrix.decompose(replacement.position, replacement.quaternion, replacement.scale);
+          replacement.matrixAutoUpdate = object.matrixAutoUpdate;
+          replacement.visible = object.visible;
+        }
+      }
+    } catch (error) {
+      this.removeModels(replacements.filter((model) => !this._models.includes(model)));
+      throw error;
+    }
+    const previous = this._models;
+    this._models = replacements;
+    this._cullMask = worldMask;
+    this.removeModels(previous.filter((model) => !replacements.includes(model)));
+    this.notifyDirty();
   }
   get state() {
     return this._state;
@@ -4761,7 +4875,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     await this.createVariant(variant);
   }
   async createVariant(variant) {
-    const rotation = new Euler5();
+    const rotation = new Euler6();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -4774,7 +4888,8 @@ var BlockObject = class _BlockObject extends SceneObject {
     const options = {
       ...this.options,
       tints: model ? await BlockTints.get(this.blockState.key, this.state, model, this.options.tints) : this.options.tints,
-      uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
+      uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0,
+      cullMask: this.options.displayPosition ? 0 : ModelCulling.toLocalMask(this._cullMask, rotation)
     };
     const obj = await this.scene.addModel(model, options);
     if (isInstanceReference(obj) || obj.isInstanced) {
@@ -6035,11 +6150,12 @@ var MineRenderScene = class _MineRenderScene extends Scene2 {
       console.log("instanceMeshes + key");
       let key = asset.key.serialize();
       if (isModelObject(obj)) {
-        const { displayPosition, uvLockRotation, tints } = obj.options;
+        const { displayPosition, uvLockRotation, tints, cullMask } = obj.options;
         if (displayPosition) key += `|display:${displayPosition}`;
         if (uvLockRotation) key += `|uvlock:${uvLockRotation.join(",")}`;
         const palette = Object.entries(tints ?? {}).sort(([a], [b]) => Number(a) - Number(b));
         if (palette.length) key += `|tints:${JSON.stringify(palette)}`;
+        if (cullMask) key += `|cull:${cullMask}`;
       }
       return this.instanceManager.getOrCreate(key, async () => {
         obj.scene = this;
@@ -6083,7 +6199,7 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace4, Vector3 as Vector39, WebGLRenderer } from "three";
+import { AxesHelper as AxesHelper2, GridHelper, OrthographicCamera, PCFSoftShadowMap, PerspectiveCamera, SRGBColorSpace as SRGBColorSpace4, Vector3 as Vector310, WebGLRenderer } from "three";
 var import_ts_deepmerge9 = __toESM(require_dist());
 import Stats from "stats.js";
 import { EffectComposer, RenderPass } from "postprocessing";
@@ -6092,11 +6208,11 @@ import { EffectComposer, RenderPass } from "postprocessing";
 import {
   EventDispatcher,
   MOUSE,
-  Quaternion as Quaternion4,
+  Quaternion as Quaternion5,
   Spherical,
   TOUCH,
   Vector2 as Vector23,
-  Vector3 as Vector38
+  Vector3 as Vector39
 } from "three";
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
@@ -6110,7 +6226,7 @@ var OrbitControls = class extends EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new Vector38();
+    this.target = new Vector39();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -6162,11 +6278,11 @@ var OrbitControls = class extends EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new Vector38();
-      const quat = new Quaternion4().setFromUnitVectors(object.up, new Vector38(0, 1, 0));
+      const offset = new Vector39();
+      const quat = new Quaternion5().setFromUnitVectors(object.up, new Vector39(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new Vector38();
-      const lastQuaternion = new Quaternion4();
+      const lastPosition = new Vector39();
+      const lastQuaternion = new Quaternion5();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -6255,7 +6371,7 @@ var OrbitControls = class extends EventDispatcher {
     const spherical = new Spherical();
     const sphericalDelta = new Spherical();
     let scale = 1;
-    const panOffset = new Vector38();
+    const panOffset = new Vector39();
     let zoomChanged = false;
     const rotateStart = new Vector23();
     const rotateEnd = new Vector23();
@@ -6281,7 +6397,7 @@ var OrbitControls = class extends EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new Vector38();
+      const v = new Vector39();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -6289,7 +6405,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new Vector38();
+      const v = new Vector39();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -6302,7 +6418,7 @@ var OrbitControls = class extends EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new Vector38();
+      const offset = new Vector39();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -6779,8 +6895,8 @@ var Renderer = class _Renderer {
           top: void 0,
           bottom: void 0
         },
-        position: new Vector39(50, 50, 50),
-        lookingAt: new Vector39(0, 0, 0)
+        position: new Vector310(50, 50, 50),
+        lookingAt: new Vector310(0, 0, 0)
       },
       render: {
         fpsLimit: 60,
@@ -7239,31 +7355,113 @@ var Skins = class {
 };
 
 // src/world/Chunk.ts
-import { Vector3 as Vector311 } from "three";
+import { Vector3 as Vector312 } 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";
+import { Vector3 as Vector311 } from "three";
 var MineRenderWorld = class {
   constructor(scene) {
     this._chunks = /* @__PURE__ */ new Map();
+    this.pendingCulling = /* @__PURE__ */ new Map();
     this.scene = scene;
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector310(posOrX, y, z));
+      return this.getBlockAt(new Vector311(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector310(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector311(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector310(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     this.validatePosBounds(posOrX);
     const value = yOrBlock;
@@ -7306,16 +7504,54 @@ var MineRenderWorld = class {
     }
   }
   async clear() {
-    for (const chunk of this._chunks.values()) {
+    await this.culling;
+    const chunks = [...this._chunks.values()];
+    this._chunks.clear();
+    for (const chunk of chunks) {
       await chunk.dispose();
     }
-    this._chunks.clear();
+  }
+  updateCulling(positions) {
+    for (const pos of positions) {
+      this.pendingCulling.set(pos.toArray().join(","), pos.clone());
+      for (const offset of CUBE_FACE_OFFSETS) {
+        const neighbor = pos.clone().add(new Vector311(...offset));
+        this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
+      }
+    }
+    return this.culling ??= Promise.resolve().then(async () => {
+      try {
+        while (this.pendingCulling.size) {
+          const batch = [...this.pendingCulling.values()];
+          this.pendingCulling.clear();
+          for (const pos of batch) {
+            const block = this.getBlockAt(pos)?.object;
+            if (!block) continue;
+            let mask = 0;
+            for (const [face, offset] of CUBE_FACE_OFFSETS.entries()) {
+              if (this.getBlockAt(pos.clone().add(new Vector311(...offset)))?.object.isOccluding) {
+                mask |= 1 << face;
+              }
+            }
+            await block.setCullMask(mask);
+          }
+        }
+      } finally {
+        this.culling = void 0;
+      }
+    });
   }
   getOrCreateChunkAt(pos) {
     const key = this.worldPosToChunkKey(pos);
     let chunk = this._chunks.get(key);
     if (typeof chunk === "undefined") {
-      chunk = new Chunk(this.scene, Math.floor(pos.x / 16), Math.floor(pos.y / 16), Math.floor(pos.z / 16));
+      chunk = new Chunk(
+        this.scene,
+        Math.floor(pos.x / 16),
+        Math.floor(pos.y / 16),
+        Math.floor(pos.z / 16),
+        (positions) => this.updateCulling(positions)
+      );
       this._chunks.set(key, chunk);
     }
     return chunk;
@@ -7324,14 +7560,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new Vector310(
+    return new Vector311(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new Vector310(
+    return new Vector311(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -7351,10 +7587,11 @@ var MineRenderWorld = class {
 };
 
 // src/world/Chunk.ts
-var p11 = prefix("Chunk");
 var Chunk = class _Chunk {
-  constructor(scene, x, y, z) {
-    this._blocks = [];
+  constructor(scene, x, y, z, onBlocksChanged) {
+    this.onBlocksChanged = onBlocksChanged;
+    this.data = new ChunkData();
+    this.renderedBlocks = /* @__PURE__ */ new Map();
     this.scene = scene;
     this.x = x;
     this.y = y;
@@ -7362,21 +7599,21 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector311(posOrX, y, z));
+      return this.getBlockAt(new Vector312(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]));
     }
     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") {
-      return this.setBlockAt(new Vector311(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector312(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -7391,44 +7628,53 @@ 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);
+    let object;
+    try {
+      if (!readBlock) return void 0;
+      const stored = readBlock();
+      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;
+    } finally {
+      await this.onBlocksChanged?.([worldPos]);
     }
-    return void 0;
   }
   async clear() {
-    this._blocks.forEach((block) => block.object.removeFromScene());
-    this._blocks.length = 0;
+    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);
   }
   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)) {
@@ -7437,14 +7683,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector311(
+    return new Vector312(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector311(
+    return new Vector312(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -7470,9 +7716,11 @@ export {
   BlockTints,
   BrowserArchiveProxy,
   CUBE_FACES,
+  CUBE_FACE_OFFSETS,
   Caching,
   CanvasImage,
   Chunk,
+  ChunkData,
   CubeFace,
   CubeFaceIndex,
   DEFAULT_ELEMENTS,
@@ -7502,6 +7750,7 @@ export {
   MineRenderWorld,
   MinecraftCubeTexture,
   MinecraftFaceUV,
+  ModelCulling,
   ModelGenerator,
   ModelMerger,
   ModelObject,