minerender 2.1.0-alpha.41 → 2.1.0-alpha.43

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;
@@ -3100,6 +3100,10 @@ var SceneObject = class _SceneObject extends Object3D2 {
     this.setMatrixAt(index, new Matrix43());
     return reference;
   }
+  /** Returns the live reference for a raycast hit on this object's instance mesh. */
+  getInstanceReference(mesh, index) {
+    return mesh === this.instanceMesh ? this.instanceReferences.get(index) : void 0;
+  }
   isInstanceActive(index, reference) {
     return this.instanceReferences.get(index) === reference;
   }
@@ -3182,9 +3186,9 @@ var SceneObject = class _SceneObject extends Object3D2 {
   }
   getRotationAt(index, euler = new Euler3()) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
-    const matrix = this.getMatrixAt(index);
-    euler.setFromRotationMatrix(matrix);
-    return euler;
+    const rotation = new Quaternion3();
+    this.getMatrixAt(index).decompose(new Vector35(), rotation, new Vector35());
+    return euler.setFromQuaternion(rotation);
   }
   setScaleAt(index, scale) {
     if (!this.isInstanced) throw new MineRenderError("Object is not instanced");
@@ -3434,11 +3438,12 @@ var GuiObject = class extends SceneObject {
 // src/inspector/SceneInspector.ts
 import { Raycaster, Vector2 as Vector22 } from "three";
 var p7 = prefix("SceneInspector");
-var help = "<span>Ctrl+Click to Select<br/></span><br/>";
+var help = "<span>Ctrl/Cmd+Click to Select<br/></span><br/>";
 var SceneInspector = class {
   constructor(renderer) {
     this.renderer = renderer;
     this.mouse = new Vector22();
+    this.listeners = new AbortController();
     this.objectInfoContainer = document.createElement("div");
     this.objectControlsContainer = document.createElement("div");
     this.raycaster = new Raycaster();
@@ -3448,13 +3453,44 @@ var SceneInspector = class {
     this.objectInfoContainer.classList.add("minerender-inspector", "minerender-object-info");
     this.objectControlsContainer.classList.add("minerender-inspector", "minerender-object-controls");
     this.objectInfoContainer.innerHTML = help;
-    document.addEventListener("click", this.onClick.bind(this), {
-      passive: true
-    });
+    const canvas = this.renderer.renderer.domElement;
+    const options = { signal: this.listeners.signal };
+    canvas.addEventListener("pointerdown", (event) => {
+      this.pointer = event.button === 0 && (event.ctrlKey || event.metaKey) ? event : void 0;
+    }, options);
+    canvas.addEventListener("pointermove", (event) => {
+      if (this.pointer?.pointerId === event.pointerId && Math.hypot(event.clientX - this.pointer.clientX, event.clientY - this.pointer.clientY) > 5) {
+        this.pointer = void 0;
+      }
+    }, options);
+    canvas.addEventListener("pointerup", (event) => {
+      const start = this.pointer;
+      this.pointer = void 0;
+      if (start?.pointerId === event.pointerId && Math.hypot(event.clientX - start.clientX, event.clientY - start.clientY) <= 5) {
+        this.onClick(event);
+      }
+    }, options);
+    canvas.addEventListener("pointercancel", () => {
+      this.pointer = void 0;
+    }, options);
+    canvas.addEventListener("pointerleave", () => {
+      this.pointer = void 0;
+    }, options);
+    canvas.addEventListener("contextmenu", (event) => {
+      if (this.pointer?.ctrlKey) event.preventDefault();
+    }, options);
+  }
+  dispose() {
+    this.listeners.abort();
+    this.pointer = void 0;
+    this.selectedObject = void 0;
+    this.objectInfoContainer.remove();
+    this.objectControlsContainer.remove();
   }
   findMeshChildren(from, out = []) {
+    if (!from.visible) return out;
     for (let c of from.children) {
-      if (isMesh(c)) {
+      if (c.visible && isMesh(c)) {
         out.push(c);
       }
       this.findMeshChildren(c, out);
@@ -3462,50 +3498,43 @@ var SceneInspector = class {
     return out;
   }
   onClick(event) {
-    if (event.target?.nodeName !== "CANVAS") return;
-    if (!event.ctrlKey) return;
-    setTimeout(() => {
-      this.mouse.x = event.clientX / window.innerWidth * 2 - 1;
-      this.mouse.y = -(event.clientY / window.innerHeight) * 2 + 1;
-      this.raycaster.setFromCamera(this.mouse, this.renderer.camera);
-      let start = Date.now();
-      let targets = this.findMeshChildren(this.renderer.scene);
-      const intersects = this.raycaster.intersectObjects(targets, false);
-      console.debug("Raycast took " + (Date.now() - start) + "ms for " + targets.length + " possible targets with " + intersects.length + " results");
-      if (intersects.length > 0) {
-        this.handleRaycasterObjects(intersects);
-      }
-    });
+    const canvas = this.renderer.renderer.domElement;
+    if (event.target !== canvas || event.button !== 0 || !(event.ctrlKey || event.metaKey)) return;
+    const rect = canvas.getBoundingClientRect();
+    const x = event.clientX - rect.left, y = event.clientY - rect.top;
+    if (rect.width <= 0 || rect.height <= 0 || x < 0 || y < 0 || x >= rect.width || y >= rect.height) return;
+    this.mouse.set(x / rect.width * 2 - 1, 1 - y / rect.height * 2);
+    this.renderer.camera.updateWorldMatrix(true, false);
+    this.renderer.scene.updateMatrixWorld(true);
+    this.raycaster.setFromCamera(this.mouse, this.renderer.camera);
+    this.handleRaycasterObjects(this.raycaster.intersectObjects(this.findMeshChildren(this.renderer.scene), false));
   }
   appendTo(el) {
     el.append(this.objectInfoContainer);
     el.append(this.objectControlsContainer);
   }
   handleRaycasterObjects(intersections) {
-    console.debug(intersections);
-    const firstIntersection = intersections[0];
-    if (firstIntersection && firstIntersection.object) {
-      const firstObject = firstIntersection.object;
-      let targetIntersection = void 0;
-      let targetObject = void 0;
-      const firstSceneObjectIntersection = intersections.find((i) => i.object && i.object.parent && isSceneObject(i.object.parent));
-      if (firstSceneObjectIntersection && firstSceneObjectIntersection.object) {
-        targetIntersection = firstSceneObjectIntersection;
-        targetObject = firstSceneObjectIntersection.object;
-      } else {
-        targetIntersection = firstIntersection;
-        targetObject = firstObject;
+    const hit = intersections[0];
+    if (!hit) return;
+    const instance = this.getIntersectionInstance(hit);
+    this.selectObject(instance?.instanceable ?? hit.object, hit, instance);
+  }
+  getIntersectionInstance(hit) {
+    if (hit?.instanceId === void 0) return void 0;
+    for (let parent = hit.object.parent; parent; parent = parent.parent) {
+      if (isSceneObject(parent)) {
+        const instance = parent.getInstanceReference(hit.object, hit.instanceId);
+        if (instance) return instance;
       }
-      if (!targetIntersection || !targetObject) return;
-      this.selectObject(targetObject, targetIntersection);
     }
+    return void 0;
   }
-  selectObject(targetObject, targetIntersection) {
+  selectObject(targetObject, targetIntersection, instance = this.getIntersectionInstance(targetIntersection)) {
     this.selectedObject = targetObject;
     console.log(p7, "selected", targetObject);
-    this.redraw(targetObject, targetIntersection);
+    this.redraw(targetObject, targetIntersection, instance);
   }
-  redraw(targetObject, targetIntersection) {
+  redraw(targetObject, targetIntersection, instance) {
     this.objectInfoContainer.innerHTML = help;
     if (targetIntersection) {
       this.addInfoLine("Distance", "D", targetIntersection.distance);
@@ -3518,8 +3547,8 @@ var SceneInspector = class {
       if (isSceneObject(targetObject.parent)) {
       }
     }
-    if ("atlas" in targetObject) {
-      const atlas = targetObject["atlas"];
+    const atlas = "atlas" in targetObject ? targetObject["atlas"] : void 0;
+    if (atlas?.image.canvas) {
       const img = atlas.image.canvas;
       img.style.width = "100px";
       img.style.height = "100px";
@@ -3528,28 +3557,31 @@ var SceneInspector = class {
       this.objectInfoContainer.prepend(img);
     }
     this.objectControlsContainer.innerHTML = "";
-    this.addControls(targetObject, targetIntersection);
+    this.addControls(targetObject, targetIntersection, instance);
   }
-  addControls(object, intersection) {
+  addControls(object, intersection, instance) {
     const container = document.createElement("div");
     container.append(this.separator("Select Parent/Child"));
     if (object.parent) {
       container.append(this.buttonControl("Select Parent " + object.parent.constructor.name + " " + object.parent.name, "P", () => {
-        this.selectObject(object.parent, intersection);
+        this.selectObject(object.parent, intersection, instance);
       }));
     }
     if (object.children.length > 0) {
       let i = 1;
       for (let child of object.children) {
         container.append(this.buttonControl("Select Child " + child.constructor.name + " " + child.name, "C" + i++, () => {
-          this.selectObject(child, intersection);
+          this.selectObject(child, intersection, instance);
         }));
       }
     }
     container.append(this.separator());
-    container.append(this.toggleControl("Visibility", "V", object.visible, (v) => object.visible = v));
+    const selectedInstance = instance && (object === instance.instanceable || object === intersection?.object) ? instance : void 0;
+    if (!selectedInstance) {
+      container.append(this.toggleControl("Visibility", "V", object.visible, (v) => object.visible = v));
+    }
     container.append(this.separator("Mesh"));
-    this.addObjectControls(object, intersection, container);
+    this.addObjectControls(object, intersection, container, selectedInstance);
     container.append(this.separator());
     this.objectControlsContainer.append(container);
   }
@@ -3561,78 +3593,26 @@ var SceneInspector = class {
     this.objectInfoContainer.append(document.createElement("br"));
     return el;
   }
-  addObjectControls(target, intersection, container) {
+  addObjectControls(target, intersection, container, instance) {
     const posRange = 16 * 16;
     const rotRange = 360;
     const scaleRange = 4;
-    if (typeof intersection !== "undefined" && typeof intersection.instanceId !== "undefined" && isSceneObject(target) && target.isInstanced) {
-      const scObj = target;
-      container.append(this.separator("Position"));
-      let pos = scObj.getPositionAt(intersection.instanceId);
-      container.append(this.rangeControl("X Position", "X", -posRange + pos.x, posRange + pos.x, pos.x, 1, (v) => {
-        pos = scObj.getPositionAt(intersection.instanceId);
-        pos.x = v;
-        scObj.setPositionAt(intersection.instanceId, pos);
-      }));
-      container.append(this.rangeControl("Y Position", "Y", -posRange + pos.y, posRange + pos.y, pos.y, 1, (v) => {
-        pos = scObj.getPositionAt(intersection.instanceId);
-        pos.y = v;
-        scObj.setPositionAt(intersection.instanceId, pos);
-      }));
-      container.append(this.rangeControl("Z Position", "Z", -posRange + pos.z, posRange + pos.z, pos.z, 1, (v) => {
-        pos = scObj.getPositionAt(intersection.instanceId);
-        pos.z = v;
-        scObj.setPositionAt(intersection.instanceId, pos);
-      }));
-      container.append(this.separator("Rotation"));
-      let rot = scObj.getRotationAt(intersection.instanceId);
-      container.append(this.rangeControl("X Rotation", "X", 0, rotRange, Math.round(toDegrees(rot.x)), 1, (v) => {
-        rot = scObj.getRotationAt(intersection.instanceId);
-        rot.x = toRadians(v);
-        scObj.setRotationAt(intersection.instanceId, rot);
-      }));
-      container.append(this.rangeControl("Y Rotation", "Y", 0, rotRange, Math.round(toDegrees(rot.y)), 1, (v) => {
-        rot = scObj.getRotationAt(intersection.instanceId);
-        rot.y = toRadians(v);
-        scObj.setRotationAt(intersection.instanceId, rot);
-      }));
-      container.append(this.rangeControl("Z Rotation", "Z", 0, rotRange, Math.round(toDegrees(rot.z)), 1, (v) => {
-        rot = scObj.getRotationAt(intersection.instanceId);
-        rot.z = toRadians(v);
-        scObj.setRotationAt(intersection.instanceId, rot);
-      }));
-      container.append(this.separator("Scale"));
-      let scl = scObj.getScale();
-      container.append(this.rangeControl("X Scale", "X", 0, scaleRange, scl.x, 0.1, (v) => {
-        scl = scObj.getScaleAt(intersection.instanceId);
-        scl.x = v;
-        scObj.setScaleAt(intersection.instanceId, scl);
-      }));
-      container.append(this.rangeControl("Y Scale", "Y", 0, scaleRange, scl.y, 0.1, (v) => {
-        scl = scObj.getScaleAt(intersection.instanceId);
-        scl.y = v;
-        scObj.setScaleAt(intersection.instanceId, scl);
-      }));
-      container.append(this.rangeControl("Z Scale", "Z", 0, scaleRange, scl.z, 0.1, (v) => {
-        scl = scObj.getScaleAt(intersection.instanceId);
-        scl.z = v;
-        scObj.setScaleAt(intersection.instanceId, scl);
-      }));
-    } else if (isTransformable(target)) {
-      const parent = target;
+    const transform = instance ?? (isTransformable(target) ? target : void 0);
+    if (transform) {
+      const parent = transform;
       container.append(this.separator("Position"));
       let pos = parent.getPosition();
-      container.append(this.rangeControl("X Position", "X", -posRange, posRange, pos.x, 1, (v) => {
+      container.append(this.rangeControl("X Position", "X", pos.x - posRange, pos.x + posRange, pos.x, 1, (v) => {
         pos = parent.getPosition();
         pos.x = v;
         parent.setPosition(pos);
       }));
-      container.append(this.rangeControl("Y Position", "Y", -posRange, posRange, pos.y, 1, (v) => {
+      container.append(this.rangeControl("Y Position", "Y", pos.y - posRange, pos.y + posRange, pos.y, 1, (v) => {
         pos = parent.getPosition();
         pos.y = v;
         parent.setPosition(pos);
       }));
-      container.append(this.rangeControl("Z Position", "Z", -posRange, posRange, pos.z, 1, (v) => {
+      container.append(this.rangeControl("Z Position", "Z", pos.z - posRange, pos.z + posRange, pos.z, 1, (v) => {
         pos = parent.getPosition();
         pos.z = v;
         parent.setPosition(pos);
@@ -3721,6 +3701,7 @@ var SceneInspector = class {
     toggle.checked = val;
     toggle.addEventListener("change", (e) => {
       change(toggle.checked);
+      this.renderer.scene.dirty = true;
     });
     label.append(toggle);
     label.append(document.createElement("br"));
@@ -3733,7 +3714,6 @@ var SceneInspector = class {
     label.setAttribute("title", name);
     labelText.style.width = "18%";
     labelText.style.display = "inline-block";
-    labelText.innerText = `${id} (${val})`;
     const range = document.createElement("input");
     range.setAttribute("type", "range");
     range.style.width = "80%";
@@ -3741,8 +3721,10 @@ var SceneInspector = class {
     range.min = `${min}`;
     range.step = `${step}`;
     range.value = `${val}`;
+    labelText.innerText = `${id} (${range.value})`;
     const onChange = () => {
       change(parseFloat(range.value));
+      this.renderer.scene.dirty = true;
       labelText.innerText = `${id} (${range.value})`;
     };
     range.addEventListener("input", onChange);
@@ -3902,6 +3884,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 +4057,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 +4651,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 +4747,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 +4771,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 +4814,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 +4862,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 +4873,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 +4881,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 +9384,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 +9519,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 +9591,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 +9606,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 +9637,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 +9648,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 +9674,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 +9793,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 +9804,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 +9824,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 +9836,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 +9862,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 +9916,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 +9946,7 @@ export {
   BasicAssetKey,
   BatchedExecutor,
   BlockObject,
+  BlockStateResolver,
   BlockStates,
   BlockTints,
   BrowserArchiveProxy,
@@ -9772,6 +10005,8 @@ export {
   SceneStats,
   SceneStatsDisplay,
   SchematicParser,
+  SectionMesh,
+  SectionModels,
   SkinImage,
   SkinObject,
   SkinPart,