minerender 2.1.0-alpha.121 → 2.1.0-alpha.123

package/dist/bundle.js

@@ -100712,6 +100712,10 @@ property list uchar int vertex_index
     get blockEntities() {
       return this._entities;
     }
+    /** Model placements drawn for this block, including its fluid surface. */
+    get models() {
+      return this._models;
+    }
     /** Sets visibility for this block's model instances and block entities. */
     setVisible(visible) {
       this.visible = visible;
@@ -107849,11 +107853,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) => {
@@ -107862,7 +107932,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 () => {
@@ -107888,7 +107958,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);
@@ -107903,7 +107973,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();
       }
@@ -107967,6 +108037,21 @@ gl_FragDepth=readDepth(vUv);
       if (options.sectionMeshing) this.sectionModels = new SectionModels(options.maxAtlasSize);
       if (options.renderEntities) this.entities = new WorldEntities(scene);
     }
+    /**
+     * Returns the nearest visible block geometry hit, respecting the raycaster's layers and near/far range.
+     * Includes fluids and block entities; texture alpha does not change triangle intersections.
+     */
+    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;
@@ -108653,6 +108738,7 @@ gl_FragDepth=readDepth(vUv);
       const positions = new Float32Array(faces * 12), normals = new Float32Array(faces * 12);
       const uvs = new Float32Array(faces * 8), uvBounds = new Float32Array(faces * 16), colors = new Float32Array(faces * 12);
       const outputIndices = new Uint32Array(faces * 6);
+      const blockIndices = new Uint16Array(faces);
       let vertex2 = 0, indexOffset = 0;
       for (const entry of page.entries) {
         const template = templateData[templates[entry]];
@@ -108667,6 +108753,7 @@ gl_FragDepth=readDepth(vUv);
         const ambientMask = ambientOcclusion && template.ambientOcclusion !== false ? sectionAmbientOcclusionMask(ambientOcclusion, lightIndex) : 0;
         for (let quad = 0; quad < template.quads; quad++) {
           if (cullMasks[entry] & template.cullFaces[quad]) continue;
+          blockIndices[indexOffset / 6] = indices[entry];
           if (ambientMask) quadAmbientOcclusion(template.positions, template.normals, quad, ambientMask, cornerBrightness2);
           const brightness = light ? lightBrightness(light[lightIndex + LIGHT_SAMPLE_OFFSETS[quadLightIndex(template.positions, template.normals, quad)]], ambientLight) : 1;
           const start = vertex2;
@@ -108699,6 +108786,7 @@ gl_FragDepth=readDepth(vUv);
         const mapV = (v5) => 1 - (placement.y + (1 - v5) * atlas.height) / page.height;
         const lightIndex = (y5 + 1) * 324 + (z4 + 1) * 18 + x4 + 1;
         for (let quad = 0; quad < quads.sprites.length; quad++) {
+          blockIndices[indexOffset / 6] = x4 + z4 * 16 + y5 * 256;
           const rect = quads.sprites[quad] === 0 ? data.still : data.flow;
           const brightness = light ? lightBrightness(fluidLightLevel(
             light[lightIndex],
@@ -108729,11 +108817,11 @@ gl_FragDepth=readDepth(vUv);
           indexOffset += 6;
         }
       }
-      return { layer: page.layer, width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, indices: outputIndices };
+      return { layer: page.layer, width: page.width, height: page.height, placements: page.placements, positions, normals, uvs, uvBounds, colors, indices: outputIndices, blockIndices };
     });
   }
   function sectionGeometryTransferables(pages) {
-    return pages.flatMap((page) => [page.positions.buffer, page.normals.buffer, page.uvs.buffer, page.uvBounds.buffer, page.colors.buffer, page.indices.buffer]);
+    return pages.flatMap((page) => [page.positions.buffer, page.normals.buffer, page.uvs.buffer, page.uvBounds.buffer, page.colors.buffer, page.indices.buffer, page.blockIndices.buffer]);
   }
 
   // src/world/SectionWorker.ts
