minecraft-renderer 0.1.79 → 0.1.81

package/src/three/tests/legacyMultiDraw.test.ts

@@ -1,12 +1,8 @@
 //@ts-nocheck
 import { expect, test, vi } from 'vitest'
-import {
-  createLegacyMultiDrawScratch,
-  detectLegacyMultiDrawCaps,
-  drawLegacySpans,
-} from '../legacyMultiDraw'
+import { createLegacyMultiDrawScratch, detectLegacyMultiDrawCaps, drawLegacySpans } from '../legacyMultiDraw'
 
-function makeMockGl (opts?: { multiDraw?: boolean }): WebGL2RenderingContext {
+function makeMockGl(opts?: { multiDraw?: boolean }): WebGL2RenderingContext {
   const multiDrawElementsWEBGL = vi.fn()
   const drawElements = vi.fn()
   return {
@@ -18,7 +14,7 @@ function makeMockGl (opts?: { multiDraw?: boolean }): WebGL2RenderingContext {
       }
       return null
     },
-    drawElements,
+    drawElements
   } as unknown as WebGL2RenderingContext
 }
 
@@ -42,7 +38,7 @@ test('drawLegacySpans: tier A uses multiDrawElementsWEBGL with byte offsets', ()
   const scratch = createLegacyMultiDrawScratch()
   const spans = [
     { indexStart: 12, indexCount: 6 },
-    { indexStart: 30, indexCount: 12 },
+    { indexStart: 30, indexCount: 12 }
   ]
 
   drawLegacySpans(gl, caps, spans, scratch)
@@ -54,13 +50,7 @@ test('drawLegacySpans: tier A uses multiDrawElementsWEBGL with byte offsets', ()
 
   const ext = caps.ext as { multiDrawElementsWEBGL: ReturnType<typeof vi.fn> }
   expect(ext.multiDrawElementsWEBGL).toHaveBeenCalledTimes(1)
-  expect(ext.multiDrawElementsWEBGL).toHaveBeenCalledWith(
-    gl.TRIANGLES,
-    scratch.counts, 0,
-    gl.UNSIGNED_INT,
-    scratch.offsets, 0,
-    2,
-  )
+  expect(ext.multiDrawElementsWEBGL).toHaveBeenCalledWith(gl.TRIANGLES, scratch.counts, 0, gl.UNSIGNED_INT, scratch.offsets, 0, 2)
 })
 
 test('drawLegacySpans: tier B loops drawElements per span', () => {
@@ -71,12 +61,7 @@ test('drawLegacySpans: tier B loops drawElements per span', () => {
 
   drawLegacySpans(gl, caps, spans, scratch)
 
-  expect((gl as unknown as { drawElements: ReturnType<typeof vi.fn> }).drawElements).toHaveBeenCalledWith(
-    gl.TRIANGLES,
-    6,
-    gl.UNSIGNED_INT,
-    16,
-  )
+  expect((gl as unknown as { drawElements: ReturnType<typeof vi.fn> }).drawElements).toHaveBeenCalledWith(gl.TRIANGLES, 6, gl.UNSIGNED_INT, 16)
 })
 
 test('drawLegacySpans: grows scratch past MAX_OPAQUE_SPANS for uncapped blend sets', () => {
@@ -88,7 +73,7 @@ test('drawLegacySpans: grows scratch past MAX_OPAQUE_SPANS for uncapped blend se
   const spanCount = 70
   const spans = Array.from({ length: spanCount }, (_, i) => ({
     indexStart: i * 6,
-    indexCount: 6,
+    indexCount: 6
   }))
 
   drawLegacySpans(gl, caps, spans, scratch)
@@ -99,11 +84,5 @@ test('drawLegacySpans: grows scratch past MAX_OPAQUE_SPANS for uncapped blend se
   expect(scratch.offsets[69]).toBe(69 * 6 * 4)
 
   const ext = caps.ext as { multiDrawElementsWEBGL: ReturnType<typeof vi.fn> }
-  expect(ext.multiDrawElementsWEBGL).toHaveBeenCalledWith(
-    gl.TRIANGLES,
-    scratch.counts, 0,
-    gl.UNSIGNED_INT,
-    scratch.offsets, 0,
-    spanCount,
-  )
+  expect(ext.multiDrawElementsWEBGL).toHaveBeenCalledWith(gl.TRIANGLES, scratch.counts, 0, gl.UNSIGNED_INT, scratch.offsets, 0, spanCount)
 })

package/src/three/tests/pr3PerFrameCpuCuts.test.ts

@@ -3,7 +3,7 @@ import { test, expect, vi, afterEach } from 'vitest'
 import * as THREE from 'three'
 
 vi.mock('../entity/EntityMesh', () => ({
-  getMesh: vi.fn(),
+  getMesh: vi.fn()
 }))
 
 import { ChunkMeshManager } from '../chunkMeshManager'
@@ -11,13 +11,8 @@ import type { GlobalLegacyBuffer } from '../globalLegacyBuffer'
 import type { WorldRendererThree } from '../worldRendererThree'
 import type { MesherGeometryOutput } from '../../mesher-shared/shared'
 
-function makeQuadArrays () {
-  const positions = new Float32Array([
-    -1, -1, -1,
-    -1, 1, -1,
-    -1, 1, 1,
-    -1, -1, 1,
-  ])
+function makeQuadArrays() {
+  const positions = new Float32Array([-1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, 1])
   const colors = new Float32Array(12).fill(1)
   const skyLights = new Float32Array(4).fill(1)
   const blockLights = new Float32Array(4).fill(0)
@@ -26,7 +21,7 @@ function makeQuadArrays () {
   return { positions, colors, skyLights, blockLights, uvs, indices }
 }
 
-function makeBlendOnlyGeometry (): MesherGeometryOutput {
+function makeBlendOnlyGeometry(): MesherGeometryOutput {
   const blend = makeQuadArrays()
   return {
     sectionYNumber: 0,
@@ -62,12 +57,12 @@ function makeBlendOnlyGeometry (): MesherGeometryOutput {
       skyLights: blend.skyLights,
       blockLights: blend.blockLights,
       uvs: blend.uvs,
-      indices: blend.indices,
-    },
+      indices: blend.indices
+    }
   }
 }
 
-function makeOpaqueOnlyGeometry (sx = 8, sy = 8, sz = 8): MesherGeometryOutput {
+function makeOpaqueOnlyGeometry(sx = 8, sy = 8, sz = 8): MesherGeometryOutput {
   const opaque = makeQuadArrays()
   return {
     sectionYNumber: 0,
@@ -95,11 +90,11 @@ function makeOpaqueOnlyGeometry (sx = 8, sy = 8, sz = 8): MesherGeometryOutput {
     signs: {},
     banners: {},
     hadErrors: false,
-    blocksCount: 1,
+    blocksCount: 1
   }
 }
 
-function makeMixedGeometry (): MesherGeometryOutput {
+function makeMixedGeometry(): MesherGeometryOutput {
   const opaque = makeQuadArrays()
   const blend = makeQuadArrays()
   return {
@@ -136,12 +131,12 @@ function makeMixedGeometry (): MesherGeometryOutput {
       skyLights: blend.skyLights,
       blockLights: blend.blockLights,
       uvs: blend.uvs,
-      indices: blend.indices,
-    },
+      indices: blend.indices
+    }
   }
 }
 
-function createManager (): ChunkMeshManager {
+function createManager(): ChunkMeshManager {
   const scene = new THREE.Scene()
   const material = new THREE.MeshBasicMaterial()
   const worldRenderer = {
@@ -150,25 +145,25 @@ function createManager (): ChunkMeshManager {
     sceneOrigin: {
       track: () => {},
       removeAndUntrack: () => {},
-      removeAndUntrackAll: () => {},
+      removeAndUntrackAll: () => {}
     },
     blockEntities: {},
-    worldRendererConfig: {},
+    worldRendererConfig: {}
   } as unknown as WorldRendererThree
   return new ChunkMeshManager(worldRenderer, scene, material, 256, 1)
 }
 
 type ManagerInternals = {
-  legacyCullSections: Map<string, { worldX: number, worldY: number, worldZ: number }>
+  legacyCullSections: Map<string, { worldX: number; worldY: number; worldZ: number }>
   registerLegacyCullSection: (key: string, wx: number, wy: number, wz: number) => void
   maybeUnregisterLegacyCullSection: (key: string) => void
 }
 
-function getLegacyCullSections (manager: ChunkMeshManager): Map<string, { worldX: number, worldY: number, worldZ: number }> {
+function getLegacyCullSections(manager: ChunkMeshManager): Map<string, { worldX: number; worldY: number; worldZ: number }> {
   return (manager as unknown as ManagerInternals).legacyCullSections
 }
 
-function makeCamera (x: number, y: number, z: number): THREE.PerspectiveCamera {
+function makeCamera(x: number, y: number, z: number): THREE.PerspectiveCamera {
   const camera = new THREE.PerspectiveCamera(60, 1, 0.1, 1000)
   camera.position.set(x, y, z)
   camera.lookAt(8, 8, 8)
@@ -225,9 +220,14 @@ test('updateSectionCullAndSort: same visible set skips span rebuild on camera mo
   manager.updateSectionCullAndSort(camera1, 8, 8, 20)
   expect(updateDrawSpansSpy).toHaveBeenCalledTimes(1)
 
+  while (blendBuffer.hasPendingUploads()) blendBuffer.uploadDirtyRange()
+
+  manager.updateSectionCullAndSort(camera1, 8, 8, 20)
+  expect(updateDrawSpansSpy).toHaveBeenCalledTimes(2)
+
   const camera2 = makeCamera(8, 8, 18)
   manager.updateSectionCullAndSort(camera2, 8, 8, 18)
-  expect(updateDrawSpansSpy).toHaveBeenCalledTimes(1)
+  expect(updateDrawSpansSpy).toHaveBeenCalledTimes(2)
 
   manager.cleanupSection(key)
   manager.dispose()
@@ -246,11 +246,7 @@ test('updateSectionCullAndSort: layoutVersion change forces span rebuild', () =>
   expect(updateDrawSpansSpy).toHaveBeenCalledTimes(1)
 
   blendBuffer.removeSection(key)
-  blendBuffer.addSection(
-    key,
-    makeBlendOnlyGeometry().blend!,
-    8, 8, 8,
-  )
+  blendBuffer.addSection(key, makeBlendOnlyGeometry().blend!, 8, 8, 8)
   ;(manager as unknown as ManagerInternals).registerLegacyCullSection(key, 8, 8, 8)
 
   manager.updateSectionCullAndSort(camera, 8, 8, 20)
@@ -260,10 +256,91 @@ test('updateSectionCullAndSort: layoutVersion change forces span rebuild', () =>
   manager.dispose()
 })
 
-function drainLegacyUploads (buffer: GlobalLegacyBuffer): void {
+function drainLegacyUploads(buffer: GlobalLegacyBuffer): void {
   while (buffer.hasPendingUploads()) buffer.uploadDirtyRange()
 }
 
+function simulateRenderCullGate(manager: ChunkMeshManager, camera: THREE.PerspectiveCamera, x: number, y: number, z: number): void {
+  for (const buf of [manager.globalLegacyBuffer, manager.globalLegacyBlendBuffer, manager.globalBlockBuffer]) {
+    if (!buf) continue
+    buf.compactStep()
+    if (buf.hasPendingUploads()) buf.uploadDirtyRange()
+  }
+  manager.markCullDirtyIfBufferStateChanged()
+  if (manager.cullDirty) {
+    manager.updateSectionCullAndSort(camera, x, y, z)
+    manager.clearCullDirty()
+  }
+}
+
+test('markCullDirtyIfBufferStateChanged: finalize layout bump marks cull dirty', () => {
+  const manager = createManager()
+  const key = '0,0,0'
+  manager.updateSection(key, makeOpaqueOnlyGeometry(8, 8, 8))
+
+  const opaqueBuf = manager.globalLegacyBuffer!
+  drainLegacyUploads(opaqueBuf)
+
+  const camera = makeCamera(8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.clearCullDirty()
+
+  opaqueBuf.addSection(
+    key,
+    {
+      positions: makeQuadArrays().positions,
+      colors: makeQuadArrays().colors,
+      skyLights: makeQuadArrays().skyLights,
+      blockLights: makeQuadArrays().blockLights,
+      uvs: makeQuadArrays().uvs,
+      indices: makeQuadArrays().indices
+    },
+    16,
+    8,
+    8
+  )
+  drainLegacyUploads(opaqueBuf)
+  opaqueBuf.compactStep()
+  expect(opaqueBuf.hasPendingReplace()).toBe(false)
+
+  manager.markCullDirtyIfBufferStateChanged()
+  expect(manager.cullDirty).toBe(true)
+
+  manager.cleanupSection(key)
+  manager.dispose()
+})
+
+test('simulateRenderCullGate: finalize remesh refreshes visible spans without camera move', () => {
+  const manager = createManager()
+  const key = '0,0,0'
+  const camera = makeCamera(8, 8, 20)
+
+  manager.updateSection(key, makeOpaqueOnlyGeometry(8, 8, 8))
+  const opaqueBuf = manager.globalLegacyBuffer!
+  drainLegacyUploads(opaqueBuf)
+  simulateRenderCullGate(manager, camera, 8, 8, 20)
+
+  const slotA = opaqueBuf.getSectionSlot(key)!.start
+  opaqueBuf.updateDrawSpans([{ key, distSq: 1 }], 'opaque')
+  expect(opaqueBuf.getVisibleIndexSpans()[0]!.indexStart).toBe(slotA * 6)
+
+  manager.updateSection(key, makeOpaqueOnlyGeometry(16, 8, 8))
+  for (let i = 0; i < 32 && (manager.hasPendingBufferWork() || opaqueBuf.hasPendingReplace() || opaqueBuf.hasPendingUploads()); i++) {
+    simulateRenderCullGate(manager, camera, 8, 8, 20)
+  }
+
+  expect(opaqueBuf.hasPendingReplace()).toBe(false)
+  expect(opaqueBuf.hasPendingUploads()).toBe(false)
+
+  const drawStart = opaqueBuf.getSectionDrawStart(key)!
+  const spans = opaqueBuf.getVisibleIndexSpans()
+  expect(spans.length).toBeGreaterThan(0)
+  expect(spans[0]!.indexStart).toBe(drawStart * 6)
+
+  manager.cleanupSection(key)
+  manager.dispose()
+})
+
 test('updateSectionCullAndSort: defrag finalize forces span rebuild with static camera', () => {
   const manager = createManager()
   const keys = ['0,0,0', '1,0,0', '2,0,0'] as const

package/src/three/tests/signTextureCache.test.ts

@@ -4,21 +4,21 @@ import * as THREE from 'three'
 
 const renderSignMock = vi.fn()
 vi.mock('../../sign-renderer', () => ({
-  renderSign: (...args: unknown[]) => renderSignMock(...args),
+  renderSign: (...args: unknown[]) => renderSignMock(...args)
 }))
 
 vi.mock('prismarine-chat', () => ({
-  default: () => () => ({}),
+  default: () => () => ({})
 }))
 
 import { getSignTexture, releaseSignTexture, disposeAllSignTextures } from '../signTextureCache'
 import type { WorldRendererThree } from '../worldRendererThree'
 
-function createWorldRenderer (): WorldRendererThree {
+function createWorldRenderer(): WorldRendererThree {
   return { version: '1.20' } as WorldRendererThree
 }
 
-function stubCanvas () {
+function stubCanvas() {
   return { width: 64, height: 32 } as HTMLCanvasElement
 }
 

package/src/three/thirdPersonVoxelRaycast.ts

@@ -0,0 +1,120 @@
+//@ts-nocheck
+import { raycastAabb, raycastAabbFromInside } from './sectionRaycastAabb'
+
+export type VoxelRaycastHit = {
+  distance: number
+  blockX: number
+  blockY: number
+  blockZ: number
+}
+
+const intBound = (s: number, ds: number): number => {
+  if (ds === 0) return Infinity
+  if (ds < 0) return intBound(-s, -ds)
+  const frac = s - Math.floor(s)
+  return (1 - frac) / ds
+}
+
+const hitSolidBlock = (
+  ox: number,
+  oy: number,
+  oz: number,
+  dx: number,
+  dy: number,
+  dz: number,
+  bx: number,
+  by: number,
+  bz: number,
+  maxDist: number,
+  radius: number,
+  minCameraDistance: number
+): number | undefined => {
+  const minX = bx - radius
+  const minY = by - radius
+  const minZ = bz - radius
+  const maxX = bx + 1 + radius
+  const maxY = by + 1 + radius
+  const maxZ = bz + 1 + radius
+
+  let t = raycastAabb(ox, oy, oz, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, maxDist)
+  if (t === undefined) {
+    t = raycastAabbFromInside(ox, oy, oz, dx, dy, dz, minX, minY, minZ, maxX, maxY, maxZ, maxDist)
+  }
+  if (t === undefined) return undefined
+  return Math.max(minCameraDistance, t)
+}
+
+/**
+ * Amanatides–Woo grid traversal against solid block volumes (not rendered mesh faces).
+ * `radius` is baked into per-block AABB expansion (swept sphere).
+ */
+export function raycastVoxelSolid(
+  ox: number,
+  oy: number,
+  oz: number,
+  dx: number,
+  dy: number,
+  dz: number,
+  maxDist: number,
+  radius: number,
+  minCameraDistance: number,
+  isSolid: (x: number, y: number, z: number) => boolean
+): VoxelRaycastHit | undefined {
+  if (maxDist <= 0) return undefined
+
+  let x = Math.floor(ox)
+  let y = Math.floor(oy)
+  let z = Math.floor(oz)
+
+  const stepX = dx > 0 ? 1 : dx < 0 ? -1 : 0
+  const stepY = dy > 0 ? 1 : dy < 0 ? -1 : 0
+  const stepZ = dz > 0 ? 1 : dz < 0 ? -1 : 0
+
+  const tDeltaX = stepX !== 0 ? Math.abs(1 / dx) : Infinity
+  const tDeltaY = stepY !== 0 ? Math.abs(1 / dy) : Infinity
+  const tDeltaZ = stepZ !== 0 ? Math.abs(1 / dz) : Infinity
+
+  let tMaxX = stepX !== 0 ? intBound(ox, dx) : Infinity
+  let tMaxY = stepY !== 0 ? intBound(oy, dy) : Infinity
+  let tMaxZ = stepZ !== 0 ? intBound(oz, dz) : Infinity
+
+  const tryHit = (bx: number, by: number, bz: number): VoxelRaycastHit | undefined => {
+    if (!isSolid(bx, by, bz)) return undefined
+    const distance = hitSolidBlock(ox, oy, oz, dx, dy, dz, bx, by, bz, maxDist, radius, minCameraDistance)
+    if (distance === undefined || distance > maxDist) return undefined
+    return { distance, blockX: bx, blockY: by, blockZ: bz }
+  }
+
+  let hit = tryHit(x, y, z)
+  if (hit) return hit
+
+  let t = 0
+  while (t <= maxDist) {
+    if (tMaxX < tMaxY) {
+      if (tMaxX < tMaxZ) {
+        x += stepX
+        t = tMaxX
+        tMaxX += tDeltaX
+      } else {
+        z += stepZ
+        t = tMaxZ
+        tMaxZ += tDeltaZ
+      }
+    } else if (tMaxY < tMaxZ) {
+      y += stepY
+      t = tMaxY
+      tMaxY += tDeltaY
+    } else {
+      z += stepZ
+      t = tMaxZ
+      tMaxZ += tDeltaZ
+    }
+
+    if (t > maxDist) break
+
+    hit = tryHit(x, y, z)
+    if (hit) return hit
+  }
+
+  return undefined
+}