minerender 2.1.0-alpha.120 → 2.1.0-alpha.121

package/dist/bundle.js

@@ -107752,7 +107752,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 +107953,38 @@ 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);
     }
+    /** 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 +108308,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 +108316,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 +108352,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 +108469,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 +108544,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 +108555,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) {
@@ -108585,8 +108664,10 @@ 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;
+          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 +108684,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];
         }
@@ -108756,7 +108838,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");
@@ -109186,6 +109269,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 +109476,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;
@@ -109407,6 +109515,7 @@ gl_FragDepth=readDepth(vUv);
       this.hiddenBlocks.clear();
       this.fluidCells.fill(0);
       this.waterTints = void 0;
+      this.ambientOcclusionCells = void 0;
       this.data.clear();
       this.biomes = void 0;
       if (notify) {