minerender 2.1.0-alpha.121 → 2.1.0-alpha.122

package/dist/node/index.mjs

@@ -12463,6 +12463,10 @@ var BlockObject = class _BlockObject extends SceneObject {
   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;
@@ -17224,7 +17228,7 @@ var AnvilWorldSource = class {
 };
 
 // src/world/Chunk.ts
-import { Color as Color13, Vector3 as Vector318 } from "three";
+import { Color as Color13, Matrix3 as Matrix33, Matrix4 as Matrix413, Vector3 as Vector318 } from "three";
 init_BlockStates();
 init_AssetKey();
 
@@ -17609,6 +17613,13 @@ var MineRenderWorld = class {
     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);
+  }
   /** Whether neighboring opaque cubes shade block-face corners. Defaults to false. */
   get ambientOcclusion() {
     return this._ambientOcclusion;
@@ -18283,6 +18294,7 @@ function buildSectionGeometry(input) {
     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 vertex = 0, indexOffset = 0;
     for (const entry of page.entries) {
       const template = templateData[templates[entry]];
@@ -18297,6 +18309,7 @@ function buildSectionGeometry(input) {
       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 = vertex;
@@ -18329,6 +18342,7 @@ function buildSectionGeometry(input) {
       const mapV = (v) => 1 - (placement.y + (1 - v) * atlas.height) / page.height;
       const lightIndex = (y + 1) * 324 + (z + 1) * 18 + x + 1;
       for (let quad = 0; quad < quads.sprites.length; quad++) {
+        blockIndices[indexOffset / 6] = x + z * 16 + y * 256;
         const rect = quads.sprites[quad] === 0 ? data.still : data.flow;
         const brightness = light ? lightBrightness(fluidLightLevel(
           light[lightIndex],
@@ -18359,11 +18373,11 @@ function buildSectionGeometry(input) {
         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
@@ -18522,6 +18536,12 @@ var SectionMesh = class _SectionMesh extends Group3 {
   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) {
@@ -18564,6 +18584,7 @@ var SectionMesh = class _SectionMesh extends Group3 {
       const texture = material.uniforms?.map?.value ?? material.map;
       const mesh = new Mesh10(geometry, material);
       section.add(mesh);
+      section.blockIndices.set(mesh, page.blockIndices);
       const unsubscribe = [];
       for (const { atlas: id, x, y } of page.placements) {
         const atlas = atlases[id];
@@ -18589,6 +18610,7 @@ var SectionMesh = class _SectionMesh extends Group3 {
       mesh.material.dispose();
       texture?.dispose();
     }
+    this.blockIndices.clear();
     this.removeFromParent();
     super.dispose();
   }
@@ -18598,6 +18620,8 @@ var SectionMesh = class _SectionMesh extends Group3 {
 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) {
@@ -18611,6 +18635,7 @@ var Chunk = class _Chunk {
     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);
@@ -18622,6 +18647,89 @@ var Chunk = class _Chunk {
     this.y = y;
     this.z = z;
   }
+  /** 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 = [];
+      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) => {
+      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 raycaster.intersectObjects([...targets.keys()], false)) {
+      if (!hit.face) continue;
+      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) {
+        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;
+      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(
+          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)),
+        distance: hit.distance
+      };
+    }
+    return void 0;
+  }
   getBlockAt(posOrX, y, z) {
     if (typeof posOrX == "number") {
       return this.getBlockAt(new Vector318(posOrX, y, z));
@@ -18742,6 +18850,7 @@ var Chunk = class _Chunk {
       if (this.fluidCells[index]) this.meshDirty = true;
       this.fluidCells[index] = 0;
       this.renderedBlocks.delete(index);
+      this.objectBlocks.delete(index);
       const worldPos = new Vector318(
         this.x * 16 + index % 16,
         this.y * 16 + Math.floor(index / 256),
@@ -18784,6 +18893,7 @@ var Chunk = class _Chunk {
         this.renderedBlocks.set(index, { get block() {
           return readBlock();
         }, object: object4 });
+        if (object4) this.objectBlocks.add(index);
       } catch (error) {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
@@ -18802,6 +18912,7 @@ var Chunk = class _Chunk {
     this.fluidCells.fill(0);
     this.waterTints = void 0;
     this.renderedBlocks.clear();
+    this.objectBlocks.clear();
     this.hiddenBlocks.clear();
     this.meshDirty = true;
     this.data.copyFrom(data);
@@ -18851,6 +18962,7 @@ var Chunk = class _Chunk {
         this.renderedBlocks.set(index, { get block() {
           return readBlock();
         }, object: void 0 });
+        this.objectBlocks.delete(index);
       } catch (error) {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
@@ -18876,10 +18988,12 @@ var Chunk = class _Chunk {
           this.z * 256 + Math.floor(index / 16) % 16 * 16
         ));
         this.renderedBlocks.get(index).object = object4;
+        this.objectBlocks.add(index);
       } catch (error) {
         this.data.assign(index, 0);
         this.fluidCells[index] = 0;
         this.renderedBlocks.delete(index);
+        this.objectBlocks.delete(index);
         object4?.removeFromScene();
         if (!failed) failure = error;
         failed = true;
@@ -19140,6 +19254,7 @@ var Chunk = class _Chunk {
     this.sectionMesh = void 0;
     this.meshDirty = false;
     this.renderedBlocks.clear();
+    this.objectBlocks.clear();
     this.hiddenBlocks.clear();
     this.fluidCells.fill(0);
     this.waterTints = void 0;