@@ -108894,6 +108982,12 @@ gl_FragDepth=readDepth(vUv);
     constructor() {
       super(...arguments);
       this.ownedMeshes = [];
+      this.blockIndices = /* @__PURE__ */ new Map();
+    }
+    /** Returns the owning section cell for a triangle hit on this mesh's merged geometry. */
+    getBlockIndex(hit) {
+      if (hit.faceIndex === void 0 || hit.faceIndex === null) return void 0;
+      return this.blockIndices.get(hit.object)?.[Math.floor(hit.faceIndex / 2)];
     }
     /** Builds section-local meshes from visible quads. `maxAtlasSize` limits each atlas dimension in pixels. */
     static build(entries, maxAtlasSize = 2048, fluids, lighting) {
@@ -108936,6 +109030,7 @@ gl_FragDepth=readDepth(vUv);
         const texture = material.uniforms?.map?.value ?? material.map;
         const mesh = new Mesh(geometry, material);
         section.add(mesh);
+        section.blockIndices.set(mesh, page.blockIndices);
         const unsubscribe = [];
         for (const { atlas: id, x: x4, y: y5 } of page.placements) {
           const atlas = atlases[id];
@@ -108961,6 +109056,7 @@ gl_FragDepth=readDepth(vUv);
         mesh.material.dispose();
         texture?.dispose();
       }
+      this.blockIndices.clear();
       this.removeFromParent();
       super.dispose();
     }
@@ -108970,6 +109066,7 @@ gl_FragDepth=readDepth(vUv);
   init_FluidGeometry();
   init_FluidQuads();
   init_CubeFace();
+  init_InstanceReference();
   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) {
@@ -108983,6 +109080,7 @@ gl_FragDepth=readDepth(vUv);
       this.ambientLight = ambientLight;
       this.data = new ChunkData();
       this.renderedBlocks = /* @__PURE__ */ new Map();
+      this.objectBlocks = /* @__PURE__ */ new Set();
       this.sectionBlocks = /* @__PURE__ */ new Map();
       this.hiddenBlocks = /* @__PURE__ */ new Set();
       this.fluidCells = new Uint8Array(4096);
@@ -108994,6 +109092,70 @@ gl_FragDepth=readDepth(vUv);
       this.y = y5;
       this.z = z4;
     }
