minecraft-renderer 0.1.80 → 0.1.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.80",
+  "version": "0.1.81",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/lib/worldrendererCommon.ts

@@ -32,6 +32,7 @@ import { generateSpiralMatrix } from './spiral'
 import { PlayerStateReactive } from '../playerState/playerState'
 import { IndexedData } from 'minecraft-data'
 import { WorldRendererConfig } from '../graphicsBackend/config'
+import { CameraCollisionBlockCache } from '../three/cameraCollisionBlockCache'
 
 function mod(x, n) {
   return ((x % n) + n) % n
@@ -43,6 +44,8 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   timeOfTheDay = 0
   lastMesherSkyLight = 15
   worldSizeParams = { minY: 0, worldHeight: 256 }
+  /** Block columns for third-person voxel DDA (renderer thread). */
+  cameraCollisionBlockCache: CameraCollisionBlockCache
   reactiveDebugParams = proxy({
     stopRendering: false,
     chunksRenderAboveOverride: undefined as number | undefined,
@@ -216,6 +219,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     public displayOptions: DisplayWorldOptions,
     public initOptions: GraphicsInitOptions
   ) {
+    this.cameraCollisionBlockCache = new CameraCollisionBlockCache(this.displayOptions.version)
     this.snapshotInitialValues()
     this.worldRendererConfig = displayOptions.inWorldRenderingConfig
     this.playerStateReactive = displayOptions.playerStateReactive!
@@ -892,6 +896,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
         `-> chunk ${JSON.stringify({ x, z, chunkLength: chunk.length, customBlockModelsLength: customBlockModels ? Object.keys(customBlockModels).length : 0 })}`
     )
     this.mesherLogReader?.chunkReceived(x, z, chunk.length)
+    this.cameraCollisionBlockCache.ingestColumn(x, z, chunk)
     const sectionHeight = this.getSectionHeight()
     const CHUNK_SIZE = 16
 
@@ -960,6 +965,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       delete this.finishedSections[sectionKey]
     }
     this.highestBlocksByChunks.delete(`${x},${z}`)
+    this.cameraCollisionBlockCache.removeColumn(x, z)
     const heightmapKey = `${Math.floor(x / 16)},${Math.floor(z / 16)}`
     delete this.reactiveState.world.heightmaps[heightmapKey]
 
@@ -1036,6 +1042,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       'loadChunk',
       ({ x, z, chunk, worldConfig, isLightUpdate }) => {
         this.worldSizeParams = worldConfig
+        this.cameraCollisionBlockCache.setWorldBounds(worldConfig.minY, worldConfig.worldHeight)
         this.queuedChunks.add(`${x},${z}`)
         const args = [x, z, chunk, isLightUpdate]
         if (!currentLoadChunkBatch) {
@@ -1139,6 +1146,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       worldEmitter,
       'onWorldSwitch',
       () => {
+        this.cameraCollisionBlockCache.clear()
         for (const fn of this.onWorldSwitched) {
           try {
             fn()
@@ -1229,6 +1237,9 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       }
     }
     this.logWorkerWork(`-> blockUpdate ${JSON.stringify({ pos, stateId, customBlockModels })}`)
+    if (stateId !== undefined) {
+      this.cameraCollisionBlockCache.setBlockStateId(pos.x, pos.y, pos.z, stateId)
+    }
     this.setSectionDirty(pos, true, true)
     if (this.neighborChunkUpdates) {
       const CHUNK_SIZE = 16

package/src/three/cameraCollisionBlockCache.ts

@@ -0,0 +1,156 @@
+//@ts-nocheck
+import Chunks from 'prismarine-chunk'
+import { Vec3 } from 'vec3'
+import { getCameraCollisionSolidityTable, isStateIdSolidForCameraCollision } from './cameraCollisionSolidity'
+
+/** 16³ blocks per section; 1 bit per block. */
+const WORDS_PER_SECTION = 128
+export const CAMERA_COLLISION_BYTES_PER_SECTION = WORDS_PER_SECTION * 4
+
+type SectionBitset = Uint32Array
+
+const sectionKey = (sx: number, sy: number, sz: number) => `${sx},${sy},${sz}`
+
+const alignSection = (coord: number) => Math.floor(coord / 16) * 16
+
+const localCoord = (coord: number) => ((coord % 16) + 16) % 16
+
+const blockBitIndex = (lx: number, ly: number, lz: number) => lx + lz * 16 + ly * 256
+
+const getBit = (bits: SectionBitset, idx: number) => {
+  const word = idx >>> 5
+  return (bits[word]! & (1 << (idx & 31))) !== 0
+}
+
+const setBit = (bits: SectionBitset, idx: number, value: boolean) => {
+  const word = idx >>> 5
+  const mask = 1 << (idx & 31)
+  if (value) bits[word]! |= mask
+  else bits[word]! &= ~mask
+}
+
+const isBitsetEmpty = (bits: SectionBitset) => {
+  for (let i = 0; i < WORDS_PER_SECTION; i++) {
+    if (bits[i]!) return false
+  }
+  return true
+}
+
+/**
+ * Sparse 1-bit-per-block solidity cache for third-person voxel DDA.
+ * Allocates a 512-byte section bitset only when it contains ≥1 solid block.
+ */
+export class CameraCollisionBlockCache {
+  private readonly sections = new Map<string, SectionBitset>()
+  private Chunk: ReturnType<typeof Chunks>
+  private solidityTable: Uint8Array
+  private worldMinY = 0
+  private worldMaxY = 256
+
+  constructor(version: string) {
+    this.Chunk = Chunks(version) as ReturnType<typeof Chunks>
+    this.solidityTable = getCameraCollisionSolidityTable(version)
+  }
+
+  setVersion(version: string) {
+    this.Chunk = Chunks(version) as ReturnType<typeof Chunks>
+    this.solidityTable = getCameraCollisionSolidityTable(version)
+    this.sections.clear()
+  }
+
+  setWorldBounds(minY: number, worldHeight: number) {
+    if (this.worldMinY === minY && this.worldMaxY === worldHeight) return
+    this.worldMinY = minY
+    this.worldMaxY = worldHeight
+    this.sections.clear()
+  }
+
+  clear() {
+    this.sections.clear()
+  }
+
+  /** Allocated 16³ section bitsets (512 bytes each). */
+  getAllocatedSectionCount(): number {
+    return this.sections.size
+  }
+
+  getAllocatedBytes(): number {
+    return this.sections.size * CAMERA_COLLISION_BYTES_PER_SECTION
+  }
+
+  removeColumn(chunkX: number, chunkZ: number) {
+    const syStart = alignSection(this.worldMinY)
+    for (let sy = syStart; sy < this.worldMaxY; sy += 16) {
+      this.sections.delete(sectionKey(chunkX, sy, chunkZ))
+    }
+  }
+
+  ingestColumn(chunkX: number, chunkZ: number, chunkJson: unknown) {
+    const chunk = this.Chunk.fromJson(chunkJson as Parameters<ReturnType<typeof Chunks>['fromJson']>[0]) as unknown as {
+      getBlockStateId: (pos: Vec3) => number
+    }
+    const pos = new Vec3(0, 0, 0)
+
+    for (let y = this.worldMinY; y < this.worldMaxY; y++) {
+      pos.y = y
+      const sy = alignSection(y)
+      const ly = y - sy
+      for (let lz = 0; lz < 16; lz++) {
+        pos.z = lz
+        const wz = chunkZ + lz
+        const sz = alignSection(wz)
+        const lzLocal = wz - sz
+        for (let lx = 0; lx < 16; lx++) {
+          pos.x = lx
+          const stateId = chunk.getBlockStateId(pos) || 0
+          if (!isStateIdSolidForCameraCollision(stateId, this.solidityTable)) continue
+
+          const wx = chunkX + lx
+          const sx = alignSection(wx)
+          const key = sectionKey(sx, sy, sz)
+          let bits = this.sections.get(key)
+          if (!bits) {
+            bits = new Uint32Array(WORDS_PER_SECTION)
+            this.sections.set(key, bits)
+          }
+          setBit(bits, blockBitIndex(wx - sx, ly, lzLocal), true)
+        }
+      }
+    }
+  }
+
+  setBlockStateId(x: number, y: number, z: number, stateId: number) {
+    if (y < this.worldMinY || y >= this.worldMaxY) return
+
+    const sx = alignSection(x)
+    const sy = alignSection(y)
+    const sz = alignSection(z)
+    const key = sectionKey(sx, sy, sz)
+    const idx = blockBitIndex(localCoord(x), y - sy, localCoord(z))
+    const solid = isStateIdSolidForCameraCollision(stateId, this.solidityTable)
+
+    if (solid) {
+      let bits = this.sections.get(key)
+      if (!bits) {
+        bits = new Uint32Array(WORDS_PER_SECTION)
+        this.sections.set(key, bits)
+      }
+      setBit(bits, idx, true)
+      return
+    }
+
+    const bits = this.sections.get(key)
+    if (!bits) return
+    setBit(bits, idx, false)
+    if (isBitsetEmpty(bits)) this.sections.delete(key)
+  }
+
+  isSolidBlock(x: number, y: number, z: number): boolean {
+    if (y < this.worldMinY || y >= this.worldMaxY) return false
+
+    const bits = this.sections.get(sectionKey(alignSection(x), alignSection(y), alignSection(z)))
+    if (!bits) return false
+
+    return getBit(bits, blockBitIndex(localCoord(x), y - alignSection(y), localCoord(z)))
+  }
+}

package/src/three/cameraCollisionSolidity.ts

@@ -0,0 +1,50 @@
+//@ts-nocheck
+import MinecraftData from 'minecraft-data'
+import PrismarineBlockLoader from 'prismarine-block'
+import moreBlockDataGeneratedJson from '../lib/moreBlockDataGenerated.json'
+
+const solidityCache = new Map<string, Uint8Array>()
+
+const PASS_THROUGH_NAMES = new Set(['water', 'flowing_water', 'lava', 'flowing_lava', 'grass', 'short_grass', 'tall_grass'])
+
+/** 1 = blocks third-person camera DDA; 0 = pass-through (air, plants, fluids). */
+export function getCameraCollisionSolidityTable(version: string): Uint8Array {
+  const cached = solidityCache.get(version)
+  if (cached) return cached
+
+  const mcData = MinecraftData(version)
+  const Block = PrismarineBlockLoader(version)
+  const noOcclusionsSet = new Set(Object.keys(moreBlockDataGeneratedJson.noOcclusions))
+  const invisibleNames = new Set(mcData.blocksArray.filter(b => moreBlockDataGeneratedJson.invisibleBlocks[b.name]).map(b => b.name))
+
+  let maxStateId = 0
+  for (const idStr of Object.keys((mcData as { blocksByStateId: Record<string, unknown> }).blocksByStateId)) {
+    maxStateId = Math.max(maxStateId, Number(idStr))
+  }
+
+  const table = new Uint8Array(maxStateId + 1)
+  for (const idStr of Object.keys((mcData as { blocksByStateId: Record<string, unknown> }).blocksByStateId)) {
+    const stateId = Number(idStr)
+    if (!stateId) continue
+
+    const block = (
+      Block as { fromStateId: (id: number, y: number) => { name: string; transparent: boolean; boundingBox: string; shapes?: number[][] } | null }
+    ).fromStateId(stateId, 0)
+    if (!block) continue
+    if (invisibleNames.has(block.name)) continue
+    if (noOcclusionsSet.has(block.name)) continue
+    if (PASS_THROUGH_NAMES.has(block.name)) continue
+    if (block.boundingBox === 'empty') continue
+    if (block.transparent && block.boundingBox !== 'block') continue
+    if (!block.shapes || block.shapes.length === 0) continue
+
+    table[stateId] = 1
+  }
+
+  solidityCache.set(version, table)
+  return table
+}
+
+export function isStateIdSolidForCameraCollision(stateId: number, solidityTable: Uint8Array): boolean {
+  return stateId > 0 && stateId < solidityTable.length && solidityTable[stateId] === 1
+}

package/src/three/chunkMeshManager.ts

@@ -3,7 +3,7 @@ import * as THREE from 'three'
 import * as nbt from 'prismarine-nbt'
 import { Vec3 } from 'vec3'
 import { MesherGeometryOutput } from '../mesher-shared/shared'
-import { getShaderCubeResources, SHADER_CUBES_WORDS_PER_FACE } from '../wasm-mesher/bridge/shaderCubeBridge'
+import { getShaderCubeResources } from '../wasm-mesher/bridge/shaderCubeBridge'
 import {
   createCubeBlockMaterial,
   computeSectionOriginRel,
@@ -22,19 +22,12 @@ import {
   setLegacyLightmapParams,
   type RenderOrigin
 } from './shaders/legacyBlockShader'
-import { LEGACY_SECTION_HALF_EXTENT, sectionIntersectsFrustum, setupLegacySectionMatrix, updateLegacySectionCullState } from './legacySectionCull'
+import { sectionIntersectsFrustum, setupLegacySectionMatrix, updateLegacySectionCullState } from './legacySectionCull'
 import { createShaderCubeMesh, disposeShaderCubeMesh } from './shaderCubeMesh'
 import { GlobalBlockBuffer } from './globalBlockBuffer'
 import { buildVisibleCubeSpans } from './cubeDrawSpans'
 import { GlobalLegacyBuffer, type LegacySectionGeometry } from './globalLegacyBuffer'
-import {
-  computeShaderSectionRaycastAabb,
-  isPointInsideAabb,
-  raycastAabb,
-  raycastShaderBlocksAabb,
-  sectionAabbIntersectsRay,
-  type ShaderSectionRaycastEntry
-} from './sectionRaycastAabb'
+import { computeShaderSectionRaycastAabb, type ShaderSectionRaycastEntry } from './sectionRaycastAabb'
 import { getMesh } from './entity/EntityMesh'
 import type { WorldRendererThree } from './worldRendererThree'
 import { armorModel } from './entity/armorModels'
@@ -170,11 +163,8 @@ export class ChunkMeshManager {
   globalBlockBuffer: GlobalBlockBuffer | null = null
   globalLegacyBuffer: GlobalLegacyBuffer | null = null
   globalLegacyBlendBuffer: GlobalLegacyBuffer | null = null
-  /** Tight world AABBs for third-person raycast; block word0 read from GlobalBlockBuffer or deferred. */
+  /** Tight world AABBs for shader-cube frustum culling (section centers). */
   private readonly shaderSectionRaycastBoxes = new Map<string, ShaderSectionRaycastEntry>()
-  /** Per-raycast block dedup; safe while the eye is inside at most one section aggregate AABB per call. */
-  private readonly blockRaycastVisitGen = new Uint16Array(4096)
-  private blockRaycastVisitStamp = 1
 
   // Performance tracking
   private hits = 0
@@ -738,35 +728,6 @@ export class ChunkMeshManager {
     this.markCullDirty()
   }
 
-  raycastGlobalLegacySections(raycaster: THREE.Raycaster, origin: THREE.Vector3, maxCenterDistance: number): number | undefined {
-    const maxDistSq = maxCenterDistance * maxCenterDistance
-    const dirX = raycaster.ray.direction.x
-    const dirY = raycaster.ray.direction.y
-    const dirZ = raycaster.ray.direction.z
-    const far = raycaster.far
-    const halfExtent = LEGACY_SECTION_HALF_EXTENT + 0.01
-    const candidates: string[] = []
-    for (const [key] of this.legacyCullSections) {
-      const section = this.sectionObjects[key]
-      if (!section || section.worldX === undefined) continue
-      const dx = section.worldX - origin.x
-      const dy = (section.worldY ?? 0) - origin.y
-      const dz = (section.worldZ ?? 0) - origin.z
-      if (dx * dx + dy * dy + dz * dz > maxDistSq) continue
-      if (!sectionAabbIntersectsRay(section.worldX, section.worldY ?? 0, section.worldZ ?? 0, origin.x, origin.y, origin.z, dirX, dirY, dirZ, far, halfExtent))
-        continue
-      candidates.push(key)
-    }
-
-    if (candidates.length === 0) return undefined
-
-    const hits: THREE.Intersection[] = []
-    this.globalLegacyBuffer?.raycastSections(raycaster, candidates, hits)
-    this.globalLegacyBlendBuffer?.raycastSections(raycaster, candidates, hits)
-
-    return hits[0]?.distance
-  }
-
   registerShaderSectionRaycastBox(
     sectionKey: string,
     words: Uint32Array,
@@ -792,91 +753,6 @@ export class ChunkMeshManager {
     this.shaderSectionRaycastBoxes.delete(sectionKey)
   }
 
-  /** Closest hit against registered shader-cube AABBs (world-space ray). */
-  raycastShaderSectionAABBs(originWorld: THREE.Vector3, direction: THREE.Vector3, maxDist: number, maxCenterDistance = 80): number | undefined {
-    const ox = originWorld.x
-    const oy = originWorld.y
-    const oz = originWorld.z
-    const dx = direction.x
-    const dy = direction.y
-    const dz = direction.z
-    const maxCenterDistSq = maxCenterDistance * maxCenterDistance
-
-    let closest = maxDist
-    let found = false
-
-    this.blockRaycastVisitStamp++
-    if (this.blockRaycastVisitStamp >= 65535) {
-      this.blockRaycastVisitGen.fill(0)
-      this.blockRaycastVisitStamp = 1
-    }
-
-    for (const [key, entry] of this.shaderSectionRaycastBoxes) {
-      const section = this.sectionObjects[key]
-      if (section && !section.visible) continue
-
-      const { box } = entry
-      const dcx = box.cx - ox
-      const dcy = box.cy - oy
-      const dcz = box.cz - oz
-      if (dcx * dcx + dcy * dcy + dcz * dcz > maxCenterDistSq) continue
-
-      let t = raycastAabb(ox, oy, oz, dx, dy, dz, box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ, closest)
-      if (t === undefined && isPointInsideAabb(ox, oy, oz, box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ)) {
-        const gb = this.globalBlockBuffer
-        const slot = gb?.getSectionSlot(key)
-        if (gb && slot) {
-          t = raycastShaderBlocksAabb(
-            gb.getW0(),
-            slot.start,
-            slot.count,
-            1,
-            entry.sectionCenterX,
-            entry.sectionCenterY,
-            entry.sectionCenterZ,
-            ox,
-            oy,
-            oz,
-            dx,
-            dy,
-            dz,
-            closest,
-            this.blockRaycastVisitGen,
-            this.blockRaycastVisitStamp
-          )
-        } else {
-          const def = this.sectionObjects[key]?.deferredShaderCubes
-          if (def) {
-            t = raycastShaderBlocksAabb(
-              def.words,
-              0,
-              def.count,
-              SHADER_CUBES_WORDS_PER_FACE,
-              entry.sectionCenterX,
-              entry.sectionCenterY,
-              entry.sectionCenterZ,
-              ox,
-              oy,
-              oz,
-              dx,
-              dy,
-              dz,
-              closest,
-              this.blockRaycastVisitGen,
-              this.blockRaycastVisitStamp
-            )
-          }
-        }
-      }
-      if (t !== undefined && t < closest) {
-        closest = t
-        found = true
-      }
-    }
-
-    return found ? closest : undefined
-  }
-
   /**
    * Update or create a section with new geometry data
    */

package/src/three/globalLegacyBuffer.ts

@@ -644,46 +644,6 @@ export class GlobalLegacyBuffer {
     if (uf?.value?.set) uf.value.set(cameraOriginFrac.x, cameraOriginFrac.y, cameraOriginFrac.z)
   }
 
-  raycastSections(raycaster: THREE.Raycaster, sectionKeys: Iterable<string>, out: THREE.Intersection[]): THREE.Intersection[] {
-    const ray = raycaster.ray
-    const closest = raycaster.near
-    const far = raycaster.far
-    _raycastOrigin.copy(ray.origin).sub(_raycastRenderOrigin.set(this.renderOrigin.x, this.renderOrigin.y, this.renderOrigin.z))
-    _raycastRay.origin.copy(_raycastOrigin)
-    _raycastRay.direction.copy(ray.direction)
-
-    for (const key of sectionKeys) {
-      const slot = this.sectionSlots.get(key)
-      if (!slot) continue
-
-      const dstVertBase = slot.start * VERTS_PER_QUAD
-      const dstFloatBase = dstVertBase * FLOATS_PER_VERT
-      const dstIndexBase = slot.start * INDICES_PER_QUAD
-      const indexLen = slot.count * INDICES_PER_QUAD
-
-      for (let i = 0; i < indexLen; i += 3) {
-        const i0 = this.indices[dstIndexBase + i]!
-        const i1 = this.indices[dstIndexBase + i + 1]!
-        const i2 = this.indices[dstIndexBase + i + 2]!
-        if (i0 === i1 && i1 === i2) continue
-
-        const hit = intersectTriangle(_raycastRay, this.positions, this.aOrigin, dstFloatBase, i0, i1, i2, closest, far)
-        if (hit !== null) {
-          out.push({
-            distance: hit,
-            point: ray.at(hit, new THREE.Vector3()),
-            object: this.mesh,
-            face: null,
-            faceIndex: Math.floor(i / 3)
-          })
-        }
-      }
-    }
-
-    out.sort((a, b) => a.distance - b.distance)
-    return out
-  }
-
   getHighWatermark(): number {
     return this.highWatermark
   }
@@ -980,70 +940,3 @@ export class GlobalLegacyBuffer {
     this.pendingRanges.length = 0
   }
 }
-
-const _vA = new THREE.Vector3()
-const _vB = new THREE.Vector3()
-const _vC = new THREE.Vector3()
-const _edge1 = new THREE.Vector3()
-const _edge2 = new THREE.Vector3()
-const _normal = new THREE.Vector3()
-const _raycastOrigin = new THREE.Vector3()
-const _raycastRenderOrigin = new THREE.Vector3()
-const _raycastRay = new THREE.Ray()
-
-function readWorldVertex(positions: Float32Array, aOrigin: Float32Array, floatBase: number, vertIndex: number, target: THREE.Vector3): void {
-  const f = floatBase + vertIndex * FLOATS_PER_VERT
-  target.set(aOrigin[f]! + positions[f]!, aOrigin[f + 1]! + positions[f + 1]!, aOrigin[f + 2]! + positions[f + 2]!)
-}
-
-function intersectTriangle(
-  ray: THREE.Ray,
-  positions: Float32Array,
-  aOrigin: Float32Array,
-  floatBase: number,
-  i0: number,
-  i1: number,
-  i2: number,
-  near: number,
-  far: number
-): number | null {
-  readWorldVertex(positions, aOrigin, floatBase, i0, _vA)
-  readWorldVertex(positions, aOrigin, floatBase, i1, _vB)
-  readWorldVertex(positions, aOrigin, floatBase, i2, _vC)
-
-  _edge1.subVectors(_vB, _vA)
-  _edge2.subVectors(_vC, _vA)
-  _normal.crossVectors(_edge1, _edge2)
-
-  const denom = _normal.dot(ray.direction)
-  if (Math.abs(denom) < 1e-8) return null
-
-  const t = _vA.clone().sub(ray.origin).dot(_normal) / denom
-  if (t < near || t > far) return null
-
-  const p = ray.at(t, new THREE.Vector3())
-  if (!pointInTriangle(p, _vA, _vB, _vC)) return null
-  return t
-}
-
-function pointInTriangle(p: THREE.Vector3, a: THREE.Vector3, b: THREE.Vector3, c: THREE.Vector3): boolean {
-  _edge1.subVectors(b, a)
-  _edge2.subVectors(c, a)
-  const n = _normal.crossVectors(_edge1, _edge2).normalize()
-
-  const ab = _edge1
-  const ac = _edge2
-  const ap = p.clone().sub(a)
-
-  const d00 = ab.dot(ab)
-  const d01 = ab.dot(ac)
-  const d11 = ac.dot(ac)
-  const d20 = ap.dot(ab)
-  const d21 = ap.dot(ac)
-  const denom = d00 * d11 - d01 * d01
-  if (Math.abs(denom) < 1e-12) return false
-  const v = (d11 * d20 - d01 * d21) / denom
-  const w = (d00 * d21 - d01 * d20) / denom
-  const u = 1 - v - w
-  return u >= -1e-4 && v >= -1e-4 && w >= -1e-4
-}

package/src/three/sectionRaycastAabb.ts

@@ -95,31 +95,6 @@ export function isPointInsideAabb(
   return ox >= minX && ox <= maxX && oy >= minY && oy <= maxY && oz >= minZ && oz <= maxZ
 }
 
-/** True if a `far`-bounded ray from (ox,oy,oz) dir (dx,dy,dz) crosses or starts inside
- *  the cube-section AABB centered at (cx,cy,cz) with the given half-extent. */
-export function sectionAabbIntersectsRay(
-  cx: number,
-  cy: number,
-  cz: number,
-  ox: number,
-  oy: number,
-  oz: number,
-  dx: number,
-  dy: number,
-  dz: number,
-  far: number,
-  halfExtent: number
-): boolean {
-  const minX = cx - halfExtent
-  const minY = cy - halfExtent
-  const minZ = cz - halfExtent
-  const maxX = cx + halfExtent
-  const maxY = cy + halfExtent
-  const maxZ = cz + halfExtent
-  if (isPointInsideAabb(ox, oy, oz, minX, minY, minZ, maxX, maxY, maxZ)) return true
-  return raycastAabb(ox, oy, oz, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, far) !== undefined
-}
-
 /** Ray–AABB entry distance, or undefined. Ignores hits when origin is inside the box. */
 export function raycastAabb(
   ox: number,
@@ -229,76 +204,3 @@ export function raycastAabbFromInside(
 
   return tExit <= maxDist ? tExit : undefined
 }
-
-/** Per-block raycast; `word0Stride` 1 = GlobalBlockBuffer SoA, 4 = deferred AoS. */
-export function raycastShaderBlocksAabb(
-  w0Source: Uint32Array,
-  start: number,
-  faceCount: number,
-  word0Stride: number,
-  sectionCenterX: number,
-  sectionCenterY: number,
-  sectionCenterZ: number,
-  ox: number,
-  oy: number,
-  oz: number,
-  dx: number,
-  dy: number,
-  dz: number,
-  maxDist: number,
-  visitGen: Uint16Array,
-  visitStamp: number
-): number | undefined {
-  const baseX = sectionCenterX - 8
-  const baseY = sectionCenterY - 8
-  const baseZ = sectionCenterZ - 8
-
-  let closest = maxDist
-  let found = false
-
-  for (let i = 0; i < faceCount; i++) {
-    const w0 = w0Source[start + i * word0Stride]!
-    const lx = w0 & ((1 << WORD0.LX_BITS) - 1)
-    const ly = (w0 >> WORD0.LY_SHIFT) & ((1 << WORD0.LY_BITS) - 1)
-    const lz = (w0 >> WORD0.LZ_SHIFT) & ((1 << WORD0.LZ_BITS) - 1)
-    const visitIdx = lx + (ly << 4) + (lz << 8)
-    if (visitGen[visitIdx] === visitStamp) continue
-    visitGen[visitIdx] = visitStamp
-
-    const minX = baseX + lx
-    const minY = baseY + ly
-    const minZ = baseZ + lz
-    const maxX = minX + 1
-    const maxY = minY + 1
-    const maxZ = minZ + 1
-
-    let t: number | undefined
-    if (isPointInsideAabb(ox, oy, oz, minX, minY, minZ, maxX, maxY, maxZ)) {
-      t = raycastAabbFromInside(ox, oy, oz, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, closest)
-    } else {
-      t = raycastAabb(ox, oy, oz, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, closest)
-    }
-    if (t !== undefined && t < closest) {
-      closest = t
-      found = true
-    }
-  }
-
-  return found ? closest : undefined
-}
-
-/** 16³ section box centered at (cx, cy, cz) — tests / legacy helper. */
-export function raycastSectionAabb(
-  ox: number,
-  oy: number,
-  oz: number,
-  dx: number,
-  dy: number,
-  dz: number,
-  cx: number,
-  cy: number,
-  cz: number,
-  maxDist: number
-): number | undefined {
-  return raycastAabb(ox, oy, oz, dx, dy, dz, cx - 8, cy - 8, cz - 8, cx + 8, cy + 8, cz + 8, maxDist)
-}