minerender 2.1.0-alpha.126 → 2.1.0-alpha.127

package/dist/browser/index.mjs

@@ -1676,6 +1676,7 @@ ${key}` : key, async () => {
         if (!object(data)) return false;
         if (dataset === "potionColors") return object(data.effects) && Object.values(data.effects).every(Number.isInteger) && object(data.potions) && Object.values(data.potions).every((effects) => Array.isArray(effects) && effects.every((effect) => object(effect) && typeof effect.id === "string" && Number.isInteger(effect.amplifier)));
         if (dataset === "legacyBlocks") return object(data.blocks) && Object.values(data.blocks).every((value) => typeof value === "string");
+        if (dataset === "blockCulling") return Array.isArray(data.profiles) && data.profiles.every((profile) => object(profile) && typeof profile.type === "string") && object(data.blocks) && Object.values(data.blocks).every((index) => Number.isInteger(index) && index >= 0 && index < data.profiles.length) && (data.groups === void 0 || object(data.groups) && Object.values(data.groups).every((group) => Array.isArray(group) && group.every((type) => typeof type === "string")));
         return Object.values(data).every((value) => {
           if (!object(value)) return false;
           switch (dataset) {
@@ -17636,6 +17637,38 @@ function sampleSectionLight(light, index) {
   };
 }
 
+// src/world/_culling/BlockCulling.ts
+init_Assets();
+init_MineRenderData();
+init_CubeFace();
+async function loadBlockCulling(root) {
+  const { manifest } = await MineRenderData.resolve(root);
+  return manifest.datasets.blockCulling ? MineRenderData.get("blockCulling", root) : void 0;
+}
+function blockCullingRule(data, type) {
+  if (!type.includes(":")) type = `${DEFAULT_NAMESPACE}:${type}`;
+  return Object.prototype.hasOwnProperty.call(data.blocks, type) ? data.profiles[data.blocks[type]] : void 0;
+}
+function skipsBlockFace(data, rule, block, neighbor, face) {
+  const type = block.type.includes(":") ? block.type : `${DEFAULT_NAMESPACE}:${block.type}`;
+  const other = neighbor.type.includes(":") ? neighbor.type : `${DEFAULT_NAMESPACE}:${neighbor.type}`;
+  const same = type === other;
+  const vertical = CUBE_FACES[face] === "up" /* UP */ || CUBE_FACES[face] === "down" /* DOWN */;
+  switch (rule.type) {
+    case "same_block":
+      return same;
+    case "same_block_vertical":
+      return same && vertical;
+    case "connected": {
+      if (vertical) return same;
+      const group = rule.group ? data.groups?.[rule.group] : void 0;
+      return (same || !!group?.includes(type) && group.includes(other)) && String(block.properties?.[CUBE_FACES[face]]) === "true" && String(neighbor.properties?.[CUBE_FACES[face ^ 1]]) === "true";
+    }
+    default:
+      return false;
+  }
+}
+
 // src/world/MineRenderWorld.ts
 var MineRenderWorld = class {
   constructor(scene, options = {}) {
@@ -18024,15 +18057,23 @@ var MineRenderWorld = class {
     return this.culling ?? (this.culling = Promise.resolve().then(async () => {
       let sliceStart = performance.now();
       try {
+        const culling = await loadBlockCulling();
         while (this.pendingCulling.size) {
           const batch = [...this.pendingCulling];
           this.pendingCulling.clear();
           for (const [chunk, indices] of batch) {
             const neighbors = CUBE_FACE_OFFSETS.map(([x, y, z]) => this._chunks.get(`${chunk.x + x}_${chunk.y + y}_${chunk.z + z}`));
-            const masks = chunk.updateCullMasks(indices === "all" ? void 0 : indices, (x, y, z) => {
+            const neighborAt = (x, y, z) => {
               const lx = x - chunk.x * 16, ly = y - chunk.y * 16, lz = z - chunk.z * 16;
               const section = neighbors[lx >= 16 ? 0 : lx < 0 ? 1 : ly >= 16 ? 2 : ly < 0 ? 3 : lz >= 16 ? 4 : 5];
-              return section?.isOccludingIndex((ly & 15) * 256 + (lz & 15) * 16 + (lx & 15)) ?? false;
+              return [section, (ly & 15) * 256 + (lz & 15) * 16 + (lx & 15)];
+            };
+            const masks = chunk.updateCullMasks(indices === "all" ? void 0 : indices, (x, y, z) => {
+              const [section, i] = neighborAt(x, y, z);
+              return section?.isOccludingIndex(i) ?? false;
+            }, culling, (x, y, z) => {
+              const [section, i] = neighborAt(x, y, z);
+              return section?.visibleBlockIndex(i);
             });
             const fluidIndices = indices === "all" ? function* () {
               for (let index = 0; index < 4096; index++) yield index;
@@ -19147,6 +19188,10 @@ var Chunk = class _Chunk {
   isBlockVisibleIndex(index) {
     return this.renderedBlocks.has(index) && !this.hiddenBlocks.has(index);
   }
+  /** Stored state of a rendered, visible cell, or `undefined`. */
+  visibleBlockIndex(index) {
+    return this.isBlockVisibleIndex(index) ? this.data.stateAt(this.data.idAt(index)) : void 0;
+  }
   /** Fluid kind bits and level of a cell, or 0. Hidden cells report 0. */
   fluidByteIndex(index) {
     return this.hiddenBlocks.has(index) ? 0 : this.fluidCells[index];
@@ -19165,18 +19210,30 @@ var Chunk = class _Chunk {
   async setCullMaskAt(pos, mask) {
     await this.setCullMaskIndex(_Chunk.chunkPosToBlockIndex(this.worldPosToChunkPos(pos)), mask);
   }
-  /** Recomputes section masks and returns changed per-block masks. Omit indices to visit every cell. */
-  updateCullMasks(indices, occludes) {
+  /**
+   * Recomputes section masks and returns changed per-block masks. Omit indices to visit every cell.
+   * `culling` supplies neighbor face rules; `blockAt` supplies visible states outside this chunk.
+   */
+  updateCullMasks(indices, occludes, culling, blockAt) {
     const changed = [];
+    const rules = [];
     for (const index of indices ?? this.fluidCells.keys()) {
       if (!this.isBlockVisibleIndex(index)) continue;
       const x = index % 16, y = Math.floor(index / 256), z = Math.floor(index / 16) % 16;
+      const id = this.data.idAt(index);
+      let rule = rules[id];
+      if (culling && rule === void 0) rules[id] = rule = blockCullingRule(culling, this.data.stateAt(id).type) ?? null;
+      const block = rule ? this.data.stateAt(id) : void 0;
       let mask = 0;
       for (let face = 0; face < CUBE_FACE_OFFSETS.length; face++) {
         const [dx, dy, dz] = CUBE_FACE_OFFSETS[face];
         const nx = x + dx, ny = y + dy, nz = z + dz;
         const inner = nx >= 0 && nx < 16 && ny >= 0 && ny < 16 && nz >= 0 && nz < 16;
         if (inner ? this.isOccludingIndex(ny * 256 + nz * 16 + nx) : occludes(this.x * 16 + nx, this.y * 16 + ny, this.z * 16 + nz)) mask |= 1 << face;
+        else if (rule) {
+          const neighbor = inner ? this.visibleBlockIndex(ny * 256 + nz * 16 + nx) : blockAt?.(this.x * 16 + nx, this.y * 16 + ny, this.z * 16 + nz);
+          if (neighbor && skipsBlockFace(culling, rule, block, neighbor, face)) mask |= 1 << face;
+        }
       }
       if (this.fluidCells[index]) this.meshDirty = true;
       const entries = this.sectionBlocks.get(index);