+    /** Finds the nearest owned block hit across sections, testing each shared mesh once. */
+    static raycast(chunks, raycaster) {
+      const roots = /* @__PURE__ */ new Map();
+      const targets = /* @__PURE__ */ new Map();
+      const meshes = (root, scene) => {
+        const cached2 = roots.get(root);
+        if (cached2) return cached2;
+        const result = pickableMeshes(root, scene, raycaster);
+        roots.set(root, result);
+        return result;
+      };
+      const add = (root, owner, reference) => {
+        for (const mesh of meshes(root, owner.chunk.scene)) {
+          if (reference && reference.instanceable.getInstanceReference(mesh, reference.index) !== reference) continue;
+          let entry = targets.get(mesh);
+          if (!entry) targets.set(mesh, entry = { owners: /* @__PURE__ */ new Map() });
+          entry.owners.set(reference?.index, owner);
+        }
+      };
+      for (const chunk of chunks) {
+        for (const index of chunk.objectBlocks) {
+          const block = chunk.renderedBlocks.get(index).object;
+          if (!block || !block.visible || chunk.hiddenBlocks.has(index)) continue;
+          const owner = { chunk, index };
+          for (const model of block.models) {
+            if (isInstanceReference(model)) {
+              if (model.instanceable.isInstanceActive(model.index, model)) add(model.instanceable, owner, model);
+            } else {
+              add(model, owner);
+            }
+          }
+          for (const entity of block.blockEntities) add(entity, owner);
+        }
+        if (chunk.sectionMesh) {
+          for (const mesh of meshes(chunk.sectionMesh, chunk.scene)) {
+            targets.set(mesh, { owners: /* @__PURE__ */ new Map(), section: { chunk, mesh: chunk.sectionMesh } });
+          }
+        }
+      }
+      for (const hit of visibleHits(raycaster, [...targets.keys()])) {
+        const mesh = hit.object;
+        const entry = targets.get(mesh);
+        let owner = entry.owners.get(hit.instanceId) ?? entry.owners.get(void 0);
+        if (entry.section) {
+          const index = entry.section.mesh.getBlockIndex(hit);
+          if (index !== void 0) owner = { chunk: entry.section.chunk, index };
+        }
+        if (!owner || owner.chunk.hiddenBlocks.has(owner.index)) continue;
+        const info = owner.chunk.renderedBlocks.get(owner.index);
+        if (!info) continue;
+        return {
+          position: new Vector3(
+            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: hitNormal(hit),
+          distance: hit.distance
+        };
+      }
+      return void 0;
+    }
     getBlockAt(posOrX, y5, z4) {
       if (typeof posOrX == "number") {
         return this.getBlockAt(new Vector3(posOrX, y5, z4));
@@ -109114,6 +109276,7 @@ gl_FragDepth=readDepth(vUv);
         if (this.fluidCells[index]) this.meshDirty = true;
         this.fluidCells[index] = 0;
         this.renderedBlocks.delete(index);
+        this.objectBlocks.delete(index);
         const worldPos = new Vector3(
           this.x * 16 + index % 16,
           this.y * 16 + Math.floor(index / 256),
@@ -109156,6 +109319,7 @@ gl_FragDepth=readDepth(vUv);
           this.renderedBlocks.set(index, { get block() {
             return readBlock();
           }, object: object4 });
+          if (object4) this.objectBlocks.add(index);
         } catch (error2) {
           this.data.assign(index, 0);
           this.fluidCells[index] = 0;
@@ -109174,6 +109338,7 @@ gl_FragDepth=readDepth(vUv);
       this.fluidCells.fill(0);
       this.waterTints = void 0;
       this.renderedBlocks.clear();
+      this.objectBlocks.clear();
       this.hiddenBlocks.clear();
       this.meshDirty = true;
       this.data.copyFrom(data);
@@ -109223,6 +109388,7 @@ gl_FragDepth=readDepth(vUv);
           this.renderedBlocks.set(index, { get block() {
             return readBlock();
           }, object: void 0 });
+          this.objectBlocks.delete(index);
         } catch (error2) {
           this.data.assign(index, 0);
           this.fluidCells[index] = 0;
@@ -109248,10 +109414,12 @@ gl_FragDepth=readDepth(vUv);
             this.z * 256 + Math.floor(index / 16) % 16 * 16
           ));
           this.renderedBlocks.get(index).object = object4;
+          this.objectBlocks.add(index);
         } catch (error2) {
           this.data.assign(index, 0);
           this.fluidCells[index] = 0;
           this.renderedBlocks.delete(index);
+          this.objectBlocks.delete(index);
           object4?.removeFromScene();
           if (!failed) failure = error2;
           failed = true;
@@ -109512,6 +109680,7 @@ gl_FragDepth=readDepth(vUv);
       this.sectionMesh = void 0;
       this.meshDirty = false;
       this.renderedBlocks.clear();
+      this.objectBlocks.clear();
       this.hiddenBlocks.clear();
       this.fluidCells.fill(0);
       this.waterTints = void 0;
@@ -109553,11 +109722,21 @@ gl_FragDepth=readDepth(vUv);
     }
   };
 
+  // src/world/WorldBlockIntersection.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
   // src/world/WorldChunkSource.ts
   init_dirname();
   init_buffer2();
   init_process2();
 
+  // src/world/WorldEntityIntersection.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
   // src/world/WorldStreamer.ts
   init_dirname();
   init_buffer2();