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

package/dist/node/index.mjs

@@ -32,8 +32,8 @@ var require_dist = __commonJS({
       __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
           s = arguments[i];
-          for (var 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;
       };
@@ -770,11 +770,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;
@@ -911,8 +911,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) => {
@@ -1180,12 +1180,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();
@@ -1272,7 +1272,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;
   }
@@ -2001,7 +2001,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) {
@@ -2009,7 +2009,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;
@@ -3902,6 +3902,93 @@ var ModelCulling = class {
   }
 };
 
+// src/model/block/BlockStateResolver.ts
+import { Euler as Euler5 } from "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 Euler5();
+    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" },
@@ -3988,7 +4075,7 @@ var BlockTints = class {
 };
 
 // src/model/scene/ModelObject.ts
-import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute4, Color as Color3, Euler as Euler5, Matrix4 as Matrix44 } from "three";
+import { BoxGeometry as BoxGeometry5, BufferAttribute as BufferAttribute4, Color as Color3, Euler as Euler6, Matrix4 as Matrix44 } from "three";
 
 // src/three/BufferGeometryUtils.js
 import {
@@ -4582,7 +4669,7 @@ var ModelObject = class _ModelObject extends SceneObject {
             elGeo.clearGroups();
           }
           if (this.options.uvLockRotation) {
-            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler5(...this.options.uvLockRotation));
+            UVMapper.lockUvs(elGeo, el.faces, this.atlas, new Euler6(...this.options.uvLockRotation));
           }
           if (this.options.tints) {
             const colors = new Float32Array(elGeo.getAttribute("position").count * 3).fill(1);
@@ -4678,18 +4765,7 @@ function isModelObject(obj) {
 
 // src/model/block/scene/BlockObject.ts
 var import_ts_deepmerge6 = __toESM(require_dist());
-import { Euler as Euler6, Matrix4 as Matrix45, Quaternion as Quaternion4, Vector3 as Vector38 } from "three";
-var p10 = prefix("BlockObject");
-function matchesCondition(condition, state) {
-  return Object.entries(condition).every(([key, value]) => {
-    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]}`);
-  });
-}
+import { Euler as Euler7, Matrix4 as Matrix45, Quaternion as Quaternion4, Vector3 as Vector38 } from "three";
 var BlockObject = class _BlockObject extends SceneObject {
   constructor(blockState, options) {
     super(options);
@@ -4713,22 +4789,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();
@@ -4771,7 +4832,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     const scale = new Vector38();
     this.getModelMatrix(model).decompose(position, rotation, scale);
     if (position.distanceToSquared(this.position) > 1e-10 || scale.distanceToSquared(new Vector38(1, 1, 1)) > 1e-10) return 0;
-    return ModelCulling.toLocalMask(worldMask, new Euler6().setFromQuaternion(rotation));
+    return ModelCulling.toLocalMask(worldMask, new Euler7().setFromQuaternion(rotation));
   }
   async setCullMask(worldMask) {
     worldMask &= 63;
@@ -4819,39 +4880,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();
@@ -4862,21 +4891,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) {
@@ -4884,13 +4899,7 @@ var BlockObject = class _BlockObject extends SceneObject {
     await this.createVariant(variant);
   }
   async createVariant(variant) {
-    const rotation = new Euler6();
-    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);
@@ -9393,32 +9402,121 @@ var AnvilParser = class {
 };
 
 // src/world/Chunk.ts
+import { Vector3 as Vector313 } from "three";
+
+// src/world/MineRenderWorld.ts
 import { Vector3 as Vector312 } from "three";
 
+// src/world/SectionModels.ts
+import { Matrix4 as Matrix46, Vector3 as Vector311 } from "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 Matrix46().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 Vector311(...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
-import { Vector3 as Vector311 } from "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 Vector311(posOrX, y, z));
+      return this.getBlockAt(new Vector312(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector311(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector312(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector311(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -9439,7 +9537,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 Vector311(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new Vector312(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     for (const block of multiblock.blocks) {
       if (Chunk.isAir(block)) continue;
@@ -9511,12 +9609,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 Vector311(...offset));
+        const neighbor = pos.clone().add(new Vector312(...offset));
         this.pendingCulling.set(neighbor.toArray().join(","), neighbor);
       }
     }
@@ -9525,17 +9624,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 Vector311(...offset)))?.object.isOccluding) {
+              const neighbor = pos.clone().add(new Vector312(...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;
@@ -9551,7 +9655,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);
     }
@@ -9561,14 +9666,14 @@ var MineRenderWorld = class {
     return this._chunks.get(this.worldPosToChunkKey(pos));
   }
   static worldToScenePosition(pos) {
-    return new Vector311(
+    return new Vector312(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
     );
   }
   static sceneToWorldPosition(pos) {
-    return new Vector311(
+    return new Vector312(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -9587,12 +9692,118 @@ var MineRenderWorld = class {
   }
 };
 
+// src/world/SectionMesh.ts
+import { BufferGeometry as BufferGeometry2, Float32BufferAttribute as Float32BufferAttribute4, Group, Mesh as Mesh7 } from "three";
+var SectionMesh = class _SectionMesh extends 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 = createCanvas2(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 BufferGeometry2();
+      geometry.setAttribute("position", new Float32BufferAttribute4(positions, 3));
+      geometry.setAttribute("normal", new Float32BufferAttribute4(normals, 3));
+      geometry.setAttribute("uv", new Float32BufferAttribute4(uvs, 2));
+      geometry.setAttribute("color", new Float32BufferAttribute4(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 Mesh7(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;
@@ -9600,10 +9811,10 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector312(posOrX, y, z));
+      return this.getBlockAt(new Vector313(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector313(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.worldPosToChunkPos(posOrX);
     const index = _Chunk.chunkPosToBlockIndex(pos);
@@ -9611,10 +9822,10 @@ var Chunk = class _Chunk {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector312(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector313(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector312(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector313(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -9631,7 +9842,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 {
@@ -9642,13 +9854,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 };
@@ -9662,11 +9880,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 Vector312(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new Vector313(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);
@@ -9684,14 +9934,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector312(
+    return new Vector313(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector312(
+    return new Vector313(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z
@@ -9714,6 +9964,7 @@ export {
   BasicAssetKey,
   BatchedExecutor,
   BlockObject,
+  BlockStateResolver,
   BlockStates,
   BlockTints,
   BrowserArchiveProxy,
@@ -9772,6 +10023,8 @@ export {
   SceneStats,
   SceneStatsDisplay,
   SchematicParser,
+  SectionMesh,
+  SectionModels,
   SkinImage,
   SkinObject,
   SkinPart,