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

package/dist/node/index.mjs

@@ -1534,6 +1534,11 @@ var init_DisplayTransforms = __esm({
       }
       /** 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;
@@ -1542,7 +1547,7 @@ var init_DisplayTransforms = __esm({
         const translation = new Vector32(...transform.translation ?? [0, 0, 0]).clampScalar(-80, 80);
         translation.x *= sign;
         const scale = new Vector32(...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) {
@@ -1727,6 +1732,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) {
@@ -7116,16 +7122,21 @@ var init_ModelObject = __esm({
         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 Matrix48();
-          transform.multiply(new Matrix48().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 Matrix48().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;
@@ -17662,6 +17673,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 = {}) {
@@ -18050,15 +18093,23 @@ var MineRenderWorld = class {
     return 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;
@@ -19174,6 +19225,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];
@@ -19192,18 +19247,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);