minerender 2.1.0-alpha.122 → 2.1.0-alpha.124

package/dist/node/index.mjs

@@ -3964,11 +3964,14 @@ var init_UVMapper = __esm({
         });
       }
       static fillMissingTextureKeys(textures, target) {
-        for (let faceName of CUBE_FACES) {
-          let v = textures[faceName];
-          if (v && v.startsWith("#")) {
-            target[faceName] = target[v.substr(1)];
+        for (const key in textures) {
+          let name = key;
+          const seen = /* @__PURE__ */ new Set();
+          while (textures[name]?.startsWith("#") && !seen.has(name)) {
+            seen.add(name);
+            name = textures[name].substr(1);
           }
+          if (name !== key) target[key] = target[name];
         }
         return target;
       }
@@ -17228,14 +17231,14 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-import { Color as Color13, Matrix3 as Matrix33, Matrix4 as Matrix413, Vector3 as Vector318 } from "three";
+import { Color as Color13, Vector3 as Vector320 } from "three";
 init_BlockStates();
 init_AssetKey();
 
 // src/world/MineRenderWorld.ts
 init_Model();
 init_util();
-import { Vector3 as Vector317 } from "three";
+import { Vector3 as Vector319 } from "three";
 init_AssetKey();
 init_BlockStates();
 init_CubeFace();
@@ -17498,11 +17501,74 @@ function resolveSavedEntity(entity) {
 
 // src/world/_entities/WorldEntities.ts
 init_BannerPatterns();
+import { Vector3 as Vector318 } from "three";
+
+// src/world/_picking/Picking.ts
+init_three();
+import { Matrix3 as Matrix33, Matrix4 as Matrix413 } from "three";
+function pickableMeshes(root, scene, raycaster) {
+  const result = [];
+  let attached = false;
+  for (let parent = root; parent; parent = parent.parent) {
+    if (!parent.visible) return result;
+    if (parent === scene) attached = true;
+  }
+  if (!attached) return result;
+  root.updateWorldMatrix(true, true);
+  root.traverseVisible((object4) => {
+    if (isMesh(object4) && raycaster.layers.test(object4.layers)) result.push(object4);
+  });
+  return result;
+}
+function visibleHits(raycaster, meshes) {
+  return raycaster.intersectObjects(meshes, false).filter((hit) => {
+    if (!hit.face) return false;
+    const mesh = hit.object;
+    const material = Array.isArray(mesh.material) ? mesh.material[hit.face.materialIndex] : mesh.material;
+    return material?.visible;
+  });
+}
+function hitNormal(hit) {
+  const mesh = hit.object;
+  const matrix = mesh.matrixWorld.clone();
+  if (isInstancedMesh(mesh) && hit.instanceId !== void 0) {
+    const instance = new Matrix413();
+    mesh.getMatrixAt(hit.instanceId, instance);
+    matrix.multiply(instance);
+  }
+  return hit.face.normal.clone().applyNormalMatrix(new Matrix33().getNormalMatrix(matrix));
+}
+
+// src/world/_entities/WorldEntities.ts
 var WorldEntities = class {
   constructor(scene) {
     this.scene = scene;
     this.columns = /* @__PURE__ */ new Map();
   }
+  /** Finds the nearest visible triangle belonging to an entity owned by this world. */
+  raycast(raycaster) {
+    const owners = /* @__PURE__ */ new Map();
+    for (const column of this.columns.values()) {
+      for (const [object4, placement] of column) {
+        for (const mesh of pickableMeshes(object4, this.scene, raycaster)) {
+          owners.set(mesh, { object: object4, ...placement });
+        }
+      }
+    }
+    for (const hit of visibleHits(raycaster, [...owners.keys()])) {
+      const mesh = hit.object;
+      const owner = owners.get(mesh);
+      return {
+        type: owner.type,
+        position: new Vector318(...owner.position),
+        object: owner.object,
+        point: hit.point.clone(),
+        normal: hitNormal(hit),
+        distance: hit.distance
+      };
+    }
+    return void 0;
+  }
   /** Captures column ownership before asynchronous block or asset loading starts. */
   prepare(entities = [], column) {
     const placements = entities.flatMap((entity) => {
@@ -17511,7 +17577,7 @@ var WorldEntities = class {
       const position = [...entity.position];
       const key = column?.join(",") ?? `${Math.floor(position[0] / 16)},${Math.floor(position[2] / 16)}`;
       let owner = this.columns.get(key);
-      if (!owner) this.columns.set(key, owner = /* @__PURE__ */ new Set());
+      if (!owner) this.columns.set(key, owner = /* @__PURE__ */ new Map());
       return [{ ...resolved, position, column: key, owner }];
     });
     return async () => {
@@ -17537,7 +17603,7 @@ var WorldEntities = class {
           object4.rotation.y = placement.yaw;
           await object4.init();
           if (!current()) return;
-          placement.owner.add(object4);
+          placement.owner.set(object4, { type: placement.key.toNamespacedString(), position: placement.position });
           this.scene.add(object4);
         } catch (error) {
           console.warn(`Could not draw saved entity ${placement.key.toNamespacedString()}, skipping it`, error);
@@ -17552,7 +17618,7 @@ var WorldEntities = class {
     const objects = this.columns.get(key);
     this.columns.delete(key);
     if (!objects) return;
-    for (const object4 of objects) {
+    for (const object4 of objects.keys()) {
       object4.removeFromScene();
       object4.dispose();
     }
@@ -17620,6 +17686,14 @@ var MineRenderWorld = class {
   raycast(raycaster) {
     return Chunk.raycast(this._chunks.values(), raycaster);
   }
+  /**
+   * Returns the nearest visible mob geometry hit when renderEntities is enabled.
+   * Respects layers and near/far; compare its distance with raycast() to account for blocks.
+   * Texture alpha does not change triangle intersections.
+   */
+  raycastEntities(raycaster) {
+    return this.entities?.raycast(raycaster);
+  }
   /** Whether neighboring opaque cubes shade block-face corners. Defaults to false. */
   get ambientOcclusion() {
     return this._ambientOcclusion;
@@ -17640,25 +17714,25 @@ var MineRenderWorld = class {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector317(posOrX, y, z));
+      return this.getBlockAt(new Vector319(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector319(posOrX[0], posOrX[1], posOrX[2]));
     }
     this.validatePosBounds(posOrX);
     return this.getChunkAt(posOrX)?.getBlockAt(posOrX);
   }
   getBiomeAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getBiomeAt(new Vector317(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector317(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new Vector319(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector319(...posOrX));
     this.validatePosBounds(posOrX);
     const cx = Math.floor(posOrX.x / 16), cy = Math.floor(posOrX.y / 16), cz = Math.floor(posOrX.z / 16);
     const lx = posOrX.x - cx * 16, ly = posOrX.y - cy * 16, lz = posOrX.z - cz * 16;
     return this.biomes.get(`${cx}_${cz}`)?.get(cy)?.[Math.floor(lx / 4) + Math.floor(lz / 4) * 4 + Math.floor(ly / 4) * 16];
   }
   getLightAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getLightAt(new Vector317(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getLightAt(new Vector317(...posOrX));
+    if (typeof posOrX === "number") return this.getLightAt(new Vector319(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getLightAt(new Vector319(...posOrX));
     this.validatePosBounds(posOrX);
     const { x, y: py, z: pz } = posOrX;
     const cx = Math.floor(x / 16), cy = Math.floor(py / 16), cz = Math.floor(pz / 16);
@@ -17676,10 +17750,10 @@ var MineRenderWorld = class {
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector317(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector319(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector317(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector319(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     return this.placeBlock(posOrX, yOrBlock);
   }
@@ -17690,10 +17764,10 @@ var MineRenderWorld = class {
   }
   async setBlockVisibleAt(posOrX, yOrVisible, z, visible) {
     if (typeof posOrX === "number") {
-      return this.setBlockVisibleAt(new Vector317(posOrX, yOrVisible, z), visible);
+      return this.setBlockVisibleAt(new Vector319(posOrX, yOrVisible, z), visible);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockVisibleAt(new Vector317(...posOrX), yOrVisible);
+      return this.setBlockVisibleAt(new Vector319(...posOrX), yOrVisible);
     }
     this.validatePosBounds(posOrX);
     await this.getChunkAt(posOrX)?.setBlockVisibleAt(posOrX, yOrVisible);
@@ -17719,7 +17793,7 @@ var MineRenderWorld = class {
     const collect = async (positions2) => {
       for (const pos of positions2) changes.set(pos.toArray().join(","), pos);
     };
-    const place = (block) => this.placeBlock(new Vector317(...block.position), block, collect);
+    const place = (block) => this.placeBlock(new Vector319(...block.position), block, collect);
     const keys = /* @__PURE__ */ new Map();
     const types = /* @__PURE__ */ new Set();
     for (const block of multiblock.blocks) {
@@ -17735,7 +17809,7 @@ var MineRenderWorld = class {
     }
     if (!executor) {
       const groups2 = /* @__PURE__ */ new Map();
-      const position = new Vector317();
+      const position = new Vector319();
       for (const block of multiblock.blocks) {
         const [x, y, z] = block.position;
         this.validatePosBounds(position.set(x, y, z));
@@ -17775,7 +17849,7 @@ var MineRenderWorld = class {
       try {
         positions = await chunk.placeBlocks(blocks);
       } finally {
-        positions ??= blocks.map(({ index }) => new Vector317(
+        positions ??= blocks.map(({ index }) => new Vector319(
           chunk.x * 16 + index % 16,
           chunk.y * 16 + Math.floor(index / 256),
           chunk.z * 16 + Math.floor(index / 16) % 16
@@ -17827,7 +17901,7 @@ var MineRenderWorld = class {
       }
       for (const section of chunk.sections) {
         if (section.biomes) {
-          const position = new Vector317(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new Vector319(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const copy = [...section.biomes];
           if (copy.length !== 64 || !copy.every((id) => typeof id === "string" && id.length > 0)) {
@@ -17843,7 +17917,7 @@ var MineRenderWorld = class {
       for (const section of chunk.sections) {
         if (!executor) {
           if (!occupiedSections.has(section.y)) continue;
-          const position = new Vector317(chunk.x * 16, section.y * 16, chunk.z * 16);
+          const position = new Vector319(chunk.x * 16, section.y * 16, chunk.z * 16);
           this.validatePosBounds(position);
           const target = this.getOrCreateChunkAt(position);
           try {
@@ -17947,7 +18021,7 @@ var MineRenderWorld = class {
     this.sectionModels?.clear();
   }
   updateCulling(positions) {
-    const neighbor = new Vector317();
+    const neighbor = new Vector319();
     for (const pos of positions) {
       const cx = Math.floor(pos.x / 16), cy = Math.floor(pos.y / 16), cz = Math.floor(pos.z / 16);
       const chunk = this._chunks.get(`${cx}_${cy}_${cz}`);
@@ -18078,7 +18152,7 @@ var MineRenderWorld = class {
   }
   /** Converts block coordinates to scene units by multiplying each component by 16. */
   static worldToScenePosition(pos) {
-    return new Vector317(
+    return new Vector319(
       pos.x * 16,
       pos.y * 16,
       pos.z * 16
@@ -18086,7 +18160,7 @@ var MineRenderWorld = class {
   }
   /** Converts scene units to block coordinates without rounding to an integer block. */
   static sceneToWorldPosition(pos) {
-    return new Vector317(
+    return new Vector319(
       pos.x / 16,
       pos.y / 16,
       pos.z / 16
@@ -18111,7 +18185,7 @@ init_Model();
 // src/world/SectionMesh.ts
 init_CanvasCompat();
 init_Materials();
-import { BufferGeometry as BufferGeometry9, Color as Color12, DoubleSide as DoubleSide8, Float32BufferAttribute as Float32BufferAttribute10, FrontSide as FrontSide4, Group as Group3, Mesh as Mesh10, Uint32BufferAttribute } from "three";
+import { BufferGeometry as BufferGeometry9, Color as Color12, DoubleSide as DoubleSide8, Float32BufferAttribute as Float32BufferAttribute10, FrontSide as FrontSide4, Group as Group3, Mesh as Mesh12, Uint32BufferAttribute } from "three";
 
 // src/world/SectionGeometry.ts
 init_FluidQuads();
@@ -18582,7 +18656,7 @@ var SectionMesh = class _SectionMesh extends Group3 {
       }
       material.vertexColors = true;
       const texture = material.uniforms?.map?.value ?? material.map;
-      const mesh = new Mesh10(geometry, material);
+      const mesh = new Mesh12(geometry, material);
       section.add(mesh);
       section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
@@ -18621,7 +18695,6 @@ init_FluidGeometry();
 init_FluidQuads();
 init_CubeFace();
 init_InstanceReference();
-init_three();
 var WATER_TINT2 = new Color13(4159204).toArray();
 var Chunk = class _Chunk {
   constructor(scene, x, y, z, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
@@ -18639,7 +18712,7 @@ var Chunk = class _Chunk {
     this.sectionBlocks = /* @__PURE__ */ new Map();
     this.hiddenBlocks = /* @__PURE__ */ new Set();
     this.fluidCells = new Uint8Array(4096);
-    this.blockPosition = new Vector318();
+    this.blockPosition = new Vector320();
     this.meshDirty = false;
     this.meshGeneration = 0;
     this.scene = scene;
@@ -18654,18 +18727,8 @@ var Chunk = class _Chunk {
     const meshes = (root, scene) => {
       const cached2 = roots.get(root);
       if (cached2) return cached2;
-      const result = [];
+      const result = pickableMeshes(root, scene, raycaster);
       roots.set(root, result);
-      let attached = false;
-      for (let parent = root; parent; parent = parent.parent) {
-        if (!parent.visible) return result;
-        if (parent === scene) attached = true;
-      }
-      if (!attached) return result;
-      root.updateWorldMatrix(true, true);
-      root.traverseVisible((object4) => {
-        if (isMesh(object4) && raycaster.layers.test(object4.layers)) result.push(object4);
-      });
       return result;
     };
     const add = (root, owner, reference) => {
@@ -18696,11 +18759,8 @@ var Chunk = class _Chunk {
         }
       }
     }
-    for (const hit of raycaster.intersectObjects([...targets.keys()], false)) {
-      if (!hit.face) continue;
+    for (const hit of visibleHits(raycaster, [...targets.keys()])) {
       const mesh = hit.object;
-      const material = Array.isArray(mesh.material) ? mesh.material[hit.face.materialIndex] : mesh.material;
-      if (!material?.visible) continue;
       const entry = targets.get(mesh);
       let owner = entry.owners.get(hit.instanceId) ?? entry.owners.get(void 0);
       if (entry.section) {
@@ -18710,21 +18770,15 @@ var Chunk = class _Chunk {
       if (!owner || owner.chunk.hiddenBlocks.has(owner.index)) continue;
       const info = owner.chunk.renderedBlocks.get(owner.index);
       if (!info) continue;
-      const matrix = mesh.matrixWorld.clone();
-      if (isInstancedMesh(mesh) && hit.instanceId !== void 0) {
-        const instance = new Matrix413();
-        mesh.getMatrixAt(hit.instanceId, instance);
-        matrix.multiply(instance);
-      }
       return {
-        position: new Vector318(
+        position: new Vector320(
           owner.chunk.x * 16 + owner.index % 16,
           owner.chunk.y * 16 + Math.floor(owner.index / 256),
           owner.chunk.z * 16 + Math.floor(owner.index / 16) % 16
         ),
         block: info.block,
         point: hit.point.clone(),
-        normal: hit.face.normal.clone().applyNormalMatrix(new Matrix33().getNormalMatrix(matrix)),
+        normal: hitNormal(hit),
         distance: hit.distance
       };
     }
@@ -18732,18 +18786,18 @@ var Chunk = class _Chunk {
   }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
-      return this.getBlockAt(new Vector318(posOrX, y, z));
+      return this.getBlockAt(new Vector320(posOrX, y, z));
     }
     if (isTripleArray(posOrX)) {
-      return this.getBlockAt(new Vector318(posOrX[0], posOrX[1], posOrX[2]));
+      return this.getBlockAt(new Vector320(posOrX[0], posOrX[1], posOrX[2]));
     }
     const pos = this.blockPosition.set(posOrX.x - this.x * 16, posOrX.y - this.y * 16, posOrX.z - this.z * 16);
     const index = _Chunk.chunkPosToBlockIndex(pos);
     return this.renderedBlocks.get(index);
   }
   getBiomeAt(posOrX, y, z) {
-    if (typeof posOrX === "number") return this.getBiomeAt(new Vector318(posOrX, y, z));
-    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector318(...posOrX));
+    if (typeof posOrX === "number") return this.getBiomeAt(new Vector320(posOrX, y, z));
+    if (isTripleArray(posOrX)) return this.getBiomeAt(new Vector320(...posOrX));
     const pos = this.worldPosToChunkPos(posOrX);
     _Chunk.chunkPosToBlockIndex(pos);
     return this.biomeAt ? this.biomeAt(posOrX.x, posOrX.y, posOrX.z) : this.biomes?.[Math.floor(pos.x / 4) + Math.floor(pos.z / 4) * 4 + Math.floor(pos.y / 4) * 16];
@@ -18786,17 +18840,17 @@ var Chunk = class _Chunk {
         this.hiddenBlocks.add(index);
         this.renderedBlocks.get(index)?.object?.setVisible(false);
       }
-      const positions = blocks.map(({ index }) => new Vector318(...this.positionAt(index)));
+      const positions = blocks.map(({ index }) => new Vector320(...this.positionAt(index)));
       if (this.onBlocksChanged) await this.onBlocksChanged(positions);
       else await this.rebuildSectionMesh();
     }
   }
   async setBlockAt(posOrX, yOrBlock, z, block) {
     if (typeof posOrX == "number") {
-      return this.setBlockAt(new Vector318(posOrX, yOrBlock, z), block);
+      return this.setBlockAt(new Vector320(posOrX, yOrBlock, z), block);
     }
     if (isTripleArray(posOrX)) {
-      return this.setBlockAt(new Vector318(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
+      return this.setBlockAt(new Vector320(posOrX[0], posOrX[1], posOrX[2]), yOrBlock);
     }
     const worldPos = posOrX;
     const pos = this.worldPosToChunkPos(worldPos);
@@ -18851,7 +18905,7 @@ var Chunk = class _Chunk {
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
       this.objectBlocks.delete(index);
-      const worldPos = new Vector318(
+      const worldPos = new Vector320(
         this.x * 16 + index % 16,
         this.y * 16 + Math.floor(index / 256),
         this.z * 16 + Math.floor(index / 16) % 16
@@ -18982,7 +19036,7 @@ var Chunk = class _Chunk {
           biome,
           biomePosition: this.biomePosition(index, blockState3, this.data.stateAt(this.data.idAt(index)))
         });
-        object4.setPosition(new Vector318(
+        object4.setPosition(new Vector320(
           this.x * 256 + index % 16 * 16,
           this.y * 256 + Math.floor(index / 256) * 16,
           this.z * 256 + Math.floor(index / 16) % 16 * 16
@@ -19245,7 +19299,7 @@ var Chunk = class _Chunk {
   /** Removes stored blocks and render objects. Set `notify` to false to skip the owning world's update. */
   async clear(notify = true) {
     const positions = notify && this.onBlocksChanged ? [...this.renderedBlocks.keys()].map((index) => this.chunkPosToWorldPos(
-      new Vector318(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
+      new Vector320(index % 16, Math.floor(index / 256), Math.floor(index / 16) % 16)
     )) : [];
     for (const info of this.renderedBlocks.values()) info.object?.removeFromScene();
     this.sectionBlocks.clear();
@@ -19281,14 +19335,14 @@ var Chunk = class _Chunk {
     return pos.y * 16 * 16 + pos.z * 16 + pos.x;
   }
   worldPosToChunkPos(pos) {
-    return new Vector318(
+    return new Vector320(
       pos.x - this.x * 16,
       pos.y - this.y * 16,
       pos.z - this.z * 16
     );
   }
   chunkPosToWorldPos(pos) {
-    return new Vector318(
+    return new Vector320(
       this.x * 16 + pos.x,
       this.y * 16 + pos.y,
       this.z * 16 + pos.z