minerender 2.1.0-alpha.120 → 2.1.0-alpha.122

package/dist/node/index.mjs

@@ -12463,6 +12463,10 @@ var BlockObject = class _BlockObject extends SceneObject {
   get blockEntities() {
     return this._entities;
   }
+  /** Model placements drawn for this block, including its fluid surface. */
+  get models() {
+    return this._models;
+  }
   /** Sets visibility for this block's model instances and block entities. */
   setVisible(visible) {
     this.visible = visible;
@@ -17224,7 +17228,7 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-import { Color as Color13, Vector3 as Vector318 } from "three";
+import { Color as Color13, Matrix3 as Matrix33, Matrix4 as Matrix413, Vector3 as Vector318 } from "three";
 init_BlockStates();
 init_AssetKey();
 
@@ -17403,7 +17407,8 @@ var SectionModels = class {
         atlas,
         cullFaces: new Uint8Array(cullFaces),
         occludes: ModelCulling.isOpaqueFullCube(atlas) && ModelCulling.toLocalMask(63, rotation) === 63,
-        layer: atlas.hasTranslucency ? 1 : 0
+        layer: atlas.hasTranslucency ? 1 : 0,
+        ambientOcclusion: model.ambientocclusion !== false
       };
       this.templates.add(template);
       return template;
@@ -17594,17 +17599,45 @@ var MineRenderWorld = class {
     this.light = /* @__PURE__ */ new Map();
     this.lightValidity = /* @__PURE__ */ new Map();
     this.highestSkySection = /* @__PURE__ */ new Map();
+    this.ambientOcclusionPending = false;
     this.pendingCulling = /* @__PURE__ */ new Map();
     if (options.savedLighting && !options.sectionMeshing) throw new TypeError("savedLighting requires sectionMeshing");
+    if (options.ambientOcclusion && !options.sectionMeshing) throw new TypeError("ambientOcclusion requires sectionMeshing");
     if (options.ambientLight !== void 0 && (!Number.isFinite(options.ambientLight) || options.ambientLight < 0 || options.ambientLight > 1)) {
       throw new RangeError("ambientLight must be a number from 0 to 1");
     }
     this.scene = scene;
     this.savedLighting = options.savedLighting ?? false;
     this.ambientLight = options.ambientLight ?? 0;
+    this._ambientOcclusion = options.ambientOcclusion ?? false;
     if (options.sectionMeshing) this.sectionModels = new SectionModels(options.maxAtlasSize);
     if (options.renderEntities) this.entities = new WorldEntities(scene);
   }
+  /**
+   * Returns the nearest visible block geometry hit, respecting the raycaster's layers and near/far range.
+   * Includes fluids and block entities; texture alpha does not change triangle intersections.
+   */
+  raycast(raycaster) {
+    return Chunk.raycast(this._chunks.values(), raycaster);
+  }
+  /** Whether neighboring opaque cubes shade block-face corners. Defaults to false. */
+  get ambientOcclusion() {
+    return this._ambientOcclusion;
+  }
+  /** Rebuilds loaded blocks with or without corner shading. Block data and saved lighting are preserved. */
+  async setAmbientOcclusion(enabled) {
+    if (typeof enabled !== "boolean") throw new TypeError("Ambient occlusion must be a boolean");
+    if (enabled && !this.sectionModels) throw new TypeError("ambientOcclusion requires sectionMeshing");
+    if (enabled === this._ambientOcclusion && !this.ambientOcclusionPending) {
+      await this.culling;
+      return;
+    }
+    this._ambientOcclusion = enabled;
+    this.ambientOcclusionPending = true;
+    for (const chunk of this._chunks.values()) this.pendingCulling.set(chunk, "all");
+    await this.updateCulling([]);
+    this.ambientOcclusionPending = false;
+  }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
       return this.getBlockAt(new Vector317(posOrX, y, z));
@@ -17928,7 +17961,7 @@ var MineRenderWorld = class {
             const index = (ny & 15) * 256 + (nz & 15) * 16 + (nx & 15);
             let pending = this.pendingCulling.get(section);
             if (pending === "all" || pending?.has(index)) continue;
-            if (Math.abs(x) + Math.abs(y) + Math.abs(z) > 1 && !section.isFluidIndex(index)) continue;
+            if (Math.abs(x) + Math.abs(y) + Math.abs(z) > 1 && !this._ambientOcclusion && !section.isFluidIndex(index)) continue;
             if (!pending) this.pendingCulling.set(section, pending = /* @__PURE__ */ new Set());
             pending.add(index);
           }
@@ -17936,6 +17969,7 @@ var MineRenderWorld = class {
       }
     }
     return this.culling ??= Promise.resolve().then(async () => {
+      let sliceStart = performance.now();
       try {
         while (this.pendingCulling.size) {
           const batch = [...this.pendingCulling];
@@ -17971,6 +18005,11 @@ var MineRenderWorld = class {
             }
             for (const [index, mask] of masks) await chunk.setCullMaskIndex(index, mask);
             await chunk.refreshLight(indices === "all" ? void 0 : indices);
+            chunk.refreshAmbientOcclusion(this._ambientOcclusion);
+            if ((this._ambientOcclusion || this.ambientOcclusionPending) && performance.now() - sliceStart > 8) {
+              await yieldToEventLoop();
+              sliceStart = performance.now();
+            }
           }
           await Promise.all(batch.map(([chunk]) => chunk.rebuildSectionMesh()));
         }
@@ -18077,6 +18116,50 @@ import { BufferGeometry as BufferGeometry9, Color as Color12, DoubleSide as Doub
 // src/world/SectionGeometry.ts
 init_FluidQuads();
 
+// src/world/_light/AmbientOcclusion.ts
+var AXIS_STRIDES = [1, 9, 3];
+function sectionAmbientOcclusionMask(cells, center) {
+  let mask = 0;
+  for (let y = -1; y <= 1; y++) for (let z = -1; z <= 1; z++) for (let x = -1; x <= 1; x++) {
+    if (Math.abs(x) + Math.abs(y) + Math.abs(z) < 2) continue;
+    if (cells[center + y * 324 + z * 18 + x]) mask |= 1 << (y + 1) * 9 + (z + 1) * 3 + x + 1;
+  }
+  return mask;
+}
+function cornerBrightness(mask, center, u, v) {
+  const sideU = mask >>> center + u & 1;
+  const sideV = mask >>> center + v & 1;
+  const corner = sideU && sideV ? 1 : mask >>> center + u + v & 1;
+  return 1 - (sideU + sideV + corner) * 0.2;
+}
+function quadAmbientOcclusion(positions, normals, quad, mask, output) {
+  output.fill(1);
+  if (!mask) return;
+  const start = quad * 12;
+  let axis = 0;
+  if (Math.abs(normals[start + 1]) > Math.abs(normals[start + axis])) axis = 1;
+  if (Math.abs(normals[start + 2]) > Math.abs(normals[start + axis])) axis = 2;
+  const uAxis = (axis + 1) % 3, vAxis = (axis + 2) % 3;
+  if (Math.abs(Math.abs(normals[start + axis]) - 1) > 1e-6 || Math.abs(normals[start + uAxis]) > 1e-6 || Math.abs(normals[start + vAxis]) > 1e-6) return;
+  const sign = normals[start + axis] > 0 ? 1 : -1;
+  for (let vertex = 0; vertex < 4; vertex++) {
+    const offset = start + vertex * 3;
+    if (Math.abs(positions[offset + axis] - sign * 8) > 16e-4 || Math.abs(positions[offset + uAxis]) > 8.0016 || Math.abs(positions[offset + vAxis]) > 8.0016) return;
+  }
+  const center = 13 + sign * AXIS_STRIDES[axis];
+  const u = AXIS_STRIDES[uAxis], v = AXIS_STRIDES[vAxis];
+  const lowLow = cornerBrightness(mask, center, -u, -v);
+  const highLow = cornerBrightness(mask, center, u, -v);
+  const lowHigh = cornerBrightness(mask, center, -u, v);
+  const highHigh = cornerBrightness(mask, center, u, v);
+  for (let vertex = 0; vertex < 4; vertex++) {
+    const offset = start + vertex * 3;
+    const a = Math.max(0, Math.min(1, (positions[offset + uAxis] + 8) / 16));
+    const b = Math.max(0, Math.min(1, (positions[offset + vAxis] + 8) / 16));
+    output[vertex] = (lowLow * (1 - a) + highLow * a) * (1 - b) + (lowHigh * (1 - a) + highHigh * a) * b;
+  }
+}
+
 // src/world/_light/FaceLight.ts
 function lightBrightness(level, ambient = 0) {
   if (level === 255) return 1;
@@ -18102,7 +18185,7 @@ var LIGHT_SAMPLE_OFFSETS = [0, 1, -1, 324, -324, 18, -18];
 
 // src/world/SectionGeometry.ts
 function buildSectionGeometry(input) {
-  const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight } = input;
+  const { count, indices, templates, cullMasks, templateData, atlases, maxAtlasSize, fluids, light, ambientLight, ambientOcclusion } = input;
   if (!Number.isInteger(maxAtlasSize) || maxAtlasSize < 1) throw new RangeError("Section atlas size must be a positive integer");
   if (count > indices.length || count > templates.length || count > cullMasks.length) throw new RangeError("Section entry count exceeds its arrays");
   if (fluids && fluids.cells.length !== 5832) throw new RangeError("Section fluid cells must cover an 18\xD718\xD718 neighborhood");
@@ -18113,6 +18196,10 @@ function buildSectionGeometry(input) {
   if (ambientLight !== void 0 && (!Number.isFinite(ambientLight) || ambientLight < 0 || ambientLight > 1)) {
     throw new RangeError("Section ambient light must be a number from 0 to 1");
   }
+  if (ambientOcclusion && (ambientOcclusion.length !== 5832 || ambientOcclusion.some((value) => value > 1))) {
+    throw new RangeError("Section ambient occlusion must cover an 18\xD718\xD718 neighborhood with zero or one per cell");
+  }
+  const cornerBrightness2 = ambientOcclusion ? new Float32Array(4) : void 0;
   for (const template of templateData) {
     const { quads } = template;
     if (template.positions.length !== quads * 12 || template.normals.length !== quads * 12 || template.uvs.length !== quads * 8 || template.uvBounds.length !== quads * 16 || template.colors.length !== quads * 12 || template.indices.length !== quads * 6 || template.cullFaces.length !== quads) {
@@ -18207,6 +18294,7 @@ function buildSectionGeometry(input) {
     const positions = new Float32Array(faces * 12), normals = new Float32Array(faces * 12);
     const uvs = new Float32Array(faces * 8), uvBounds = new Float32Array(faces * 16), colors = new Float32Array(faces * 12);
     const outputIndices = new Uint32Array(faces * 6);
+    const blockIndices = new Uint16Array(faces);
     let vertex = 0, indexOffset = 0;
     for (const entry of page.entries) {
       const template = templateData[templates[entry]];
@@ -18218,8 +18306,11 @@ function buildSectionGeometry(input) {
       const offsetY = Math.floor(indices[entry] / 256) * 16;
       const offsetZ = Math.floor(indices[entry] / 16) % 16 * 16;
       const lightIndex = (offsetY / 16 + 1) * 324 + (offsetZ / 16 + 1) * 18 + offsetX / 16 + 1;
+      const ambientMask = ambientOcclusion && template.ambientOcclusion !== false ? sectionAmbientOcclusionMask(ambientOcclusion, lightIndex) : 0;
       for (let quad = 0; quad < template.quads; quad++) {
         if (cullMasks[entry] & template.cullFaces[quad]) continue;
+        blockIndices[indexOffset / 6] = indices[entry];
+        if (ambientMask) quadAmbientOcclusion(template.positions, template.normals, quad, ambientMask, cornerBrightness2);
         const brightness = light ? lightBrightness(light[lightIndex + LIGHT_SAMPLE_OFFSETS[quadLightIndex(template.positions, template.normals, quad)]], ambientLight) : 1;
         const start = vertex;
         for (let corner = 0; corner < 4; corner++, vertex++) {
@@ -18236,9 +18327,10 @@ function buildSectionGeometry(input) {
           uvBounds[vertex * 4 + 1] = mapV(template.uvBounds[source * 4 + 1]);
           uvBounds[vertex * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
           uvBounds[vertex * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
-          colors[vertex * 3] = template.colors[source * 3] * brightness;
-          colors[vertex * 3 + 1] = template.colors[source * 3 + 1] * brightness;
-          colors[vertex * 3 + 2] = template.colors[source * 3 + 2] * brightness;
+          const factor = brightness * (ambientMask ? cornerBrightness2[corner] : 1);
+          colors[vertex * 3] = template.colors[source * 3] * factor;
+          colors[vertex * 3 + 1] = template.colors[source * 3 + 1] * factor;
+          colors[vertex * 3 + 2] = template.colors[source * 3 + 2] * factor;
         }
         for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[quad * 6 + corner];
       }
@@ -18250,6 +18342,7 @@ function buildSectionGeometry(input) {
       const mapV = (v) => 1 - (placement.y + (1 - v) * atlas.height) / page.height;
       const lightIndex = (y + 1) * 324 + (z + 1) * 18 + x + 1;
       for (let quad = 0; quad < quads.sprites.length; quad++) {
+        blockIndices[indexOffset / 6] = x + z * 16 + y * 256;
         const rect = quads.sprites[quad] === 0 ? data.still : data.flow;
         const brightness = light ? lightBrightness(fluidLightLevel(
           light[lightIndex],
@@ -18280,11 +18373,11 @@ function buildSectionGeometry(input) {
         indexOffset += 6;
       }
     }
-    return { layer: page.layer, width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, indices: outputIndices };
+    return { layer: page.layer, width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, indices: outputIndices, blockIndices };
   });
 }
 function sectionGeometryTransferables(pages) {
-  return pages.flatMap((page) => [page.positions.buffer, page.normals.buffer, page.uvs.buffer, page.uvBounds.buffer, page.colors.buffer, page.indices.buffer]);
+  return pages.flatMap((page) => [page.positions.buffer, page.normals.buffer, page.uvs.buffer, page.uvBounds.buffer, page.colors.buffer, page.indices.buffer, page.blockIndices.buffer]);
 }
 
 // src/world/SectionWorker.ts
@@ -18387,7 +18480,8 @@ function toInput(entries, maxAtlasSize, fluids, lighting) {
           indices: new Uint16Array(quads * 6),
           cullFaces: new Uint8Array(template.cullFaces),
           atlas: 0,
-          layer: template.layer
+          layer: template.layer,
+          ambientOcclusion: template.ambientOcclusion
         };
         const normal = template.geometry.getAttribute("normal");
         const uv = template.geometry.getAttribute("uv");
@@ -18442,6 +18536,12 @@ var SectionMesh = class _SectionMesh extends Group3 {
   constructor() {
     super(...arguments);
     this.ownedMeshes = [];
+    this.blockIndices = /* @__PURE__ */ new Map();
+  }
+  /** Returns the owning section cell for a triangle hit on this mesh's merged geometry. */
+  getBlockIndex(hit) {
+    if (hit.faceIndex === void 0 || hit.faceIndex === null) return void 0;
+    return this.blockIndices.get(hit.object)?.[Math.floor(hit.faceIndex / 2)];
   }
   /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
   static build(entries, maxAtlasSize = 2048, fluids, lighting) {
@@ -18484,6 +18584,7 @@ var SectionMesh = class _SectionMesh extends Group3 {
       const texture = material.uniforms?.map?.value ?? material.map;
       const mesh = new Mesh10(geometry, material);
       section.add(mesh);
+      section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
       for (const { atlas: id, x, y } of page.placements) {
         const atlas = atlases[id];
@@ -18509,6 +18610,7 @@ var SectionMesh = class _SectionMesh extends Group3 {
       mesh.material.dispose();
       texture?.dispose();
     }
+    this.blockIndices.clear();
     this.removeFromParent();
     super.dispose();
   }
@@ -18518,6 +18620,8 @@ var SectionMesh = class _SectionMesh extends Group3 {
 init_FluidGeometry();
 init_FluidQuads();
 init_CubeFace();
+init_InstanceReference();
+init_three();
 var WATER_TINT2 = new Color13(4159204).toArray();
 var Chunk = class _Chunk {
   constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
@@ -18531,6 +18635,7 @@ var Chunk = class _Chunk {
     this.ambientLight = ambientLight;
     this.data = new ChunkData();
     this.renderedBlocks = /* @__PURE__ */ new Map();
+    this.objectBlocks = /* @__PURE__ */ new Set();
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
     this.fluidCells = new Uint8Array(4096);
@@ -18542,6 +18647,89 @@ var Chunk = class _Chunk {
     this.y = y;
     this.z = z;
   }
+  /** Finds the nearest owned block hit across sections, testing each shared mesh once. */
+  static raycast(chunks, raycaster) {
+    const roots = /* @__PURE__ */ new Map();
+    const targets = /* @__PURE__ */ new Map();
+    const meshes = (root, scene) => {
+      const cached2 = roots.get(root);
+      if (cached2) return cached2;
+      const result = [];
+      roots.set(root, result);
+      let attached = false;
+      for (let parent = root; parent; parent = parent.parent) {
+        if (!parent.visible) return result;
+        if (parent === scene) attached = true;
+      }
+      if (!attached) return result;
+      root.updateWorldMatrix(true, true);
+      root.traverseVisible((object4) => {
+        if (isMesh(object4) && raycaster.layers.test(object4.layers)) result.push(object4);
+      });
+      return result;
+    };
+    const add = (root, owner, reference) => {
+      for (const mesh of meshes(root, owner.chunk.scene)) {
+        if (reference && reference.instanceable.getInstanceReference(mesh, reference.index) !== reference) continue;
+        let entry = targets.get(mesh);
+        if (!entry) targets.set(mesh, entry = { owners: /* @__PURE__ */ new Map() });
+        entry.owners.set(reference?.index, owner);
+      }
+    };
+    for (const chunk of chunks) {
+      for (const index of chunk.objectBlocks) {
+        const block = chunk.renderedBlocks.get(index).object;
+        if (!block || !block.visible || chunk.hiddenBlocks.has(index)) continue;
+        const owner = { chunk, index };
+        for (const model of block.models) {
+          if (isInstanceReference(model)) {
+            if (model.instanceable.isInstanceActive(model.index, model)) add(model.instanceable, owner, model);
+          } else {
+            add(model, owner);
+          }
+        }
+        for (const entity of block.blockEntities) add(entity, owner);
+      }
+      if (chunk.sectionMesh) {
+        for (const mesh of meshes(chunk.sectionMesh, chunk.scene)) {
+          targets.set(mesh, { owners: /* @__PURE__ */ new Map(), section: { chunk, mesh: chunk.sectionMesh } });
+        }
+      }
+    }
+    for (const hit of raycaster.intersectObjects([...targets.keys()], false)) {
+      if (!hit.face) continue;
+      const mesh = hit.object;
+      const material = Array.isArray(mesh.material) ? mesh.material[hit.face.materialIndex] : mesh.material;
+      if (!material?.visible) continue;
+      const entry = targets.get(mesh);
+      let owner = entry.owners.get(hit.instanceId) ?? entry.owners.get(void 0);
+      if (entry.section) {
+        const index = entry.section.mesh.getBlockIndex(hit);
+        if (index !== void 0) owner = { chunk: entry.section.chunk, index };
+      }
+      if (!owner || owner.chunk.hiddenBlocks.has(owner.index)) continue;
+      const info = owner.chunk.renderedBlocks.get(owner.index);
+      if (!info) continue;
+      const matrix = mesh.matrixWorld.clone();
+      if (isInstancedMesh(mesh) && hit.instanceId !== void 0) {
+        const instance = new Matrix413();
+        mesh.getMatrixAt(hit.instanceId, instance);
+        matrix.multiply(instance);
+      }
+      return {
+        position: new Vector318(
+          owner.chunk.x * 16 + owner.index % 16,
+          owner.chunk.y * 16 + Math.floor(owner.index / 256),
+          owner.chunk.z * 16 + Math.floor(owner.index / 16) % 16
+        ),
+        block: info.block,
+        point: hit.point.clone(),
+        normal: hit.face.normal.clone().applyNormalMatrix(new Matrix33().getNormalMatrix(matrix)),
+        distance: hit.distance
+      };
+    }
+    return void 0;
+  }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
       return this.getBlockAt(new Vector318(posOrX, y, z));
@@ -18662,6 +18850,7 @@ var Chunk = class _Chunk {
       if (this.fluidCells[index]) this.meshDirty = true;
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
+      this.objectBlocks.delete(index);
       const worldPos = new Vector318(
         this.x * 16 + index % 16,
         this.y * 16 + Math.floor(index / 256),
@@ -18704,6 +18893,7 @@ var Chunk = class _Chunk {
         this.renderedBlocks.set(index, { get block() {
           return readBlock();
         }, object: object4 });
+        if (object4) this.objectBlocks.add(index);
       } catch (error) {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
@@ -18722,6 +18912,7 @@ var Chunk = class _Chunk {
     this.fluidCells.fill(0);
     this.waterTints = void 0;
     this.renderedBlocks.clear();
+    this.objectBlocks.clear();
     this.hiddenBlocks.clear();
     this.meshDirty = true;
     this.data.copyFrom(data);
@@ -18771,6 +18962,7 @@ var Chunk = class _Chunk {
         this.renderedBlocks.set(index, { get block() {
           return readBlock();
         }, object: void 0 });
+        this.objectBlocks.delete(index);
       } catch (error) {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
@@ -18796,10 +18988,12 @@ var Chunk = class _Chunk {
           this.z * 256 + Math.floor(index / 16) % 16 * 16
         ));
         this.renderedBlocks.get(index).object = object4;
+        this.objectBlocks.add(index);
       } catch (error) {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
         this.renderedBlocks.delete(index);
+        this.objectBlocks.delete(index);
         object4?.removeFromScene();
         if (!failed) failure = error;
         failed = true;
@@ -18817,6 +19011,25 @@ var Chunk = class _Chunk {
       if (this.renderedBlocks.has(index)) this.meshDirty = true;
     }
   }
+  /** Refreshes baked corner shading after edits or a world setting change. Disabled chunks keep no AO neighborhood. */
+  refreshAmbientOcclusion(enabled) {
+    if (!enabled && !this.ambientOcclusionCells) return;
+    const cells = enabled ? this.buildAmbientOcclusionCells() : void 0;
+    if (cells?.some((value, index) => value !== this.ambientOcclusionCells?.[index]) || !!cells !== !!this.ambientOcclusionCells) this.meshDirty = true;
+    this.ambientOcclusionCells = cells;
+  }
+  buildAmbientOcclusionCells() {
+    const cells = new Uint8Array(18 * 18 * 18);
+    for (let y = -1; y <= 16; y++) {
+      for (let z = -1; z <= 16; z++) {
+        for (let x = -1; x <= 16; x++) {
+          const inner = x >= 0 && x < 16 && y >= 0 && y < 16 && z >= 0 && z < 16;
+          cells[(y + 1) * 324 + (z + 1) * 18 + x + 1] = inner ? Number(this.isOccludingIndex(y * 256 + z * 16 + x)) : Number(!!((this.neighborCell?.(this.x * 16 + x, this.y * 16 + y, this.z * 16 + z) ?? 0) & 64));
+        }
+      }
+    }
+    return cells;
+  }
   biomePosition(index, blockState3, stored) {
     const position = this.positionAt(index), name = blockState3.key?.toNamespacedString();
     if (stored.properties?.half === "upper" && (name === "minecraft:tall_grass" || name === "minecraft:large_fern")) position[1]--;
@@ -19005,12 +19218,18 @@ var Chunk = class _Chunk {
         }
       }
     }
-    const next = entries.length || fluids ? await SectionMesh.buildAsync(
-      entries,
-      this.sectionModels.maxAtlasSize,
-      fluids,
-      light ? { light, ambientLight: this.ambientLight } : void 0
-    ) : void 0;
+    let next;
+    try {
+      next = entries.length || fluids ? await SectionMesh.buildAsync(
+        entries,
+        this.sectionModels.maxAtlasSize,
+        fluids,
+        { light, ambientLight: this.ambientLight, ambientOcclusion: this.ambientOcclusionCells }
+      ) : void 0;
+    } catch (error) {
+      if (generation === this.meshGeneration) this.meshDirty = true;
+      throw error;
+    }
     if (generation !== this.meshGeneration) {
       next?.dispose();
       return;
@@ -19035,9 +19254,11 @@ var Chunk = class _Chunk {
     this.sectionMesh = void 0;
     this.meshDirty = false;
     this.renderedBlocks.clear();
+    this.objectBlocks.clear();
     this.hiddenBlocks.clear();
     this.fluidCells.fill(0);
     this.waterTints = void 0;
+    this.ambientOcclusionCells = void 0;
     this.data.clear();
     this.biomes = void 0;
     if (notify) {