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

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;
@@ -107967,6 +107971,13 @@ 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);
+    }
     /** Whether neighboring opaque cubes shade block-face corners. Defaults to false. */
     get ambientOcclusion() {
       return this._ambientOcclusion;
@@ -108653,6 +108664,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 +108679,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 +108712,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 +108743,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 +108908,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 +108956,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 +108982,7 @@ gl_FragDepth=readDepth(vUv);
         mesh.material.dispose();
         texture?.dispose();
       }
+      this.blockIndices.clear();
       this.removeFromParent();
       super.dispose();
     }
@@ -108970,6 +108992,8 @@ gl_FragDepth=readDepth(vUv);
   init_FluidGeometry();
   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) {
@@ -108983,6 +109007,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 +109019,89 @@ 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 = [];
+        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 Matrix4();
+          mesh.getMatrixAt(hit.instanceId, instance);
+          matrix.multiply(instance);
+        }
+        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: hit.face.normal.clone().applyNormalMatrix(new Matrix3().getNormalMatrix(matrix)),
+          distance: hit.distance
+        };
+      }
+      return void 0;
+    }
     getBlockAt(posOrX, y5, z4) {
       if (typeof posOrX == "number") {
         return this.getBlockAt(new Vector3(posOrX, y5, z4));
@@ -109114,6 +109222,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 +109265,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 +109284,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 +109334,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 +109360,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 +109626,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,6 +109668,11 @@ gl_FragDepth=readDepth(vUv);
     }
   };
 
+  // src/world/WorldBlockIntersection.ts
+  init_dirname();
+  init_buffer2();
+  init_process2();
+
   // src/world/WorldChunkSource.ts
   init_dirname();
   init_buffer2();