minecraft-renderer 0.1.58 → 0.1.59

package/package.json

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

package/src/three/chunkMeshManager.ts

@@ -4,14 +4,16 @@ import * as THREE from 'three'
 import * as nbt from 'prismarine-nbt'
 import { Vec3 } from 'vec3'
 import { MesherGeometryOutput } from '../mesher-shared/shared'
-import { getShaderCubeResources } from '../wasm-mesher/bridge/shaderCubeBridge'
+import { getShaderCubeResources, SHADER_CUBES_WORDS_PER_FACE } from '../wasm-mesher/bridge/shaderCubeBridge'
 import { createCubeBlockMaterial } from './shaders/cubeBlockShader'
 import { createShaderCubeMesh, disposeShaderCubeMesh } from './shaderCubeMesh'
 import { GlobalBlockBuffer } from './globalBlockBuffer'
 import {
   computeShaderSectionRaycastAabb,
+  isPointInsideAabb,
   raycastAabb,
-  type ShaderSectionRaycastBox,
+  raycastShaderBlocksAabb,
+  type ShaderSectionRaycastEntry,
 } from './sectionRaycastAabb'
 import { chunkPos } from '../lib/simpleUtils'
 import { renderSign } from '../sign-renderer'
@@ -99,8 +101,11 @@ export class ChunkMeshManager {
   private cubeShaderMaterial: THREE.ShaderMaterial | null = null
   /** One instanced mesh for all shader-cube faces (single draw call). */
   globalBlockBuffer: GlobalBlockBuffer | null = null
-  /** Tight world AABBs for third-person raycast; no per-section Object3D. */
-  private readonly shaderSectionRaycastBoxes = new Map<string, ShaderSectionRaycastBox>()
+  /** Tight world AABBs for third-person raycast; block word0 read from GlobalBlockBuffer or deferred. */
+  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
@@ -256,7 +261,12 @@ export class ChunkMeshManager {
   ): void {
     const box = computeShaderSectionRaycastAabb(words, faceCount, sectionCenterX, sectionCenterY, sectionCenterZ)
     if (box) {
-      this.shaderSectionRaycastBoxes.set(sectionKey, box)
+      this.shaderSectionRaycastBoxes.set(sectionKey, {
+        box,
+        sectionCenterX,
+        sectionCenterY,
+        sectionCenterZ,
+      })
     } else {
       this.shaderSectionRaycastBoxes.delete(sectionKey)
     }
@@ -284,20 +294,63 @@ export class ChunkMeshManager {
     let closest = maxDist
     let found = false
 
-    for (const [key, box] of this.shaderSectionRaycastBoxes) {
+    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
 
-      const t = raycastAabb(
+      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

package/src/three/globalBlockBuffer.ts

@@ -106,6 +106,15 @@ export class GlobalBlockBuffer {
     return this.sectionSlots.has(sectionKey)
   }
 
+  getSectionSlot (sectionKey: string): { start: number, count: number } | undefined {
+    return this.sectionSlots.get(sectionKey)
+  }
+
+  /** Fetch fresh each raycast — growCapacity reallocates the backing array. */
+  getW0 (): Uint32Array {
+    return this.w0
+  }
+
   /** Copy live GPU words and remove the section (sci-fi reveal hide / restore). */
   takeSectionData (sectionKey: string): GlobalBlockBufferShaderData | undefined {
     const slot = this.sectionSlots.get(sectionKey)

package/src/three/sectionRaycastAabb.ts

@@ -14,6 +14,13 @@ export type ShaderSectionRaycastBox = {
   cz: number
 }
 
+export type ShaderSectionRaycastEntry = {
+  box: ShaderSectionRaycastBox
+  sectionCenterX: number
+  sectionCenterY: number
+  sectionCenterZ: number
+}
+
 /**
  * Tight world-space AABB covering occupied shader-cube blocks in a section.
  * `sectionCenter*` is geometryData.sx/sy/sz (section base + 8).
@@ -74,7 +81,7 @@ export function computeShaderSectionRaycastAabb (
   }
 }
 
-function isPointInsideAabb (
+export function isPointInsideAabb (
   ox: number,
   oy: number,
   oz: number,
@@ -150,6 +157,99 @@ export function raycastAabb (
   return tmin <= tmax && tmin >= 0 ? tmin : undefined
 }
 
+/** Ray origin inside AABB: distance to exit face along the ray. */
+export function raycastAabbFromInside (
+  ox: number,
+  oy: number,
+  oz: number,
+  dx: number,
+  dy: number,
+  dz: number,
+  minX: number,
+  minY: number,
+  minZ: number,
+  maxX: number,
+  maxY: number,
+  maxZ: number,
+  maxDist: number,
+): number | undefined {
+  let tExit = maxDist
+
+  if (Math.abs(dx) >= 1e-8) {
+    const t = dx > 0 ? (maxX - ox) / dx : (minX - ox) / dx
+    if (t > 1e-6) tExit = Math.min(tExit, t)
+  } else if (ox < minX || ox > maxX) return undefined
+
+  if (Math.abs(dy) >= 1e-8) {
+    const t = dy > 0 ? (maxY - oy) / dy : (minY - oy) / dy
+    if (t > 1e-6) tExit = Math.min(tExit, t)
+  } else if (oy < minY || oy > maxY) return undefined
+
+  if (Math.abs(dz) >= 1e-8) {
+    const t = dz > 0 ? (maxZ - oz) / dz : (minZ - oz) / dz
+    if (t > 1e-6) tExit = Math.min(tExit, t)
+  } else if (oz < minZ || oz > maxZ) return undefined
+
+  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,

package/src/wasm-mesher/tests/sectionRaycastAabb.test.ts

@@ -3,6 +3,7 @@ import { test, expect } from 'vitest'
 import {
   computeShaderSectionRaycastAabb,
   raycastAabb,
+  raycastShaderBlocksAabb,
   raycastSectionAabb,
 } from '../../three/sectionRaycastAabb'
 import { SHADER_CUBES_WORDS_PER_FACE } from '../bridge/shaderCubeBridge'
@@ -46,6 +47,62 @@ test('raycastAabb: origin inside box is ignored', () => {
   expect(t).toBeUndefined()
 })
 
+test('raycastShaderBlocksAabb: hits wall block when origin is inside section aggregate AABB', () => {
+  const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE * 3)
+  words[0] = 8 | (4 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
+  words[4] = 8 | (5 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
+  words[8] = 8 | (6 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
+  const visitGen = new Uint16Array(4096)
+  const visitStamp = 1
+  const t = raycastShaderBlocksAabb(words, 0, 3, SHADER_CUBES_WORDS_PER_FACE, 8, 8, 8, 4.5, 5.5, 8.5, 1, 0, 0, 10, visitGen, visitStamp)!
+  expect(t).toBeGreaterThan(0)
+  expect(t).toBeLessThan(4)
+})
+
+test('raycastShaderBlocksAabb: ray into empty space does not hit', () => {
+  const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE)
+  words[0] = 8 | (4 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
+  const visitGen = new Uint16Array(4096)
+  const visitStamp = 1
+  const t = raycastShaderBlocksAabb(words, 0, 1, SHADER_CUBES_WORDS_PER_FACE, 8, 8, 8, 4.5, 5.5, 8.5, -1, 0, 0, 10, visitGen, visitStamp)
+  expect(t).toBeUndefined()
+})
+
+test('raycastShaderBlocksAabb: eye inside solid block uses exit distance', () => {
+  const lx = 5
+  const ly = 3
+  const lz = 7
+  const sectionCenterX = 8
+  const sectionCenterY = 8
+  const sectionCenterZ = 8
+  const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE)
+  words[0] = lx | (ly << WORD0.LY_SHIFT) | (lz << WORD0.LZ_SHIFT)
+  const visitGen = new Uint16Array(4096)
+  const visitStamp = 1
+  const ox = sectionCenterX - 8 + lx + 0.5
+  const oy = sectionCenterY - 8 + ly + 0.5
+  const oz = sectionCenterZ - 8 + lz + 0.5
+  const t = raycastShaderBlocksAabb(
+    words, 0, 1, SHADER_CUBES_WORDS_PER_FACE,
+    sectionCenterX, sectionCenterY, sectionCenterZ,
+    ox, oy, oz, 0, 0, 1, 10, visitGen, visitStamp,
+  )!
+  expect(t).toBeGreaterThan(0)
+  expect(t).toBeLessThanOrEqual(10)
+  expect(t).toBeCloseTo(0.5, 5)
+})
+
+test('raycastShaderBlocksAabb: SoA stride-1 layout (GlobalBlockBuffer style)', () => {
+  const w0 = new Uint32Array(2)
+  w0[0] = 8 | (4 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
+  w0[1] = 8 | (5 << WORD0.LY_SHIFT) | (8 << WORD0.LZ_SHIFT)
+  const visitGen = new Uint16Array(4096)
+  const visitStamp = 1
+  const t = raycastShaderBlocksAabb(w0, 0, 2, 1, 8, 8, 8, 4.5, 5.5, 8.5, 1, 0, 0, 10, visitGen, visitStamp)!
+  expect(t).toBeGreaterThan(0)
+  expect(t).toBeLessThan(4)
+})
+
 test('raycastAabb: narrow floor slab blocks downward ray', () => {
   const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE * 2)
   words[0] = 4 | (0 << WORD0.LY_SHIFT) | (4 << WORD0.LZ_SHIFT)