minecraft-renderer 0.1.79 → 0.1.81

package/src/three/sceneOrigin.ts

@@ -4,20 +4,53 @@ import type { Object3D, Scene, Vector3 } from 'three'
 const IS_TRACKED_PROXY = Symbol('tracked-proxy')
 
 const MUTATING_METHODS = new Set([
-  'add', 'addScalar', 'addScaledVector', 'addVectors',
-  'sub', 'subScalar', 'subVectors',
-  'multiply', 'multiplyScalar', 'multiplyVectors',
-  'divide', 'divideScalar',
-  'applyEuler', 'applyAxisAngle', 'applyMatrix3', 'applyMatrix4', 'applyNormalMatrix', 'applyQuaternion',
-  'negate', 'floor', 'ceil', 'round', 'roundToZero',
-  'min', 'max', 'clamp', 'clampLength', 'clampScalar',
-  'project', 'unproject', 'reflect',
-  'lerp', 'lerpVectors',
-  'cross', 'crossVectors',
-  'setFromMatrixPosition', 'setFromMatrixColumn', 'setFromMatrix3Column',
-  'setFromEuler', 'setFromSpherical', 'setFromSphericalCoords', 'setFromCylindrical',
-  'fromArray', 'fromBufferAttribute',
-  'setComponent', 'randomDirection', 'random',
+  'add',
+  'addScalar',
+  'addScaledVector',
+  'addVectors',
+  'sub',
+  'subScalar',
+  'subVectors',
+  'multiply',
+  'multiplyScalar',
+  'multiplyVectors',
+  'divide',
+  'divideScalar',
+  'applyEuler',
+  'applyAxisAngle',
+  'applyMatrix3',
+  'applyMatrix4',
+  'applyNormalMatrix',
+  'applyQuaternion',
+  'negate',
+  'floor',
+  'ceil',
+  'round',
+  'roundToZero',
+  'min',
+  'max',
+  'clamp',
+  'clampLength',
+  'clampScalar',
+  'project',
+  'unproject',
+  'reflect',
+  'lerp',
+  'lerpVectors',
+  'cross',
+  'crossVectors',
+  'setFromMatrixPosition',
+  'setFromMatrixColumn',
+  'setFromMatrix3Column',
+  'setFromEuler',
+  'setFromSpherical',
+  'setFromSphericalCoords',
+  'setFromCylindrical',
+  'fromArray',
+  'fromBufferAttribute',
+  'setComponent',
+  'randomDirection',
+  'random'
 ])
 
 interface TrackOptions {
@@ -41,9 +74,15 @@ export class SceneOrigin {
     this.scene = scene
   }
 
-  get x(): number { return this._x }
-  get y(): number { return this._y }
-  get z(): number { return this._z }
+  get x(): number {
+    return this._x
+  }
+  get y(): number {
+    return this._y
+  }
+  get z(): number {
+    return this._z
+  }
 
   /** Update origin (called each frame with camera world position) */
   update(worldX: number, worldY: number, worldZ: number): void {
@@ -83,7 +122,9 @@ export class SceneOrigin {
         if (prop === IS_TRACKED_PROXY) return worldData
         if (prop === 'set') {
           return (x: number, y: number, z: number) => {
-            worldData.x = x; worldData.y = y; worldData.z = z
+            worldData.x = x
+            worldData.y = y
+            worldData.z = z
             target.set(x - origin._x, y - origin._y, z - origin._z)
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
@@ -95,7 +136,9 @@ export class SceneOrigin {
             const wx = srcWorld ? srcWorld.x : v.x
             const wy = srcWorld ? srcWorld.y : v.y
             const wz = srcWorld ? srcWorld.z : v.z
-            worldData.x = wx; worldData.y = wy; worldData.z = wz
+            worldData.x = wx
+            worldData.y = wy
+            worldData.z = wz
             target.set(wx - origin._x, wy - origin._y, wz - origin._z)
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
@@ -103,27 +146,32 @@ export class SceneOrigin {
         }
         if (prop === 'setX') {
           return (val: number) => {
-            worldData.x = val; target.x = val - origin._x
+            worldData.x = val
+            target.x = val - origin._x
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
           }
         }
         if (prop === 'setY') {
           return (val: number) => {
-            worldData.y = val; target.y = val - origin._y
+            worldData.y = val
+            target.y = val - origin._y
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
           }
         }
         if (prop === 'setZ') {
           return (val: number) => {
-            worldData.z = val; target.z = val - origin._z
+            worldData.z = val
+            target.z = val - origin._z
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
           }
         }
         if (typeof prop === 'string' && MUTATING_METHODS.has(prop)) {
-          return () => { throw new Error(`Cannot call position.${prop}() on a tracked object. Use position.set(x, y, z) instead.`) }
+          return () => {
+            throw new Error(`Cannot call position.${prop}() on a tracked object. Use position.set(x, y, z) instead.`)
+          }
         }
         const value = (target as any)[prop]
         if (typeof value === 'function') return value.bind(target)
@@ -131,17 +179,20 @@ export class SceneOrigin {
       },
       set(target, prop, value) {
         if (prop === 'x') {
-          worldData.x = value; target.x = value - origin._x
+          worldData.x = value
+          target.x = value - origin._x
           if (opts?.updateMatrix) obj.updateMatrix()
           return true
         }
         if (prop === 'y') {
-          worldData.y = value; target.y = value - origin._y
+          worldData.y = value
+          target.y = value - origin._y
           if (opts?.updateMatrix) obj.updateMatrix()
           return true
         }
         if (prop === 'z') {
-          worldData.z = value; target.z = value - origin._z
+          worldData.z = value
+          target.z = value - origin._z
           if (opts?.updateMatrix) obj.updateMatrix()
           return true
         }
@@ -179,7 +230,7 @@ export class SceneOrigin {
 
   /** Untrack an Object3D and all its descendants, then remove from the scene */
   removeAndUntrackAll(obj: Object3D): void {
-    obj.traverse((child) => {
+    obj.traverse(child => {
       this.untrack(child)
     })
     obj.removeFromParent()
@@ -204,12 +255,24 @@ export class SceneOrigin {
   }
 
   /** Convert world coordinates → scene coordinates */
-  toSceneX(worldX: number): number { return worldX - this._x }
-  toSceneY(worldY: number): number { return worldY - this._y }
-  toSceneZ(worldZ: number): number { return worldZ - this._z }
+  toSceneX(worldX: number): number {
+    return worldX - this._x
+  }
+  toSceneY(worldY: number): number {
+    return worldY - this._y
+  }
+  toSceneZ(worldZ: number): number {
+    return worldZ - this._z
+  }
 
   /** Convert scene coordinates → world coordinates */
-  toWorldX(sceneX: number): number { return sceneX + this._x }
-  toWorldY(sceneY: number): number { return sceneY + this._y }
-  toWorldZ(sceneZ: number): number { return sceneZ + this._z }
+  toWorldX(sceneX: number): number {
+    return sceneX + this._x
+  }
+  toWorldY(sceneY: number): number {
+    return sceneY + this._y
+  }
+  toWorldZ(sceneZ: number): number {
+    return sceneZ + this._z
+  }
 }

package/src/three/sectionRaycastAabb.ts

@@ -25,12 +25,12 @@ export type ShaderSectionRaycastEntry = {
  * Tight world-space AABB covering occupied shader-cube blocks in a section.
  * `sectionCenter*` is geometryData.sx/sy/sz (section base + 8).
  */
-export function computeShaderSectionRaycastAabb (
+export function computeShaderSectionRaycastAabb(
   words: Uint32Array,
   faceCount: number,
   sectionCenterX: number,
   sectionCenterY: number,
-  sectionCenterZ: number,
+  sectionCenterZ: number
 ): ShaderSectionRaycastBox | undefined {
   if (faceCount <= 0) return undefined
 
@@ -77,11 +77,11 @@ export function computeShaderSectionRaycastAabb (
     maxZ,
     cx: (minX + maxX) * 0.5,
     cy: (minY + maxY) * 0.5,
-    cz: (minZ + maxZ) * 0.5,
+    cz: (minZ + maxZ) * 0.5
   }
 }
 
-export function isPointInsideAabb (
+export function isPointInsideAabb(
   ox: number,
   oy: number,
   oz: number,
@@ -90,38 +90,13 @@ export function isPointInsideAabb (
   minZ: number,
   maxX: number,
   maxY: number,
-  maxZ: number,
+  maxZ: number
 ): boolean {
   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 (
+export function raycastAabb(
   ox: number,
   oy: number,
   oz: number,
@@ -134,7 +109,7 @@ export function raycastAabb (
   maxX: number,
   maxY: number,
   maxZ: number,
-  maxDist: number,
+  maxDist: number
 ): number | undefined {
   if (isPointInsideAabb(ox, oy, oz, minX, minY, minZ, maxX, maxY, maxZ)) {
     return undefined
@@ -149,7 +124,11 @@ export function raycastAabb (
     const inv = 1 / dx
     let t1 = (minX - ox) * inv
     let t2 = (maxX - ox) * inv
-    if (t1 > t2) { const tmp = t1; t1 = t2; t2 = tmp }
+    if (t1 > t2) {
+      const tmp = t1
+      t1 = t2
+      t2 = tmp
+    }
     tmin = Math.max(tmin, t1)
     tmax = Math.min(tmax, t2)
     if (tmin > tmax) return undefined
@@ -161,7 +140,11 @@ export function raycastAabb (
     const inv = 1 / dy
     let t1 = (minY - oy) * inv
     let t2 = (maxY - oy) * inv
-    if (t1 > t2) { const tmp = t1; t1 = t2; t2 = tmp }
+    if (t1 > t2) {
+      const tmp = t1
+      t1 = t2
+      t2 = tmp
+    }
     tmin = Math.max(tmin, t1)
     tmax = Math.min(tmax, t2)
     if (tmin > tmax) return undefined
@@ -173,7 +156,11 @@ export function raycastAabb (
     const inv = 1 / dz
     let t1 = (minZ - oz) * inv
     let t2 = (maxZ - oz) * inv
-    if (t1 > t2) { const tmp = t1; t1 = t2; t2 = tmp }
+    if (t1 > t2) {
+      const tmp = t1
+      t1 = t2
+      t2 = tmp
+    }
     tmin = Math.max(tmin, t1)
     tmax = Math.min(tmax, t2)
     if (tmin > tmax) return undefined
@@ -183,7 +170,7 @@ export function raycastAabb (
 }
 
 /** Ray origin inside AABB: distance to exit face along the ray. */
-export function raycastAabbFromInside (
+export function raycastAabbFromInside(
   ox: number,
   oy: number,
   oz: number,
@@ -196,7 +183,7 @@ export function raycastAabbFromInside (
   maxX: number,
   maxY: number,
   maxZ: number,
-  maxDist: number,
+  maxDist: number
 ): number | undefined {
   let tExit = maxDist
 
@@ -217,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)
-}

package/src/three/shaderCubeMesh.ts

@@ -12,10 +12,7 @@ export type ShaderCubeInstanceData = {
  * Build InstancedBufferGeometry for full-cube shader faces.
  * One instance = one visible face; vertex shader uses gl_VertexID (6 verts/face).
  */
-export function buildShaderCubeGeometry(
-  words: Uint32Array,
-  faceCount: number,
-): THREE.InstancedBufferGeometry {
+export function buildShaderCubeGeometry(words: Uint32Array, faceCount: number): THREE.InstancedBufferGeometry {
   const geometry = new THREE.InstancedBufferGeometry()
 
   const positions = new Float32Array(VERTICES_PER_FACE * 3)
@@ -39,14 +36,8 @@ export function buildShaderCubeGeometry(
   geometry.setAttribute('a_w3', new THREE.InstancedBufferAttribute(w3, 1))
 
   geometry.instanceCount = faceCount
-  geometry.boundingBox = new THREE.Box3(
-    new THREE.Vector3(-8, -8, -8),
-    new THREE.Vector3(8, 8, 8),
-  )
-  geometry.boundingSphere = new THREE.Sphere(
-    new THREE.Vector3(0, 0, 0),
-    Math.sqrt(3 * 8 ** 2),
-  )
+  geometry.boundingBox = new THREE.Box3(new THREE.Vector3(-8, -8, -8), new THREE.Vector3(8, 8, 8))
+  geometry.boundingSphere = new THREE.Sphere(new THREE.Vector3(0, 0, 0), Math.sqrt(3 * 8 ** 2))
 
   return geometry
 }
@@ -58,9 +49,7 @@ const _raycastPoint = new THREE.Vector3()
  * CPU raycast uses section AABB (geometry.boundingBox), not GPU-generated faces.
  * Enough for third-person camera collision; block pick uses mineflayer, not mesh raycast.
  */
-export function attachShaderCubeRaycast(
-  mesh: THREE.Mesh<THREE.BufferGeometry, THREE.Material>,
-): void {
+export function attachShaderCubeRaycast(mesh: THREE.Mesh<THREE.BufferGeometry, THREE.Material>): void {
   mesh.raycast = (raycaster, intersects) => {
     const { geometry } = mesh
     if (!geometry.boundingBox) return
@@ -70,14 +59,14 @@ export function attachShaderCubeRaycast(
     intersects.push({
       distance,
       point: _raycastPoint.clone(),
-      object: mesh,
+      object: mesh
     })
   }
 }
 
 export function createShaderCubeMesh(
   data: ShaderCubeInstanceData,
-  material: THREE.ShaderMaterial,
+  material: THREE.ShaderMaterial
 ): THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial> {
   const geometry = buildShaderCubeGeometry(data.words, data.count)
   const mesh = new THREE.Mesh(geometry, material)