minerender 2.1.0-alpha.40 → 2.1.0-alpha.42

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 p11 in s) if (Object.prototype.hasOwnProperty.call(s, p11))
-            t[p11] = s[p11];
+          for (var p10 in s) if (Object.prototype.hasOwnProperty.call(s, p10))
+            t[p10] = s[p10];
         }
         return t;
       };
@@ -139,6 +139,7 @@ __export(index_browser_exports, {
   BasicAssetKey: () => BasicAssetKey,
   BatchedExecutor: () => BatchedExecutor,
   BlockObject: () => BlockObject,
+  BlockStateResolver: () => BlockStateResolver,
   BlockStates: () => BlockStates,
   BlockTints: () => BlockTints,
   BrowserArchiveProxy: () => BrowserArchiveProxy,
@@ -197,6 +198,8 @@ __export(index_browser_exports, {
   SceneStats: () => SceneStats,
   SceneStatsDisplay: () => SceneStatsDisplay,
   SchematicParser: () => SchematicParser,
+  SectionMesh: () => SectionMesh,
+  SectionModels: () => SectionModels,
   SkinImage: () => SkinImage,
   SkinObject: () => SkinObject,
   SkinPart: () => SkinPart,
@@ -928,11 +931,11 @@ var ImageLoader = class _ImageLoader {
   static async loadCanvasData(src) {
     const keyStr = serializeImageKey({ src });
     const info = this.getInfo(src);
-    const cached = Caching.rawImageCache.getIfPresent(keyStr);
+    const cached2 = Caching.rawImageCache.getIfPresent(keyStr);
     try {
       return await this.infoToCanvasData(await info);
     } catch (err) {
-      if (cached && Caching.rawImageCache.getIfPresent(keyStr) === cached) {
+      if (cached2 && Caching.rawImageCache.getIfPresent(keyStr) === cached2) {
         Caching.rawImageCache.invalidate(keyStr);
       }
       throw err;
@@ -1067,8 +1070,8 @@ var Textures = class _Textures {
   }
   static getImage(key) {
     const keyStr = serializeTextureKey(key);
-    const cached = Caching.textureCache.peek(keyStr);
-    if (cached && TextureLoader.hasFailed(cached)) {
+    const cached2 = Caching.textureCache.peek(keyStr);
+    if (cached2 && TextureLoader.hasFailed(cached2)) {
       Caching.textureCache.invalidate(keyStr);
     }
     return Caching.textureCache.get(keyStr, (k) => {
@@ -1335,12 +1338,12 @@ var AssetKey = class _AssetKey extends BasicAssetKey {
     return a.join("/");
   }
   getFullPath() {
-    let p11 = [];
+    let p10 = [];
     if (this.type) {
-      p11.push(this.type);
+      p10.push(this.type);
     }
-    p11.push(this.path);
-    return p11.join("/");
+    p10.push(this.path);
+    return p10.join("/");
   }
   toNamespacedString() {
     return this.namespace + ":" + this.getFullPath();
@@ -1427,7 +1430,7 @@ var ModelMerger = class {
         merged.display = { ...inheritedDisplay, ...DisplayTransforms.withHandFallbacks(source.display) };
       }
     }
-    merged.hierarchy = models.map((m) => m.parent).filter((p11) => `${p11}`);
+    merged.hierarchy = models.map((m) => m.parent).filter((p10) => `${p10}`);
     merged.hierarchy.push(`${merged.parent}`);
     return merged;
   }
@@ -2134,7 +2137,7 @@ var ModelTextures = class {
   static async get(key) {
     const keyStr = key.serialize();
     const pending = this.preload(key);
-    const cached = Caching.textureAssetCache.getIfPresent(keyStr);
+    const cached2 = Caching.textureAssetCache.getIfPresent(keyStr);
     try {
       const asset = await pending;
       if (asset) {
@@ -2142,7 +2145,7 @@ var ModelTextures = class {
       }
       return void 0;
     } catch (err) {
-      if (cached && Caching.textureAssetCache.getIfPresent(keyStr) === cached) {
+      if (cached2 && Caching.textureAssetCache.getIfPresent(keyStr) === cached2) {
         Caching.textureAssetCache.invalidate(keyStr);
       }
       throw err;
@@ -4018,6 +4021,93 @@ var ModelCulling = class {
   }
 };
 
+// src/model/block/BlockStateResolver.ts
+var import_three17 = require("three");
+function matchesCondition(condition, state) {
+  return Object.entries(condition).every(([key, value]) => {
+    if (Array.isArray(value)) {
+      if (key === "OR") return value.some((child) => matchesCondition(child, state));
+      if (key === "AND") return value.every((child) => matchesCondition(child, state));
+      return false;
+    }
+    return typeof value === "string" && state[key] !== void 0 && value.split("|").includes(`${state[key]}`);
+  });
+}
+var BlockStateResolver = class {
+  static async defaults(blockState) {
+    const defaults = blockState.key ? await BlockStates.getDefaultState(blockState.key) : void 0;
+    const state = {};
+    if (defaults && Object.keys(defaults).length > 0) {
+      for (const key in defaults) state[key] = defaults[key].default;
+    } else if (blockState.variants) {
+      const variant = Object.keys(blockState.variants)[0];
+      if (variant) {
+        for (const property of variant.split(",")) {
+          const [key, value] = property.split("=");
+          state[key] = value;
+        }
+      }
+    } else if (blockState.multipart) {
+      const condition = blockState.multipart.map((part) => part.when).find((when) => when !== void 0 && Object.values(when).every((value) => typeof value === "string"));
+      for (const [key, value] of Object.entries(condition ?? {})) state[key] = value.split("|")[0];
+    }
+    return state;
+  }
+  static select(blockState, state, choose = this.choose) {
+    return this.matching(blockState, state).map(choose);
+  }
+  static matching(blockState, state) {
+    const out = [];
+    if (blockState.variants) {
+      if (Object.keys(blockState.variants).length === 1 && "" in blockState.variants) {
+        out.push(blockState.variants[""]);
+      } else {
+        for (const variantKey in blockState.variants) {
+          const matches = variantKey.split(",").every((property) => {
+            const [key, value] = property.split("=");
+            return `${state[key]}` === `${value}`;
+          });
+          if (matches) out.push(blockState.variants[variantKey]);
+        }
+      }
+    } else if (blockState.multipart) {
+      for (const part of blockState.multipart) {
+        if (part.apply && (!part.when || matchesCondition(part.when, state))) {
+          out.push(part.apply);
+        }
+      }
+    }
+    return out;
+  }
+  static choose(variants) {
+    if (!Array.isArray(variants)) return variants;
+    if (!variants.length) throw new MineRenderError("Blockstate variant arrays must not be empty");
+    const total = variants.reduce((sum, variant) => {
+      const weight = variant.weight ?? 1;
+      if (!Number.isInteger(weight) || weight < 1) {
+        throw new MineRenderError(`Invalid blockstate variant weight: ${weight}`);
+      }
+      return sum + weight;
+    }, 0);
+    let choice = Math.random() * total;
+    for (const variant of variants) {
+      choice -= variant.weight ?? 1;
+      if (choice < 0) return variant;
+    }
+    return variants[variants.length - 1];
+  }
+  static rotation(variant) {
+    const rotation = new import_three17.Euler();
+    if (typeof variant.x !== "undefined") {
+      rotation.x = toRadians(clampRotationDegrees(variant.x));
+    }
+    if (typeof variant.y !== "undefined") {
+      rotation.y = toRadians(clampRotationDegrees(typeof variant.x !== "undefined" ? variant.y : 360 - variant.y));
+    }
+    return rotation;
+  }
+};
+
 // src/model/block/blockTints.json
 var blockTints_default = {
   "minecraft:large_fern": { source: "grass" },
@@ -4104,10 +4194,10 @@ var BlockTints = class {
 };
 
 // src/model/scene/ModelObject.ts
-var import_three18 = require("three");
+var import_three19 = require("three");
 
 // src/three/BufferGeometryUtils.js
-var import_three17 = require("three");
+var import_three18 = require("three");
 function computeTangents(geometry) {
   geometry.computeTangents();
   console.warn("THREE.BufferGeometryUtils: .computeTangents() has been removed. Use BufferGeometry.computeTangents() instead.");
@@ -4119,7 +4209,7 @@ function mergeBufferGeometries(geometries, useGroups = false) {
   const attributes = {};
   const morphAttributes = {};
   const morphTargetsRelative = geometries[0].morphTargetsRelative;
-  const mergedGeometry = new import_three17.BufferGeometry();
+  const mergedGeometry = new import_three18.BufferGeometry();
   let offset = 0;
   for (let i = 0; i < geometries.length; ++i) {
     const geometry = geometries[i];
@@ -4243,7 +4333,7 @@ function mergeBufferAttributes(attributes) {
     array.set(attributes[i].array, offset);
     offset += attributes[i].array.length;
   }
-  return new import_three17.BufferAttribute(array, itemSize, normalized);
+  return new import_three18.BufferAttribute(array, itemSize, normalized);
 }
 function interleaveAttributes(attributes) {
   let TypedArray;
@@ -4259,7 +4349,7 @@ function interleaveAttributes(attributes) {
     arrayLength += attribute.array.length;
     stride += attribute.itemSize;
   }
-  const interleavedBuffer = new import_three17.InterleavedBuffer(new TypedArray(arrayLength), stride);
+  const interleavedBuffer = new import_three18.InterleavedBuffer(new TypedArray(arrayLength), stride);
   let offset = 0;
   const res = [];
   const getters = ["getX", "getY", "getZ", "getW"];
@@ -4268,7 +4358,7 @@ function interleaveAttributes(attributes) {
     const attribute = attributes[j];
     const itemSize = attribute.itemSize;
     const count = attribute.count;
-    const iba = new import_three17.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
+    const iba = new import_three18.InterleavedBufferAttribute(interleavedBuffer, itemSize, offset, attribute.normalized);
     res.push(iba);
     offset += itemSize;
     for (let c = 0; c < count; c++) {
@@ -4352,13 +4442,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_three17.BufferAttribute(buffer, oldAttribute.itemSize, oldAttribute.normalized);
+    const attribute = new import_three18.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_three17.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
+        const morphAttribute = new import_three18.BufferAttribute(buffer2, oldMorphAttribute.itemSize, oldMorphAttribute.normalized);
         result.morphAttributes[name][j] = morphAttribute;
       }
     }
@@ -4367,11 +4457,11 @@ function mergeVertices(geometry, tolerance = 1e-4) {
   return result;
 }
 function toTrianglesDrawMode(geometry, drawMode) {
-  if (drawMode === import_three17.TrianglesDrawMode) {
+  if (drawMode === import_three18.TrianglesDrawMode) {
     console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
     return geometry;
   }
-  if (drawMode === import_three17.TriangleFanDrawMode || drawMode === import_three17.TriangleStripDrawMode) {
+  if (drawMode === import_three18.TriangleFanDrawMode || drawMode === import_three18.TriangleStripDrawMode) {
     let index = geometry.getIndex();
     if (index === null) {
       const indices = [];
@@ -4389,7 +4479,7 @@ function toTrianglesDrawMode(geometry, drawMode) {
     }
     const numberOfTriangles = index.count - 2;
     const newIndices = [];
-    if (drawMode === import_three17.TriangleFanDrawMode) {
+    if (drawMode === import_three18.TriangleFanDrawMode) {
       for (let i = 1; i <= numberOfTriangles; i++) {
         newIndices.push(index.getX(0));
         newIndices.push(index.getX(i));
@@ -4425,15 +4515,15 @@ function computeMorphedAttributes(object) {
     console.error("THREE.BufferGeometryUtils: Geometry is not of type BufferGeometry.");
     return null;
   }
-  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();
+  const _vA = new import_three18.Vector3();
+  const _vB = new import_three18.Vector3();
+  const _vC = new import_three18.Vector3();
+  const _tempA = new import_three18.Vector3();
+  const _tempB = new import_three18.Vector3();
+  const _tempC = new import_three18.Vector3();
+  const _morphA = new import_three18.Vector3();
+  const _morphB = new import_three18.Vector3();
+  const _morphC = new import_three18.Vector3();
   function _calculateMorphedAttributeData(object2, material2, attribute, morphAttribute, morphTargetsRelative2, a2, b2, c2, modifiedAttributeArray) {
     _vA.fromBufferAttribute(attribute, a2);
     _vB.fromBufferAttribute(attribute, b2);
@@ -4628,8 +4718,8 @@ function computeMorphedAttributes(object) {
       }
     }
   }
-  const morphedPositionAttribute = new import_three17.Float32BufferAttribute(modifiedPosition, 3);
-  const morphedNormalAttribute = new import_three17.Float32BufferAttribute(modifiedNormal, 3);
+  const morphedPositionAttribute = new import_three18.Float32BufferAttribute(modifiedPosition, 3);
+  const morphedNormalAttribute = new import_three18.Float32BufferAttribute(modifiedNormal, 3);
   return {
     positionAttribute,
     normalAttribute,
@@ -4685,7 +4775,7 @@ var _ModelObject = class _ModelObject extends SceneObject {
             elGeo.clearGroups();
           }
           if (this.options.uvLockRotation) {
-            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three18.Euler(...this.options.uvLockRotation));
+            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new import_three19.Euler(...this.options.uvLockRotation));
           }
           if (this.options.tints) {
             const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4694,19 +4784,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_three18.Color(tint);
+              const color = new import_three19.Color(tint);
               for (let vertex = 0; vertex < 4; vertex++) {
                 color.toArray(colors, (faceIndex * 4 + vertex) * 3);
               }
             }
-            elGeo.setAttribute("color", new import_three18.BufferAttribute(colors, 3));
+            elGeo.setAttribute("color", new import_three19.BufferAttribute(colors, 3));
           }
-          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]));
+          elGeo.applyMatrix4(new import_three19.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_three19.Matrix4().makeTranslation(el.from[0], el.from[1], el.from[2]));
           if (el.rotation) {
             applyElementRotation(el.rotation, elGeo);
           }
-          elGeo.applyMatrix4(new import_three18.Matrix4().makeTranslation(-8, -8, -8));
+          elGeo.applyMatrix4(new import_three19.Matrix4().makeTranslation(-8, -8, -8));
           if (displayTransform) DisplayTransforms.apply(elGeo, displayTransform);
           if (this.options.mergeMeshes) {
             allGeos.push(elGeo);
@@ -4728,7 +4818,7 @@ var _ModelObject = class _ModelObject extends SceneObject {
       if (allGeos.length > 0) {
         combinedGeo = mergeBufferGeometries(allGeos);
       } else {
-        combinedGeo = new import_three18.BoxGeometry(16, 16, 16);
+        combinedGeo = new import_three19.BoxGeometry(16, 16, 16);
         if (displayTransform) DisplayTransforms.apply(combinedGeo, displayTransform);
       }
       combinedGeo.computeBoundingBox();
@@ -4783,18 +4873,7 @@ function isModelObject(obj) {
 
 // src/model/block/scene/BlockObject.ts
 var import_ts_deepmerge6 = __toESM(require_dist());
-var import_three19 = require("three");
-var p10 = prefix("BlockObject");
-function matchesCondition(condition, state) {
-  return Object.entries(condition).every(([key, value]) => {
-    if (Array.isArray(value)) {
-      if (key === "OR") return value.some((child) => matchesCondition(child, state));
-      if (key === "AND") return value.every((child) => matchesCondition(child, state));
-      return false;
-    }
-    return typeof value === "string" && state[key] !== void 0 && value.split("|").includes(`${state[key]}`);
-  });
-}
+var import_three20 = require("three");
 var _BlockObject = class _BlockObject extends SceneObject {
   constructor(blockState, options) {
     super(options);
@@ -4813,22 +4892,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   }
   async init() {
     if (this.options.applyDefaultState) {
-      const defaultState = this.blockState.key ? await BlockStates.getDefaultState(this.blockState.key) : void 0;
-      if (defaultState && Object.keys(defaultState).length > 0) {
-        const state = {};
-        for (let k in defaultState) {
-          state[k] = defaultState[k].default;
-        }
-        this._setState(state);
-      } else {
-        if (this.blockState.variants) {
-          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]]));
-          this._setState(state);
-        }
-      }
+      this._setState(await BlockStateResolver.defaults(this.blockState));
     }
     if (this.options.initialState !== void 0) this._setState(this.options.initialState);
     await this.recreateModels();
@@ -4866,12 +4930,12 @@ var _BlockObject = class _BlockObject extends SceneObject {
   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();
+    const position = new import_three20.Vector3();
+    const rotation = new import_three20.Quaternion();
+    const scale = new import_three20.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));
+    if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new import_three20.Vector3(1, 1, 1)) > 1e-10) return 0;
+    return ModelCulling.toLocalMask(worldMask, new import_three20.Euler().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -4919,39 +4983,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     return ref;
   }
   async mapStateToVariant(state) {
-    const out = [];
-    if (this.blockState.variants) {
-      if (Object.keys(this.blockState.variants).length === 1 && "" in this.blockState.variants) {
-        out.push(this.getSingleVariant(this.blockState.variants[""]));
-      } else {
-        for (let variantKey in this.blockState.variants) {
-          const split = variantKey.split(",");
-          let matches = true;
-          for (let s of split) {
-            const [k, v] = s.split("=");
-            if (`${state[k]}` !== `${v}`) {
-              matches = false;
-              break;
-            }
-          }
-          if (matches) {
-            const variants = this.blockState.variants[variantKey];
-            out.push(this.getSingleVariant(variants));
-          }
-        }
-      }
-    } else if (this.blockState.multipart) {
-      for (let part of this.blockState.multipart) {
-        if (!part.apply) {
-          console.debug(p10, "Missing apply for blockState part", part);
-          continue;
-        }
-        if (!part.when || matchesCondition(part.when, state)) {
-          out.push(this.getSingleVariant(part.apply));
-        }
-      }
-    }
-    return out;
+    return BlockStateResolver.select(this.blockState, state, (variants) => this.getSingleVariant(variants));
   }
   async recreateModels() {
     this.clearModels();
@@ -4962,21 +4994,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     }
   }
   getSingleVariant(variants) {
-    if (!Array.isArray(variants)) return variants;
-    if (!variants.length) throw new MineRenderError("Blockstate variant arrays must not be empty");
-    const total = variants.reduce((sum, variant) => {
-      const weight = variant.weight ?? 1;
-      if (!Number.isInteger(weight) || weight < 1) {
-        throw new MineRenderError(`Invalid blockstate variant weight: ${weight}`);
-      }
-      return sum + weight;
-    }, 0);
-    let choice = Math.random() * total;
-    for (const variant of variants) {
-      choice -= variant.weight ?? 1;
-      if (choice < 0) return variant;
-    }
-    return variants[variants.length - 1];
+    return BlockStateResolver.choose(variants);
   }
   // @deprecated
   async createAVariant(variants, instanceInfo) {
@@ -4984,13 +5002,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
     await this.createVariant(variant);
   }
   async createVariant(variant) {
-    const rotation = new import_three19.Euler();
-    if (typeof variant.x !== "undefined") {
-      rotation.x = toRadians(clampRotationDegrees(variant.x));
-    }
-    if (typeof variant.y !== "undefined") {
-      rotation.y = toRadians(clampRotationDegrees(typeof variant.x !== "undefined" ? variant.y : 360 - variant.y));
-    }
+    const rotation = BlockStateResolver.rotation(variant);
     const modelKey = AssetKey.parse("models", variant.model);
     modelKey.root = this.blockState.key?.root;
     const model = await Models.getMerged(modelKey);
@@ -5075,7 +5087,7 @@ var _BlockObject = class _BlockObject extends SceneObject {
   setPositionRotationScaleAt(index, position, rotation, scale) {
     super.setPositionRotationScaleAt(index, position, rotation, scale);
   }
-  getMatrixAt(index, matrix = new import_three19.Matrix4()) {
+  getMatrixAt(index, matrix = new import_three20.Matrix4()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
     const child = this._models[0];
     if (child && isModelObject(child)) {
@@ -6931,7 +6943,7 @@ var StructureParser = class {
 };
 
 // src/renderer/MineRenderScene.ts
-var import_three21 = require("three");
+var import_three22 = require("three");
 var import_ts_deepmerge8 = __toESM(require_dist());
 
 // src/skin/SkinPart.ts
@@ -7656,7 +7668,7 @@ var slimSkinGeometries = {
 var import_ts_deepmerge7 = __toESM(require_dist());
 
 // src/skin/SkinTextures.ts
-var import_three20 = require("three");
+var import_three21 = require("three");
 
 // src/skin/SkinImage.ts
 var SkinImage = class {
@@ -7733,11 +7745,11 @@ var SkinTextures = class {
     });
   }
   static createMaterial(pixels, width, height, transparent = true) {
-    const texture = Textures.initTextureProps(new import_three20.DataTexture(pixels, width, height));
-    texture.colorSpace = import_three20.SRGBColorSpace;
+    const texture = Textures.initTextureProps(new import_three21.DataTexture(pixels, width, height));
+    texture.colorSpace = import_three21.SRGBColorSpace;
     texture.flipY = true;
     texture.needsUpdate = true;
-    return new import_three20.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three20.DoubleSide : import_three20.FrontSide, alphaTest: transparent ? 0.1 : 0 });
+    return new import_three21.MeshBasicMaterial({ map: texture, transparent, side: transparent ? import_three21.DoubleSide : import_three21.FrontSide, alphaTest: transparent ? 0.1 : 0 });
   }
   static isSlim(image, scale) {
     for (const [x, y] of [[46, 52], [54, 20]]) {
@@ -7964,7 +7976,7 @@ var SkinObject = class extends SceneObject {
 };
 
 // src/renderer/MineRenderScene.ts
-var _MineRenderScene = class _MineRenderScene extends import_three21.Scene {
+var _MineRenderScene = class _MineRenderScene extends import_three22.Scene {
   constructor(options) {
     super();
     this.isMineRenderScene = true;
@@ -8088,17 +8100,17 @@ function isMineRenderScene(obj) {
 }
 
 // src/renderer/Renderer.ts
-var import_three23 = require("three");
+var import_three24 = 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_three22 = require("three");
+var import_three23 = require("three");
 var _changeEvent = { type: "change" };
 var _startEvent = { type: "start" };
 var _endEvent = { type: "end" };
-var OrbitControls = class extends import_three22.EventDispatcher {
+var OrbitControls = class extends import_three23.EventDispatcher {
   constructor(object, domElement) {
     super();
     if (domElement === void 0) console.warn('THREE.OrbitControls: The second parameter "domElement" is now mandatory.');
@@ -8107,7 +8119,7 @@ var OrbitControls = class extends import_three22.EventDispatcher {
     this.domElement = domElement;
     this.domElement.style.touchAction = "none";
     this.enabled = true;
-    this.target = new import_three22.Vector3();
+    this.target = new import_three23.Vector3();
     this.minDistance = 0;
     this.maxDistance = Infinity;
     this.minZoom = 0;
@@ -8129,8 +8141,8 @@ var OrbitControls = class extends import_three22.EventDispatcher {
     this.autoRotate = false;
     this.autoRotateSpeed = 2;
     this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
-    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.mouseButtons = { LEFT: import_three23.MOUSE.ROTATE, MIDDLE: import_three23.MOUSE.DOLLY, RIGHT: import_three23.MOUSE.PAN };
+    this.touches = { ONE: import_three23.TOUCH.ROTATE, TWO: import_three23.TOUCH.DOLLY_PAN };
     this.target0 = this.target.clone();
     this.position0 = this.object.position.clone();
     this.zoom0 = this.object.zoom;
@@ -8159,11 +8171,11 @@ var OrbitControls = class extends import_three22.EventDispatcher {
       state = STATE.NONE;
     };
     this.update = function() {
-      const offset = new import_three22.Vector3();
-      const quat = new import_three22.Quaternion().setFromUnitVectors(object.up, new import_three22.Vector3(0, 1, 0));
+      const offset = new import_three23.Vector3();
+      const quat = new import_three23.Quaternion().setFromUnitVectors(object.up, new import_three23.Vector3(0, 1, 0));
       const quatInverse = quat.clone().invert();
-      const lastPosition = new import_three22.Vector3();
-      const lastQuaternion = new import_three22.Quaternion();
+      const lastPosition = new import_three23.Vector3();
+      const lastQuaternion = new import_three23.Quaternion();
       const twoPI = 2 * Math.PI;
       return function update() {
         const position = scope.object.position;
@@ -8249,20 +8261,20 @@ var OrbitControls = class extends import_three22.EventDispatcher {
     };
     let state = STATE.NONE;
     const EPS = 1e-6;
-    const spherical = new import_three22.Spherical();
-    const sphericalDelta = new import_three22.Spherical();
+    const spherical = new import_three23.Spherical();
+    const sphericalDelta = new import_three23.Spherical();
     let scale = 1;
-    const panOffset = new import_three22.Vector3();
+    const panOffset = new import_three23.Vector3();
     let zoomChanged = false;
-    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 rotateStart = new import_three23.Vector2();
+    const rotateEnd = new import_three23.Vector2();
+    const rotateDelta = new import_three23.Vector2();
+    const panStart = new import_three23.Vector2();
+    const panEnd = new import_three23.Vector2();
+    const panDelta = new import_three23.Vector2();
+    const dollyStart = new import_three23.Vector2();
+    const dollyEnd = new import_three23.Vector2();
+    const dollyDelta = new import_three23.Vector2();
     const pointers = [];
     const pointerPositions = {};
     function getAutoRotationAngle() {
@@ -8278,7 +8290,7 @@ var OrbitControls = class extends import_three22.EventDispatcher {
       sphericalDelta.phi -= angle;
     }
     const panLeft = function() {
-      const v = new import_three22.Vector3();
+      const v = new import_three23.Vector3();
       return function panLeft2(distance, objectMatrix) {
         v.setFromMatrixColumn(objectMatrix, 0);
         v.multiplyScalar(-distance);
@@ -8286,7 +8298,7 @@ var OrbitControls = class extends import_three22.EventDispatcher {
       };
     }();
     const panUp = function() {
-      const v = new import_three22.Vector3();
+      const v = new import_three23.Vector3();
       return function panUp2(distance, objectMatrix) {
         if (scope.screenSpacePanning === true) {
           v.setFromMatrixColumn(objectMatrix, 1);
@@ -8299,7 +8311,7 @@ var OrbitControls = class extends import_three22.EventDispatcher {
       };
     }();
     const pan = function() {
-      const offset = new import_three22.Vector3();
+      const offset = new import_three23.Vector3();
       return function pan2(deltaX, deltaY) {
         const element = scope.domElement;
         if (scope.object.isPerspectiveCamera) {
@@ -8548,12 +8560,12 @@ var OrbitControls = class extends import_three22.EventDispatcher {
           mouseAction = -1;
       }
       switch (mouseAction) {
-        case import_three22.MOUSE.DOLLY:
+        case import_three23.MOUSE.DOLLY:
           if (scope.enableZoom === false) return;
           handleMouseDownDolly(event);
           state = STATE.DOLLY;
           break;
-        case import_three22.MOUSE.ROTATE:
+        case import_three23.MOUSE.ROTATE:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enablePan === false) return;
             handleMouseDownPan(event);
@@ -8564,7 +8576,7 @@ var OrbitControls = class extends import_three22.EventDispatcher {
             state = STATE.ROTATE;
           }
           break;
-        case import_three22.MOUSE.PAN:
+        case import_three23.MOUSE.PAN:
           if (event.ctrlKey || event.metaKey || event.shiftKey) {
             if (scope.enableRotate === false) return;
             handleMouseDownRotate(event);
@@ -8620,12 +8632,12 @@ var OrbitControls = class extends import_three22.EventDispatcher {
       switch (pointers.length) {
         case 1:
           switch (scope.touches.ONE) {
-            case import_three22.TOUCH.ROTATE:
+            case import_three23.TOUCH.ROTATE:
               if (scope.enableRotate === false) return;
               handleTouchStartRotate();
               state = STATE.TOUCH_ROTATE;
               break;
-            case import_three22.TOUCH.PAN:
+            case import_three23.TOUCH.PAN:
               if (scope.enablePan === false) return;
               handleTouchStartPan();
               state = STATE.TOUCH_PAN;
@@ -8636,12 +8648,12 @@ var OrbitControls = class extends import_three22.EventDispatcher {
           break;
         case 2:
           switch (scope.touches.TWO) {
-            case import_three22.TOUCH.DOLLY_PAN:
+            case import_three23.TOUCH.DOLLY_PAN:
               if (scope.enableZoom === false && scope.enablePan === false) return;
               handleTouchStartDollyPan();
               state = STATE.TOUCH_DOLLY_PAN;
               break;
-            case import_three22.TOUCH.DOLLY_ROTATE:
+            case import_three23.TOUCH.DOLLY_ROTATE:
               if (scope.enableZoom === false && scope.enableRotate === false) return;
               handleTouchStartDollyRotate();
               state = STATE.TOUCH_DOLLY_ROTATE;
@@ -8708,7 +8720,7 @@ var OrbitControls = class extends import_three22.EventDispatcher {
     function trackPointer(event) {
       let position = pointerPositions[event.pointerId];
       if (position === void 0) {
-        position = new import_three22.Vector2();
+        position = new import_three23.Vector2();
         pointerPositions[event.pointerId] = position;
       }
       position.set(event.pageX, event.pageY);
@@ -8728,10 +8740,10 @@ var MapControls = class extends OrbitControls {
   constructor(object, domElement) {
     super(object, domElement);
     this.screenSpacePanning = false;
-    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;
+    this.mouseButtons.LEFT = import_three23.MOUSE.PAN;
+    this.mouseButtons.RIGHT = import_three23.MOUSE.ROTATE;
+    this.touches.ONE = import_three23.TOUCH.PAN;
+    this.touches.TWO = import_three23.TOUCH.DOLLY_ROTATE;
   }
 };
 
@@ -8768,14 +8780,14 @@ var _Renderer = class _Renderer {
     switch (this.options.camera.type) {
       case "perspective":
       default:
-        return new import_three23.PerspectiveCamera(
+        return new import_three24.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_three23.OrthographicCamera(
+        return new import_three24.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,
@@ -8786,7 +8798,7 @@ var _Renderer = class _Renderer {
     }
   }
   createRenderer() {
-    const renderer = new import_three23.WebGLRenderer({
+    const renderer = new import_three24.WebGLRenderer({
       antialias: this.options.render.antialias,
       alpha: true,
       powerPreference: "high-performance",
@@ -8794,8 +8806,8 @@ var _Renderer = class _Renderer {
     });
     renderer.setClearColor(0, 0);
     renderer.shadowMap.enabled = true;
-    renderer.shadowMap.type = import_three23.PCFSoftShadowMap;
-    renderer.outputColorSpace = import_three23.SRGBColorSpace;
+    renderer.shadowMap.type = import_three24.PCFSoftShadowMap;
+    renderer.outputColorSpace = import_three24.SRGBColorSpace;
     renderer.setSize(this.viewWidth, this.viewHeight);
     return renderer;
   }
@@ -8829,20 +8841,20 @@ var _Renderer = class _Renderer {
       window["__THREE_DEVTOOLS__"].dispatchEvent(new CustomEvent("observe", { detail: this.scene }));
     }
     if (this.options.debug.grid) {
-      const gridHelper = new import_three23.GridHelper(128, 16);
+      const gridHelper = new import_three24.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper);
       this.scene.add(gridHelper);
-      const gridHelper2 = new import_three23.GridHelper(128, 16);
+      const gridHelper2 = new import_three24.GridHelper(128, 16);
       this._debugHelpers.push(gridHelper2);
       gridHelper2.rotation.x = 90 * (Math.PI / 180);
       this.scene.add(gridHelper2);
-      const gridHelper3 = new import_three23.GridHelper(128, 16);
+      const gridHelper3 = new import_three24.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_three23.AxesHelper(64);
+      const axesHelper = new import_three24.AxesHelper(64);
       this._debugHelpers.push(axesHelper);
       this.scene.add(axesHelper);
     }
@@ -9046,8 +9058,8 @@ _Renderer.DEFAULT_OPTIONS = (0, import_ts_deepmerge9.default)({}, {
       top: void 0,
       bottom: void 0
     },
-    position: new import_three23.Vector3(50, 50, 50),
-    lookingAt: new import_three23.Vector3(0, 0, 0)
+    position: new import_three24.Vector3(50, 50, 50),
+    lookingAt: new import_three24.Vector3(0, 0, 0)
   },
   render: {
     fpsLimit: 60,
@@ -9487,32 +9499,121 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
+var import_three29 = require("three");
+
+// src/world/MineRenderWorld.ts
+var import_three27 = require("three");
+
+// src/world/SectionModels.ts
 var import_three26 = require("three");
+var SectionModel = class extends ModelObject {
+  applyTextures() {
+  }
+};
+function cached(map, key, load) {
+  let value = map.get(key);
+  if (!value) {
+    value = load().catch((error) => {
+      map.delete(key);
+      throw error;
+    });
+    map.set(key, value);
+  }
+  return value;
+}
+var SectionModels = class {
+  constructor(maxAtlasSize = 2048) {
+    this.maxAtlasSize = maxAtlasSize;
+    this.states = /* @__PURE__ */ new WeakMap();
+    this.models = /* @__PURE__ */ new WeakMap();
+    this.templates = /* @__PURE__ */ new Set();
+    if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("maxAtlasSize must be a positive integer");
+  }
+  async get(blockState, properties = {}) {
+    if (!blockState.variants || blockState.multipart) return void 0;
+    let states = this.states.get(blockState);
+    if (!states) this.states.set(blockState, states = /* @__PURE__ */ new Map());
+    const key = JSON.stringify(Object.entries(properties).sort(([a], [b]) => a.localeCompare(b)));
+    const prepared = await cached(states, key, () => this.prepare(blockState, properties));
+    if (!prepared) return void 0;
+    return prepared.templates.get(BlockStateResolver.choose(prepared.variants));
+  }
+  async prepare(blockState, properties) {
+    const state = { ...await BlockStateResolver.defaults(blockState), ...properties };
+    const groups = BlockStateResolver.matching(blockState, state);
+    if (groups.length !== 1) return void 0;
+    const variants = groups[0];
+    const choices = Array.isArray(variants) ? variants : [variants];
+    if (!choices.length) return void 0;
+    const templates = /* @__PURE__ */ new Map();
+    for (const variant of choices) {
+      const model = await Models.getMerged(AssetKey.parse("models", variant.model));
+      if (!model) return void 0;
+      const atlas = await UVMapper.getAtlas(model);
+      const rotation = BlockStateResolver.rotation(variant);
+      if (!atlas || atlas.hasAnimation || !ModelCulling.isOpaqueFullCube(atlas) || atlas.image.width > this.maxAtlasSize || atlas.image.height > this.maxAtlasSize || ModelCulling.toLocalMask(63, rotation) !== 63) return void 0;
+      const tints = await BlockTints.get(blockState.key, state, model);
+      let models = this.models.get(model);
+      if (!models) this.models.set(model, models = /* @__PURE__ */ new Map());
+      const key = JSON.stringify([rotation.x, rotation.y, rotation.z, variant.uvlock, tints]);
+      const template = await cached(models, key, async () => {
+        const object = new SectionModel(model, {
+          instanceMeshes: false,
+          mergeMeshes: false,
+          tints,
+          uvLockRotation: variant.uvlock && (rotation.x !== 0 || rotation.y !== 0) ? [rotation.x, rotation.y, rotation.z] : void 0
+        });
+        await object.init();
+        const geometry = object.children[0].geometry;
+        geometry.applyMatrix4(new import_three26.Matrix4().makeRotationFromEuler(rotation));
+        object.clear();
+        const cullFaces = CUBE_FACES.map((face) => {
+          const local = CUBE_FACES.findIndex((name) => name === atlas.model.elements[0].faces[face]?.cullface);
+          if (local < 0) return 0;
+          const normal = new import_three26.Vector3(...CUBE_FACE_OFFSETS[local]).applyEuler(rotation);
+          const world = 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);
+          return 1 << world;
+        });
+        const template2 = { geometry, atlas, cullFaces };
+        this.templates.add(template2);
+        return template2;
+      });
+      templates.set(variant, template);
+    }
+    return { variants, templates };
+  }
+  clear() {
+    for (const template of this.templates) template.geometry.dispose();
+    this.templates.clear();
+    this.states = /* @__PURE__ */ new WeakMap();
+    this.models = /* @__PURE__ */ new WeakMap();
+  }
+};
 
 // src/world/MineRenderWorld.ts
-var import_three25 = require("three");
 var MineRenderWorld = class {
-  constructor(scene) {
+  constructor(scene, options = {}) {
     this._chunks = /* @__PURE__ */ new Map();
     this.pendingCulling = /* @__PURE__ */ new Map();
     this.scene = scene;
+    if (options.sectionMeshing) this.sectionModels = new SectionModels(options.maxAtlasSize);
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three25.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three27.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_three27.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_three25.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three27.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_three27.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -9533,7 +9634,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new import_three25.Vector3(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new import_three27.Vector3(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -9605,12 +9706,13 @@ var MineRenderWorld = class {
     for (const chunk of chunks) {
       await chunk.dispose();
     }
+    this.sectionModels?.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));
+        const neighbor = pos.clone().add(new import_three27.Vector3(...offset));
         this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
       }
     }
@@ -9619,17 +9721,22 @@ var MineRenderWorld = class {
         while (this.pendingCulling.size) {
           const batch = [...this.pendingCulling.values()];
           this.pendingCulling.clear();
+          const changed = /* @__PURE__ */ new Set();
           for (const pos of batch) {
-            const block = this.getBlockAt(pos)?.object;
-            if (!block) continue;
+            const chunk = this.getChunkAt(pos);
+            if (!chunk) continue;
+            changed.add(chunk);
+            if (!chunk.getBlockAt(pos)) 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) {
+              const neighbor = pos.clone().add(new import_three27.Vector3(...offset));
+              if (this.getChunkAt(neighbor)?.isOccludingAt(neighbor)) {
                 mask |= 1 << face;
               }
             }
-            await block.setCullMask(mask);
+            await chunk.setCullMaskAt(pos, mask);
           }
+          for (const chunk of changed) chunk.rebuildSectionMesh();
         }
       } finally {
         this.culling = void 0;
@@ -9645,7 +9752,8 @@ var MineRenderWorld = class {
         Math.floor(pos.x / 16),
         Math.floor(pos.y / 16),
         Math.floor(pos.z / 16),
-        (positions) => this.updateCulling(positions)
+        (positions) => this.updateCulling(positions),
+        this.sectionModels
       );
       this._chunks.set(key, chunk);
     }
@@ -9655,14 +9763,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new import_three25.Vector3(
+    return new import_three27.Vector3(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new import_three25.Vector3(
+    return new import_three27.Vector3(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -9681,12 +9789,118 @@ var MineRenderWorld = class {
   }
 };
 
+// src/world/SectionMesh.ts
+var import_three28 = require("three");
+var SectionMesh = class _SectionMesh extends import_three28.Group {
+  constructor() {
+    super(...arguments);
+    this.ownedMeshes = [];
+  }
+  static build(entries, maxAtlasSize = 2048) {
+    if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
+    const visible = entries.filter((entry) => entry.template.cullFaces.some((direction) => !(entry.cullMask & direction)));
+    const atlases = [...new Set(visible.map((entry) => entry.template.atlas))].sort((a, b) => b.image.height - a.image.height);
+    const pages = [];
+    const locations = /* @__PURE__ */ new Map();
+    for (const atlas of atlases) {
+      const { width, height } = atlas.image;
+      if (width > maxAtlasSize || height > maxAtlasSize) throw new RangeError("Model atlas exceeds the section atlas size limit");
+      let selected;
+      for (const page of pages) {
+        const nextRow = page.x + width > maxAtlasSize;
+        if ((nextRow ? page.y + page.rowHeight : page.y) + height > maxAtlasSize) continue;
+        if (nextRow) {
+          page.y += page.rowHeight;
+          page.x = 0;
+          page.rowHeight = 0;
+        }
+        selected = page;
+        break;
+      }
+      if (!selected) {
+        selected = { placements: [], entries: [], x: 0, y: 0, rowHeight: 0, width: 0, height: 0 };
+        pages.push(selected);
+      }
+      const placement = { atlas, x: selected.x, y: selected.y };
+      selected.placements.push(placement);
+      selected.x += width;
+      selected.rowHeight = Math.max(selected.rowHeight, height);
+      selected.width = Math.max(selected.width, selected.x);
+      selected.height = Math.max(selected.height, selected.y + height);
+      locations.set(atlas, { page: selected, placement });
+    }
+    for (const entry of visible) locations.get(entry.template.atlas).page.entries.push(entry);
+    const section = new _SectionMesh();
+    for (const page of pages) {
+      const canvas = createCanvas(page.width, page.height);
+      const context = canvas.getContext("2d");
+      for (const { atlas, x, y } of page.placements) {
+        context.drawImage(atlas.image.canvas, x, y);
+      }
+      const positions = [], normals = [], uvs = [], colors = [], indices = [];
+      for (const { index, template, cullMask } of page.entries) {
+        const position = template.geometry.getAttribute("position");
+        const normal = template.geometry.getAttribute("normal");
+        const uv = template.geometry.getAttribute("uv");
+        const color = template.geometry.getAttribute("color");
+        const sourceIndices = template.geometry.getIndex();
+        const placement = locations.get(template.atlas).placement;
+        const offsetX = index % 16 * 16;
+        const offsetY = Math.floor(index / 256) * 16;
+        const offsetZ = Math.floor(index / 16) % 16 * 16;
+        for (let face = 0; face < 6; face++) {
+          if (cullMask & template.cullFaces[face]) continue;
+          const start = positions.length / 3;
+          for (let corner = 0; corner < 4; corner++) {
+            const vertex = face * 4 + corner;
+            positions.push(position.getX(vertex) + offsetX, position.getY(vertex) + offsetY, position.getZ(vertex) + offsetZ);
+            normals.push(normal.getX(vertex), normal.getY(vertex), normal.getZ(vertex));
+            uvs.push(
+              (placement.x + uv.getX(vertex) * template.atlas.image.width) / page.width,
+              1 - (placement.y + (1 - uv.getY(vertex)) * template.atlas.image.height) / page.height
+            );
+            colors.push(color?.getX(vertex) ?? 1, color?.getY(vertex) ?? 1, color?.getZ(vertex) ?? 1);
+          }
+          for (let corner = 0; corner < 6; corner++) indices.push(start + sourceIndices.getX(face * 6 + corner) - face * 4);
+        }
+      }
+      const geometry = new import_three28.BufferGeometry();
+      geometry.setAttribute("position", new import_three28.Float32BufferAttribute(positions, 3));
+      geometry.setAttribute("normal", new import_three28.Float32BufferAttribute(normals, 3));
+      geometry.setAttribute("uv", new import_three28.Float32BufferAttribute(uvs, 2));
+      geometry.setAttribute("color", new import_three28.Float32BufferAttribute(colors, 3));
+      geometry.setIndex(indices);
+      geometry.computeBoundingBox();
+      geometry.computeBoundingSphere();
+      const material = Materials.createShadedCanvasMaterial(canvas, false);
+      material.vertexColors = true;
+      const texture = material.uniforms?.map?.value ?? material.map;
+      const mesh = new import_three28.Mesh(geometry, material);
+      section.add(mesh);
+      section.ownedMeshes.push({ mesh, texture });
+    }
+    return section;
+  }
+  dispose() {
+    for (const { mesh, texture } of this.ownedMeshes.splice(0)) {
+      mesh.removeFromParent();
+      mesh.geometry.dispose();
+      mesh.material.dispose();
+      texture?.dispose();
+    }
+    this.removeFromParent();
+  }
+};
+
 // src/world/Chunk.ts
 var Chunk = class _Chunk {
-  constructor(scene, x, y, z, onBlocksChanged) {
+  constructor(scene, x, y, z, onBlocksChanged, sectionModels) {
     this.onBlocksChanged = onBlocksChanged;
+    this.sectionModels = sectionModels;
     this.data = new ChunkData();
     this.renderedBlocks = /* @__PURE__ */ new Map();
+    this.sectionBlocks = /* @__PURE__ */ new Map();
+    this.meshDirty = false;
     this.scene = scene;
     this.x = x;
     this.y = y;
@@ -9694,10 +9908,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new import_three26.Vector3(posOrX, y, z));
+      return this.getBlockAt(new import_three29.Vector3(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new import_three26.Vector3(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new import_three29.Vector3(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -9705,10 +9919,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new import_three26.Vector3(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new import_three29.Vector3(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new import_three26.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new import_three29.Vector3(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -9725,7 +9939,8 @@ var Chunk = class _Chunk {
     const index = _Chunk.chunkPosToBlockIndex(pos);
     this.data.set(index, block);
     const readBlock = this.data.snapshot(index);
-    this.renderedBlocks.get(index)?.object.removeFromScene();
+    this.renderedBlocks.get(index)?.object?.removeFromScene();
+    if (this.sectionBlocks.delete(index)) this.meshDirty = true;
     this.renderedBlocks.delete(index);
     let object;
     try {
@@ -9736,13 +9951,19 @@ var Chunk = class _Chunk {
         this.data.set(index, void 0);
         return void 0;
       }
-      object = await this.scene.addBlock(blockState, {
-        mergeMeshes: true,
-        instanceMeshes: true,
-        maxInstanceCount: 2e3,
-        initialState: stored.properties
-      });
-      object.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
+      const template = await this.sectionModels?.get(blockState, stored.properties);
+      if (template) {
+        this.sectionBlocks.set(index, { index, template, cullMask: 0 });
+        this.meshDirty = true;
+      } else {
+        object = await this.scene.addBlock(blockState, {
+          mergeMeshes: true,
+          instanceMeshes: true,
+          maxInstanceCount: 2e3,
+          initialState: stored.properties
+        });
+        object.setPosition(MineRenderWorld.worldToScenePosition(worldPos));
+      }
       const info = { get block() {
         return readBlock();
       }, object };
@@ -9756,11 +9977,43 @@ var Chunk = class _Chunk {
       await onBlocksChanged?.([worldPos]);
     }
   }
+  isOccludingAt(pos) {
+    const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+    return this.sectionBlocks.has(index) || (this.renderedBlocks.get(index)?.object?.isOccluding ?? false);
+  }
+  async setCullMaskAt(pos, mask) {
+    const index = _Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos));
+    const entry = this.sectionBlocks.get(index);
+    if (entry) {
+      if (entry.cullMask !== mask) {
+        entry.cullMask = mask;
+        this.meshDirty = true;
+      }
+    } else {
+      await this.renderedBlocks.get(index)?.object?.setCullMask(mask);
+    }
+  }
+  rebuildSectionMesh() {
+    if (!this.meshDirty) return;
+    const next = this.sectionBlocks.size ? SectionMesh.build([...this.sectionBlocks.values()], this.sectionModels.maxAtlasSize) : void 0;
+    this.sectionMesh?.dispose();
+    this.sectionMesh = next;
+    if (next) {
+      next.position.set(this.x * 256, this.y * 256, this.z * 256);
+      this.scene.add(next);
+    }
+    this.scene.dirty = true;
+    this.meshDirty = false;
+  }
   async clear(onBlocksChanged = this.onBlocksChanged) {
     const positions = [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new import_three26.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new import_three29.Vector3(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     ));
-    for (const info of this.renderedBlocks.values()) info.object.removeFromScene();
+    for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
+    this.sectionBlocks.clear();
+    this.sectionMesh?.dispose();
+    this.sectionMesh = void 0;
+    this.meshDirty = false;
     this.renderedBlocks.clear();
     this.data.clear();
     await onBlocksChanged?.(positions);
@@ -9778,14 +10031,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new import_three26.Vector3(
+    return new import_three29.Vector3(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new import_three26.Vector3(
+    return new import_three29.Vector3(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z