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

package/dist/node/index.mjs

@@ -17403,7 +17403,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 +17595,38 @@ 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);
   }
+  /** 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 +17950,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 +17958,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 +17994,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 +18105,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 +18174,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 +18185,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) {
@@ -18218,8 +18294,10 @@ 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;
+        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 +18314,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];
       }
@@ -18387,7 +18466,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");
@@ -18817,6 +18897,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 +19104,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;
@@ -19038,6 +19143,7 @@ var Chunk = class _Chunk {
     this.hiddenBlocks.clear();
     this.fluidCells.fill(0);
     this.waterTints = void 0;
+    this.ambientOcclusionCells = void 0;
     this.data.clear();
     this.biomes = void 0;
     if (notify) {