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

package/dist/bundle.js

@@ -88859,11 +88859,14 @@ ${key}` : key;
           });
         }
         static fillMissingTextureKeys(textures, target) {
-          for (let faceName of CUBE_FACES) {
-            let v5 = textures[faceName];
-            if (v5 && v5.startsWith("#")) {
-              target[faceName] = target[v5.substr(1)];
+          for (const key in textures) {
+            let name2 = key;
+            const seen = /* @__PURE__ */ new Set();
+            while (textures[name2]?.startsWith("#") && !seen.has(name2)) {
+              seen.add(name2);
+              name2 = textures[name2].substr(1);
             }
+            if (name2 !== key) target[key] = target[name2];
           }
           return target;
         }
@@ -107853,11 +107856,77 @@ gl_FragDepth=readDepth(vUv);
 
   // src/world/_entities/WorldEntities.ts
   init_BannerPatterns();
+  init_three_module();
+
+  // src/world/_picking/Picking.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+  init_three_module();
+  init_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 Matrix4();
+      mesh.getMatrixAt(hit.instanceId, instance);
+      matrix.multiply(instance);
+    }
+    return hit.face.normal.clone().applyNormalMatrix(new Matrix3().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 Vector3(...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) => {
@@ -107866,7 +107935,7 @@ gl_FragDepth=readDepth(vUv);
         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 () => {
@@ -107892,7 +107961,7 @@ gl_FragDepth=readDepth(vUv);
             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 (error2) {
             console.warn(`Could not draw saved entity ${placement.key.toNamespacedString()}, skipping it`, error2);
@@ -107907,7 +107976,7 @@ gl_FragDepth=readDepth(vUv);
       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();
       }
@@ -107978,6 +108047,14 @@ gl_FragDepth=readDepth(vUv);
     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;
@@ -108993,7 +109070,6 @@ gl_FragDepth=readDepth(vUv);
   init_FluidQuads();
   init_CubeFace();
   init_InstanceReference();
-  init_three();
   var WATER_TINT2 = new Color(4159204).toArray();
   var Chunk = class _Chunk {
     constructor(scene, x4, y5, z4, onBlocksChanged, sectionModels, neighborCell, biomeAt, onBiomesChanged, lightAt, onLightCleared, ambientLight = 0) {
@@ -109026,18 +109102,8 @@ gl_FragDepth=readDepth(vUv);
       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) => {
@@ -109068,11 +109134,8 @@ gl_FragDepth=readDepth(vUv);
           }
         }
       }
-      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) {
@@ -109082,12 +109145,6 @@ gl_FragDepth=readDepth(vUv);
         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 Matrix4();
-          mesh.getMatrixAt(hit.instanceId, instance);
-          matrix.multiply(instance);
-        }
         return {
           position: new Vector3(
             owner.chunk.x * 16 + owner.index % 16,
@@ -109096,7 +109153,7 @@ gl_FragDepth=readDepth(vUv);
           ),
           block: info.block,
           point: hit.point.clone(),
-          normal: hit.face.normal.clone().applyNormalMatrix(new Matrix3().getNormalMatrix(matrix)),
+          normal: hitNormal(hit),
           distance: hit.distance
         };
       }
@@ -109678,6 +109735,11 @@ gl_FragDepth=readDepth(vUv);
   init_buffer2();
   init_process2();
 
+  // src/world/WorldEntityIntersection.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
   // src/world/WorldStreamer.ts
   init_dirname();
   init_buffer2();