minerender 2.1.0-alpha.125 → 2.1.0-alpha.127

package/dist/bundle.js

@@ -43098,6 +43098,11 @@ void main() {
         }
         /** Build a display pose for geometry already centered at the model's [8, 8, 8] pivot. */
         static getMatrix(display, position) {
+          const transform = this.getTransform(display, position);
+          return new Matrix4().compose(transform.position, transform.quaternion, transform.scale);
+        }
+        /** Position, rotation, and scale of a display pose for geometry already centered at the model's [8, 8, 8] pivot. */
+        static getTransform(display, position) {
           const transform = this.withHandFallbacks(display)?.[position] ?? {};
           const left = position === "firstperson_lefthand" /* FIRSTPERSON_LEFTHAND */ || position === "thirdperson_lefthand" /* THIRDPERSON_LEFTHAND */;
           const sign = left ? -1 : 1;
@@ -43106,7 +43111,7 @@ void main() {
           const translation = new Vector3(...transform.translation ?? [0, 0, 0]).clampScalar(-80, 80);
           translation.x *= sign;
           const scale = new Vector3(...transform.scale ?? [1, 1, 1]).clampScalar(-4, 4);
-          return new Matrix4().compose(translation, rotation, scale);
+          return { position: translation, quaternion: rotation, scale };
         }
         /** Transforms geometry in place and reverses triangle winding when the matrix reflects it. */
         static apply(geometry, matrix) {
@@ -43300,6 +43305,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) {
@@ -94784,16 +94790,21 @@ ${shader.fragmentShader}`.replace(
           const special = this.originalModel.special;
           if (special) {
             const parts2 = await SpecialItems.getParts(special, this.originalModel.key?.root, this.originalModel.components);
-            const transform = this.options.displayPosition ? DisplayTransforms.getMatrix(this.originalModel.display, this.options.displayPosition) : new Matrix4();
-            transform.multiply(new Matrix4().makeTranslation(-8, -8, -8));
+            const display = new SceneObject();
+            if (this.options.displayPosition) {
+              const transform = DisplayTransforms.getTransform(this.originalModel.display, this.options.displayPosition);
+              display.position.copy(transform.position);
+              display.quaternion.copy(transform.quaternion);
+              display.scale.copy(transform.scale);
+            }
+            this.add(display);
+            const offset = new Matrix4().makeTranslation(-8, -8, -8);
             try {
               const targets = [];
               for (const part of parts2) {
                 const object4 = new EntityObject(part.model, { flip: false, wireframe: this.options.wireframe, tints: part.tints, faces: part.faces });
-                object4.matrix.copy(transform).multiply(part.transform);
-                object4.matrixWorldNeedsUpdate = true;
-                object4.matrixAutoUpdate = false;
-                this.add(object4);
+                object4.matrix.multiplyMatrices(offset, part.transform).decompose(object4.position, object4.quaternion, object4.scale);
+                display.add(object4);
                 await object4.init(part.material);
                 object4.iterateAllMeshes((mesh) => {
                   const source = mesh.material;
@@ -108023,6 +108034,41 @@ gl_FragDepth=readDepth(vUv);
     };
   }
 
+  // src/world/_culling/BlockCulling.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  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 = {}) {
@@ -108411,15 +108457,23 @@ gl_FragDepth=readDepth(vUv);
       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(([x4, y5, z4]) => this._chunks.get(`${chunk.x + x4}_${chunk.y + y5}_${chunk.z + z4}`));
-              const masks = chunk.updateCullMasks(indices === "all" ? void 0 : indices, (x4, y5, z4) => {
+              const neighborAt = (x4, y5, z4) => {
                 const lx = x4 - chunk.x * 16, ly = y5 - chunk.y * 16, lz = z4 - 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, (x4, y5, z4) => {
+                const [section, i4] = neighborAt(x4, y5, z4);
+                return section?.isOccludingIndex(i4) ?? false;
+              }, culling, (x4, y5, z4) => {
+                const [section, i4] = neighborAt(x4, y5, z4);
+                return section?.visibleBlockIndex(i4);
               });
               const fluidIndices = indices === "all" ? function* () {
                 for (let index = 0; index < 4096; index++) yield index;
@@ -109549,6 +109603,10 @@ gl_FragDepth=readDepth(vUv);
     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];
@@ -109567,18 +109625,30 @@ gl_FragDepth=readDepth(vUv);
     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 x4 = index % 16, y5 = Math.floor(index / 256), z4 = 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 = x4 + dx, ny = y5 + dy, nz = z4 + 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);