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

package/dist/bundle.js

@@ -100712,6 +100712,10 @@ property list uchar int vertex_index
     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;
@@ -107752,7 +107756,8 @@ gl_FragDepth=readDepth(vUv);
           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;
@@ -107952,17 +107957,45 @@ gl_FragDepth=readDepth(vUv);
       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, y5, z4) {
       if (typeof posOrX == "number") {
         return this.getBlockAt(new Vector3(posOrX, y5, z4));
@@ -108286,7 +108319,7 @@ gl_FragDepth=readDepth(vUv);
               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(x4) + Math.abs(y5) + Math.abs(z4) > 1 && !section.isFluidIndex(index)) continue;
+              if (Math.abs(x4) + Math.abs(y5) + Math.abs(z4) > 1 && !this._ambientOcclusion && !section.isFluidIndex(index)) continue;
               if (!pending) this.pendingCulling.set(section, pending = /* @__PURE__ */ new Set());
               pending.add(index);
             }
@@ -108294,6 +108327,7 @@ gl_FragDepth=readDepth(vUv);
         }
       }
       return this.culling ?? (this.culling = Promise.resolve().then(async () => {
+        let sliceStart = performance.now();
         try {
           while (this.pendingCulling.size) {
             const batch = [...this.pendingCulling];
@@ -108329,6 +108363,11 @@ gl_FragDepth=readDepth(vUv);
               }
               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()));
           }
@@ -108441,6 +108480,53 @@ gl_FragDepth=readDepth(vUv);
   init_process2();
   init_FluidQuads();
 
+  // src/world/_light/AmbientOcclusion.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  var AXIS_STRIDES = [1, 9, 3];
+  function sectionAmbientOcclusionMask(cells, center) {
+    let mask = 0;
+    for (let y5 = -1; y5 <= 1; y5++) for (let z4 = -1; z4 <= 1; z4++) for (let x4 = -1; x4 <= 1; x4++) {
+      if (Math.abs(x4) + Math.abs(y5) + Math.abs(z4) < 2) continue;
+      if (cells[center + y5 * 324 + z4 * 18 + x4]) mask |= 1 << (y5 + 1) * 9 + (z4 + 1) * 3 + x4 + 1;
+    }
+    return mask;
+  }
+  function cornerBrightness(mask, center, u4, v5) {
+    const sideU = mask >>> center + u4 & 1;
+    const sideV = mask >>> center + v5 & 1;
+    const corner = sideU && sideV ? 1 : mask >>> center + u4 + v5 & 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 vertex2 = 0; vertex2 < 4; vertex2++) {
+      const offset = start + vertex2 * 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 u4 = AXIS_STRIDES[uAxis], v5 = AXIS_STRIDES[vAxis];
+    const lowLow = cornerBrightness(mask, center, -u4, -v5);
+    const highLow = cornerBrightness(mask, center, u4, -v5);
+    const lowHigh = cornerBrightness(mask, center, -u4, v5);
+    const highHigh = cornerBrightness(mask, center, u4, v5);
+    for (let vertex2 = 0; vertex2 < 4; vertex2++) {
+      const offset = start + vertex2 * 3;
+      const a4 = Math.max(0, Math.min(1, (positions[offset + uAxis] + 8) / 16));
+      const b4 = Math.max(0, Math.min(1, (positions[offset + vAxis] + 8) / 16));
+      output[vertex2] = (lowLow * (1 - a4) + highLow * a4) * (1 - b4) + (lowHigh * (1 - a4) + highHigh * a4) * b4;
+    }
+  }
+
   // src/world/_light/FaceLight.ts
   init_dirname();
   init_buffer2();
@@ -108469,7 +108555,7 @@ gl_FragDepth=readDepth(vUv);
 
   // 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");
@@ -108480,6 +108566,10 @@ gl_FragDepth=readDepth(vUv);
     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) {
@@ -108574,6 +108664,7 @@ gl_FragDepth=readDepth(vUv);
       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 vertex2 = 0, indexOffset = 0;
       for (const entry of page.entries) {
         const template = templateData[templates[entry]];
@@ -108585,8 +108676,11 @@ gl_FragDepth=readDepth(vUv);
         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 = vertex2;
           for (let corner = 0; corner < 4; corner++, vertex2++) {
@@ -108603,9 +108697,10 @@ gl_FragDepth=readDepth(vUv);
             uvBounds[vertex2 * 4 + 1] = mapV(template.uvBounds[source * 4 + 1]);
             uvBounds[vertex2 * 4 + 2] = mapU(template.uvBounds[source * 4 + 2]);
             uvBounds[vertex2 * 4 + 3] = mapV(template.uvBounds[source * 4 + 3]);
-            colors[vertex2 * 3] = template.colors[source * 3] * brightness;
-            colors[vertex2 * 3 + 1] = template.colors[source * 3 + 1] * brightness;
-            colors[vertex2 * 3 + 2] = template.colors[source * 3 + 2] * brightness;
+            const factor = brightness * (ambientMask ? cornerBrightness2[corner] : 1);
+            colors[vertex2 * 3] = template.colors[source * 3] * factor;
+            colors[vertex2 * 3 + 1] = template.colors[source * 3 + 1] * factor;
+            colors[vertex2 * 3 + 2] = template.colors[source * 3 + 2] * factor;
           }
           for (let corner = 0; corner < 6; corner++) outputIndices[indexOffset++] = start + template.indices[quad * 6 + corner];
         }
@@ -108617,6 +108712,7 @@ gl_FragDepth=readDepth(vUv);
         const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
         const lightIndex = (y5 + 1) * 324 + (z4 + 1) * 18 + x4 + 1;
         for (let quad = 0; quad < quads.sprites.length; quad++) {
+          blockIndices[indexOffset / 6] = x4 + z4 * 16 + y5 * 256;
           const rect = quads.sprites[quad] === 0 ? data.still : data.flow;
           const brightness = light ? lightBrightness(fluidLightLevel(
             light[lightIndex],
@@ -108647,11 +108743,11 @@ gl_FragDepth=readDepth(vUv);
           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
@@ -108756,7 +108852,8 @@ gl_FragDepth=readDepth(vUv);
             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");
@@ -108811,6 +108908,12 @@ gl_FragDepth=readDepth(vUv);
     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) {
@@ -108853,6 +108956,7 @@ gl_FragDepth=readDepth(vUv);
         const texture = material.uniforms?.map?.value ?? material.map;
         const mesh = new Mesh(geometry, material);
         section.add(mesh);
+        section.blockIndices.set(mesh, page.blockIndices);
         const unsubscribe = [];
         for (const { atlas: id, x: x4, y: y5 } of page.placements) {
           const atlas = atlases[id];
@@ -108878,6 +108982,7 @@ gl_FragDepth=readDepth(vUv);
         mesh.material.dispose();
         texture?.dispose();
       }
+      this.blockIndices.clear();
       this.removeFromParent();
       super.dispose();
     }
@@ -108887,6 +108992,8 @@ gl_FragDepth=readDepth(vUv);
   init_FluidGeometry();
   init_FluidQuads();
   init_CubeFace();
+  init_InstanceReference();
+  init_three();
   var WATER_TINT2 = new Color(4159204).toArray();
   var Chunk = class _Chunk {
     constructor(scene, x4, y5, z4, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
@@ -108900,6 +109007,7 @@ gl_FragDepth=readDepth(vUv);
       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);
@@ -108911,6 +109019,89 @@ gl_FragDepth=readDepth(vUv);
       this.y = y5;
       this.z = z4;
     }
+    /** 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 Matrix4();
+          mesh.getMatrixAt(hit.instanceId, instance);
+          matrix.multiply(instance);
+        }
+        return {
+          position: new Vector3(
+            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 Matrix3().getNormalMatrix(matrix)),
+          distance: hit.distance
+        };
+      }
+      return void 0;
+    }
     getBlockAt(posOrX, y5, z4) {
       if (typeof posOrX == "number") {
         return this.getBlockAt(new Vector3(posOrX, y5, z4));
@@ -109031,6 +109222,7 @@ gl_FragDepth=readDepth(vUv);
         if (this.fluidCells[index]) this.meshDirty = true;
         this.fluidCells[index] = 0;
         this.renderedBlocks.delete(index);
+        this.objectBlocks.delete(index);
         const worldPos = new Vector3(
           this.x * 16 + index % 16,
           this.y * 16 + Math.floor(index / 256),
@@ -109073,6 +109265,7 @@ gl_FragDepth=readDepth(vUv);
           this.renderedBlocks.set(index, { get block() {
             return readBlock();
           }, object: object4 });
+          if (object4) this.objectBlocks.add(index);
         } catch (error2) {
           this.data.assign(index, 0);
           this.fluidCells[index] = 0;
@@ -109091,6 +109284,7 @@ gl_FragDepth=readDepth(vUv);
       this.fluidCells.fill(0);
       this.waterTints = void 0;
       this.renderedBlocks.clear();
+      this.objectBlocks.clear();
       this.hiddenBlocks.clear();
       this.meshDirty = true;
       this.data.copyFrom(data);
@@ -109140,6 +109334,7 @@ gl_FragDepth=readDepth(vUv);
           this.renderedBlocks.set(index, { get block() {
             return readBlock();
           }, object: void 0 });
+          this.objectBlocks.delete(index);
         } catch (error2) {
           this.data.assign(index, 0);
           this.fluidCells[index] = 0;
@@ -109165,10 +109360,12 @@ gl_FragDepth=readDepth(vUv);
             this.z * 256 + Math.floor(index / 16) % 16 * 16
           ));
           this.renderedBlocks.get(index).object = object4;
+          this.objectBlocks.add(index);
         } catch (error2) {
           this.data.assign(index, 0);
           this.fluidCells[index] = 0;
           this.renderedBlocks.delete(index);
+          this.objectBlocks.delete(index);
           object4?.removeFromScene();
           if (!failed) failure = error2;
           failed = true;
@@ -109186,6 +109383,25 @@ gl_FragDepth=readDepth(vUv);
         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 y5 = -1; y5 <= 16; y5++) {
+        for (let z4 = -1; z4 <= 16; z4++) {
+          for (let x4 = -1; x4 <= 16; x4++) {
+            const inner = x4 >= 0 && x4 < 16 && y5 >= 0 && y5 < 16 && z4 >= 0 && z4 < 16;
+            cells[(y5 + 1) * 324 + (z4 + 1) * 18 + x4 + 1] = inner ? Number(this.isOccludingIndex(y5 * 256 + z4 * 16 + x4)) : Number(!!((this.neighborCell?.(this.x * 16 + x4, this.y * 16 + y5, this.z * 16 + z4) ?? 0) & 64));
+          }
+        }
+      }
+      return cells;
+    }
     biomePosition(index, blockState3, stored) {
       const position = this.positionAt(index), name2 = blockState3.key?.toNamespacedString();
       if (stored.properties?.half === "upper" && (name2 === "minecraft:tall_grass" || name2 === "minecraft:large_fern")) position[1]--;
@@ -109374,12 +109590,18 @@ gl_FragDepth=readDepth(vUv);
           }
         }
       }
-      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 (error2) {
+        if (generation === this.meshGeneration) this.meshDirty = true;
+        throw error2;
+      }
       if (generation !== this.meshGeneration) {
         next?.dispose();
         return;
@@ -109404,9 +109626,11 @@ gl_FragDepth=readDepth(vUv);
       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) {
@@ -109444,6 +109668,11 @@ gl_FragDepth=readDepth(vUv);
     }
   };
 
+  // src/world/WorldBlockIntersection.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
   // src/world/WorldChunkSource.ts
   init_dirname();
   init_buffer2();