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

package/dist/browser/index.js

@@ -37,8 +37,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;
       };
@@ -144,9 +144,11 @@ __export(index_browser_exports, {
   BrowserCache: () => BrowserCache,
   BrowserEnv: () => BrowserEnv,
   CUBE_FACES: () => CUBE_FACES,
+  CUBE_FACE_OFFSETS: () => CUBE_FACE_OFFSETS,
   Caching: () => Caching,
   CanvasImage: () => CanvasImage,
   Chunk: () => Chunk,
+  ChunkData: () => ChunkData,
   CubeFace: () => CubeFace,
   CubeFaceIndex: () => CubeFaceIndex,
   DEFAULT_ELEMENTS: () => DEFAULT_ELEMENTS,
@@ -176,6 +178,7 @@ __export(index_browser_exports, {
   MineRenderWorld: () => MineRenderWorld,
   MinecraftCubeTexture: () => MinecraftCubeTexture,
   MinecraftFaceUV: () => MinecraftFaceUV,
+  ModelCulling: () => ModelCulling,
   ModelGenerator: () => ModelGenerator,
   ModelMerger: () => ModelMerger,
   ModelObject: () => ModelObject,
@@ -473,6 +476,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) {
@@ -1323,12 +1334,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();
@@ -1415,7 +1426,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;
   }
@@ -3961,6 +3972,42 @@ function isQuadArray(obj) {
   return Array.isArray(obj) && obj.length === 4;
 }
 
+// src/model/ModelCulling.ts
+var import_three16 = require("three");
+var ModelCulling = class {
+  static toLocalMask(worldMask, rotation) {
+    let localMask = 0;
+    for (const [localFace, offset] of CUBE_FACE_OFFSETS.entries()) {
+      const normal = new import_three16.Vector3(...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" },
@@ -4047,10 +4094,10 @@ var BlockTints = class {
 };
 
 // src/model/scene/ModelObject.ts
-var import_three17 = require("three");
+var import_three18 = require("three");
 
 // src/three/BufferGeometryUtils.js
-var import_three16 = require("three");
+var import_three17 = require("three");
 function computeTangents(geometry) {
   geometry.computeTangents();
   console.warn("THREE.BufferGeometryUtils: .computeTangents() has been removed. Use BufferGeometry.computeTangents() instead.");
@@ -4062,7 +4109,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three16.BufferGeometry();
+  const mergedGeometry = new import_three17.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -4186,7 +4233,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three16.BufferAttribute(array, itemSize, normalized);
+  return new import_three17.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -4202,7 +4249,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three16.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three17.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -4211,7 +4258,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three16.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three17.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -4295,13 +4342,13 @@ function mergeVertices(geometry, tolerance = 1e-4) {
     const name = attributeNames[i];
     const oldAttribute = geometry.getAttribute(name);
     const buffer = new oldAttribute.array.constructor(attrArrays[name]);
-    const attribute = new import_three16.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three17.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
     result.setAttribute(name, attribute);
     if (name in morphAttrsArrays) {
       for (let j = 0; j < morphAttrsArrays[name].length; j++) {
         const oldMorphAttribute = geometry.morphAttributes[name][j];
         const buffer2 = new oldMorphAttribute.array.constructor(morphAttrsArrays[name][j]);
-        const morphAttribute = new import_three16.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three17.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -4310,11 +4357,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three16.TrianglesDrawMode) {
+  if (drawMode === import_three17.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three16.TriangleFanDrawMode || drawMode === import_three16.TriangleStripDrawMode) {
+  if (drawMode === import_three17.TriangleFanDrawMode || drawMode === import_three17.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -4332,7 +4379,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three16.TriangleFanDrawMode) {
+    if (drawMode === import_three17.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -4368,15 +4415,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  const _vA = new import_three16.Vector3();
-  const _vB = new import_three16.Vector3();
-  const _vC = new import_three16.Vector3();
-  const _tempA = new import_three16.Vector3();
-  const _tempB = new import_three16.Vector3();
-  const _tempC = new import_three16.Vector3();
-  const _morphA = new import_three16.Vector3();
-  const _morphB = new import_three16.Vector3();
-  const _morphC = new import_three16.Vector3();
+  const _vA = new import_three17.Vector3();
+  const _vB = new import_three17.Vector3();
+  const _vC = new import_three17.Vector3();
+  const _tempA = new import_three17.Vector3();
+  const _tempB = new import_three17.Vector3();
+  const _tempC = new import_three17.Vector3();
+  const _morphA = new import_three17.Vector3();
+  const _morphB = new import_three17.Vector3();
+  const _morphC = new import_three17.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4571,8 +4618,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three16.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three16.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three17.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three17.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4602,6 +4649,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);
@@ -4615,8 +4665,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 import_three17.Euler(...this.options.uvLockRotation));
+            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three18.Euler(...this.options.uvLockRotation));
           }
           if (this.options.tints) {
             const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4625,19 +4684,19 @@ var _ModelObject = class _ModelObject extends SceneObject {
               if (tintIndex === void 0 || tintIndex < 0) continue;
               const tint = this.options.tints[tintIndex];
               if (tint === void 0) continue;
-              const color = new import_three17.Color(tint);
+              const color = new import_three18.Color(tint);
               for (let vertex = 0; vertex < 4; vertex++) {
                 color.toArray(colors, (faceIndex * 4 + vertex) * 3);
               }
             }
-            elGeo.setAttribute("color", new import_three17.BufferAttribute(colors, 3));
+            elGeo.setAttribute("color", new import_three18.BufferAttribute(colors, 3));
           }
-          elGeo.applyMatrix4(new import_three17.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
-          elGeo.applyMatrix4(new import_three17.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
+          elGeo.applyMatrix4(new import_three18.Matrix4().makeTranslation((el.to[0] - el.from[0]) / 2, (el.to[1] - el.from[1]) / 2, (el.to[2] - el.from[2]) / 2));
+          elGeo.applyMatrix4(new import_three18.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
           if (el.rotation) {
             applyElementRotation(el.rotation, elGeo);
           }
-          elGeo.applyMatrix4(new import_three17.Matrix4().makeTranslation(-8, -8, -8));
+          elGeo.applyMatrix4(new import_three18.Matrix4().makeTranslation(-8, -8, -8));
           if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
           if (this.options.mergeMeshes) {
             allGeos.push(elGeo);
@@ -4659,7 +4718,7 @@ var _ModelObject = class _ModelObject extends SceneObject {
       if (allGeos.length > 0) {
         combinedGeo = mergeBufferGeometries(allGeos);
       } else {
-        combinedGeo = new import_three17.BoxGeometry(16, 16, 16);
+        combinedGeo = new import_three18.BoxGeometry(16, 16, 16);
         if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
       }
       combinedGeo.computeBoundingBox();
@@ -4714,7 +4773,7 @@ function isModelObject(obj) {
 
 // src/model/block/scene/BlockObject.ts
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three18 = require("three");
+var import_three19 = require("three");
 var p10 = prefix("BlockObject");
 function matchesCondition(condition, state) {
   return Object.entries(condition).every(([key, value]) => {
@@ -4739,6 +4798,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 ?? {});
   }
   async init() {
@@ -4772,12 +4832,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 import_three19.Vector3();
+    const rotation = new import_three19.Quaternion();
+    const scale = new import_three19.Vector3();
+    this.getModelMatrix(model).decompose(position, rotation, scale);
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three19.Vector3(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new import_three19.Euler().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;
@@ -4857,7 +4974,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     await this.createVariant(variant);
   }
   async createVariant(variant) {
-    const rotation = new import_three18.Euler();
+    const rotation = new import_three19.Euler();
     if (typeof variant.x !== "undefined") {
       rotation.x = toRadians(clampRotationDegrees(variant.x));
     }
@@ -4870,7 +4987,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) {
@@ -4947,7 +5065,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three18.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three19.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -5026,7 +5144,7 @@ var StructureParser = class {
 };
 
 // src/renderer/MineRenderScene.ts
-var import_three20 = require("three");
+var import_three21 = require("three");
 var import_ts_deepmerge8 = __toESM(require_dist());
 
 // src/skin/SkinPart.ts
@@ -5751,7 +5869,7 @@ var slimSkinGeometries = {
 var import_ts_deepmerge7 = __toESM(require_dist());
 
 // src/skin/SkinTextures.ts
-var import_three19 = require("three");
+var import_three20 = require("three");
 
 // src/skin/SkinImage.ts
 var SkinImage = class {
@@ -5828,11 +5946,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three19.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three19.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three20.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three20.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three19.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three19.DoubleSide : import_three19.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three20.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three20.DoubleSide : import_three20.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -6059,7 +6177,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var _MineRenderScene = class _MineRenderScene extends import_three20.Scene {
+var _MineRenderScene = class _MineRenderScene extends import_three21.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -6132,11 +6250,12 @@ var _MineRenderScene = class _MineRenderScene extends import_three20.Scene {
       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;
@@ -6182,17 +6301,17 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three22 = require("three");
+var import_three23 = require("three");
 var import_ts_deepmerge9 = __toESM(require_dist());
 var import_stats = __toESM(require("stats.js"));
 var import_postprocessing = require("postprocessing");
 
 // src/three/OrbitControls.js
-var import_three21 = require("three");
+var import_three22 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three21.EventDispatcher {
+var OrbitControls = class extends import_three22.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -6201,7 +6320,7 @@ var OrbitControls = class extends import_three21.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three21.Vector3();
+    this.target = new import_three22.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -6223,8 +6342,8 @@ var OrbitControls = class extends import_three21.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    this.mouseButtons = { LEFT: import_three21.MOUSE.ROTATE, MIDDLE: import_three21.MOUSE.DOLLY, RIGHT: import_three21.MOUSE.PAN };
-    this.touches = { ONE: import_three21.TOUCH.ROTATE, TWO: import_three21.TOUCH.DOLLY_PAN };
+    this.mouseButtons = { LEFT: import_three22.MOUSE.ROTATE, MIDDLE: import_three22.MOUSE.DOLLY, RIGHT: import_three22.MOUSE.PAN };
+    this.touches = { ONE: import_three22.TOUCH.ROTATE, TWO: import_three22.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -6253,11 +6372,11 @@ var OrbitControls = class extends import_three21.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three21.Vector3();
-      const quat = new import_three21.Quaternion().setFromUnitVectors(object.up, new import_three21.Vector3(0, 1, 0));
+      const offset = new import_three22.Vector3();
+      const quat = new import_three22.Quaternion().setFromUnitVectors(object.up, new import_three22.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three21.Vector3();
-      const lastQuaternion = new import_three21.Quaternion();
+      const lastPosition = new import_three22.Vector3();
+      const lastQuaternion = new import_three22.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -6343,20 +6462,20 @@ var OrbitControls = class extends import_three21.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three21.Spherical();
-    const sphericalDelta = new import_three21.Spherical();
+    const spherical = new import_three22.Spherical();
+    const sphericalDelta = new import_three22.Spherical();
     let scale = 1;
-    const panOffset = new import_three21.Vector3();
+    const panOffset = new import_three22.Vector3();
     let zoomChanged = false;
-    const rotateStart = new import_three21.Vector2();
-    const rotateEnd = new import_three21.Vector2();
-    const rotateDelta = new import_three21.Vector2();
-    const panStart = new import_three21.Vector2();
-    const panEnd = new import_three21.Vector2();
-    const panDelta = new import_three21.Vector2();
-    const dollyStart = new import_three21.Vector2();
-    const dollyEnd = new import_three21.Vector2();
-    const dollyDelta = new import_three21.Vector2();
+    const rotateStart = new import_three22.Vector2();
+    const rotateEnd = new import_three22.Vector2();
+    const rotateDelta = new import_three22.Vector2();
+    const panStart = new import_three22.Vector2();
+    const panEnd = new import_three22.Vector2();
+    const panDelta = new import_three22.Vector2();
+    const dollyStart = new import_three22.Vector2();
+    const dollyEnd = new import_three22.Vector2();
+    const dollyDelta = new import_three22.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -6372,7 +6491,7 @@ var OrbitControls = class extends import_three21.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three21.Vector3();
+      const v = new import_three22.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -6380,7 +6499,7 @@ var OrbitControls = class extends import_three21.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three21.Vector3();
+      const v = new import_three22.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -6393,7 +6512,7 @@ var OrbitControls = class extends import_three21.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three21.Vector3();
+      const offset = new import_three22.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -6642,12 +6761,12 @@ var OrbitControls = class extends import_three21.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three21.MOUSE.DOLLY:
+        case import_three22.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three21.MOUSE.ROTATE:
+        case import_three22.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -6658,7 +6777,7 @@ var OrbitControls = class extends import_three21.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three21.MOUSE.PAN:
+        case import_three22.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -6714,12 +6833,12 @@ var OrbitControls = class extends import_three21.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three21.TOUCH.ROTATE:
+            case import_three22.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three21.TOUCH.PAN:
+            case import_three22.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -6730,12 +6849,12 @@ var OrbitControls = class extends import_three21.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three21.TOUCH.DOLLY_PAN:
+            case import_three22.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three21.TOUCH.DOLLY_ROTATE:
+            case import_three22.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -6802,7 +6921,7 @@ var OrbitControls = class extends import_three21.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three21.Vector2();
+        position = new import_three22.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -6822,10 +6941,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    this.mouseButtons.LEFT = import_three21.MOUSE.PAN;
-    this.mouseButtons.RIGHT = import_three21.MOUSE.ROTATE;
-    this.touches.ONE = import_three21.TOUCH.PAN;
-    this.touches.TWO = import_three21.TOUCH.DOLLY_ROTATE;
+    this.mouseButtons.LEFT = import_three22.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three22.MOUSE.ROTATE;
+    this.touches.ONE = import_three22.TOUCH.PAN;
+    this.touches.TWO = import_three22.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -6862,14 +6981,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three22.PerspectiveCamera(
+        return new import_three23.PerspectiveCamera(
           this.options.camera.perspective.fov,
           this.options.camera.perspective.aspect ?? this.viewWidth / this.viewHeight,
           this.options.camera.near,
           this.options.camera.far
         );
       case "orthographic":
-        return new import_three22.OrthographicCamera(
+        return new import_three23.OrthographicCamera(
           this.options.camera.orthographic.left ?? this.viewWidth / -2,
           this.options.camera.orthographic.right ?? this.viewWidth / 2,
           this.options.camera.orthographic.top ?? this.viewHeight / 2,
@@ -6880,7 +6999,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three22.WebGLRenderer({
+    const renderer = new import_three23.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -6888,8 +7007,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three22.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three22.SRGBColorSpace;
+    renderer.shadowMap.type = import_three23.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three23.SRGBColorSpace;
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
   }
@@ -6923,20 +7042,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three22.GridHelper(128, 16);
+      const gridHelper = new import_three23.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three22.GridHelper(128, 16);
+      const gridHelper2 = new import_three23.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three22.GridHelper(128, 16);
+      const gridHelper3 = new import_three23.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper3);
       gridHelper3.rotation.z = 90 * (Math.PI / 180);
       this.scene.add(gridHelper3);
     }
     if (this.options.debug.axes) {
-      const axesHelper = new import_three22.AxesHelper(64);
+      const axesHelper = new import_three23.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -7140,8 +7259,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three22.Vector3(50, 50, 50),
-    lookingAt: new import_three22.Vector3(0, 0, 0)
+    position: new import_three23.Vector3(50, 50, 50),
+    lookingAt: new import_three23.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -7329,31 +7448,113 @@ var Skins = class {
 };
 
 // src/world/Chunk.ts
-var import_three25 = require("three");
+var import_three26 = require("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
-var import_three24 = require("three");
+var import_three25 = require("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 import_three24.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three25.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three24.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three25.Vector3(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 import_three24.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three25.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three24.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three25.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     this.validatePosBounds(posOrX);
     const value = yOrBlock;
@@ -7396,16 +7597,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 import_three25.Vector3(...offset));
+        this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
+      }
+    }
+    return this.culling ?? (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 import_three25.Vector3(...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;
@@ -7414,14 +7653,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new import_three24.Vector3(
+    return new import_three25.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three24.Vector3(
+    return new import_three25.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -7441,10 +7680,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;
@@ -7452,21 +7692,21 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three25.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three26.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three25.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three26.Vector3(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 import_three25.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three26.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three25.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three26.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -7481,44 +7721,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 import_three26.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);
   }
   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)) {
@@ -7527,14 +7776,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three25.Vector3(
+    return new import_three26.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three25.Vector3(
+    return new import_three26.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z