minecraft-renderer 0.1.78 → 0.1.80

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

@@ -0,0 +1,88 @@
+//@ts-nocheck
+import { expect, test, vi } from 'vitest'
+import { createLegacyMultiDrawScratch, detectLegacyMultiDrawCaps, drawLegacySpans } from '../legacyMultiDraw'
+
+function makeMockGl(opts?: { multiDraw?: boolean }): WebGL2RenderingContext {
+  const multiDrawElementsWEBGL = vi.fn()
+  const drawElements = vi.fn()
+  return {
+    TRIANGLES: 0x0004,
+    UNSIGNED_INT: 0x1405,
+    getExtension: (name: string) => {
+      if (opts?.multiDraw && name === 'WEBGL_multi_draw') {
+        return { multiDrawElementsWEBGL }
+      }
+      return null
+    },
+    drawElements
+  } as unknown as WebGL2RenderingContext
+}
+
+test('detectLegacyMultiDrawCaps: tier A when WEBGL_multi_draw is available', () => {
+  const gl = makeMockGl({ multiDraw: true })
+  const caps = detectLegacyMultiDrawCaps(gl)
+  expect(caps.tier).toBe('A')
+  expect(caps.ext).not.toBeNull()
+})
+
+test('detectLegacyMultiDrawCaps: tier B when extension is missing', () => {
+  const gl = makeMockGl()
+  const caps = detectLegacyMultiDrawCaps(gl)
+  expect(caps.tier).toBe('B')
+  expect(caps.ext).toBeNull()
+})
+
+test('drawLegacySpans: tier A uses multiDrawElementsWEBGL with byte offsets', () => {
+  const gl = makeMockGl({ multiDraw: true })
+  const caps = detectLegacyMultiDrawCaps(gl)
+  const scratch = createLegacyMultiDrawScratch()
+  const spans = [
+    { indexStart: 12, indexCount: 6 },
+    { indexStart: 30, indexCount: 12 }
+  ]
+
+  drawLegacySpans(gl, caps, spans, scratch)
+
+  expect(scratch.counts[0]).toBe(6)
+  expect(scratch.counts[1]).toBe(12)
+  expect(scratch.offsets[0]).toBe(48)
+  expect(scratch.offsets[1]).toBe(120)
+
+  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)
+})
+
+test('drawLegacySpans: tier B loops drawElements per span', () => {
+  const gl = makeMockGl()
+  const caps = detectLegacyMultiDrawCaps(gl)
+  const scratch = createLegacyMultiDrawScratch()
+  const spans = [{ indexStart: 4, indexCount: 6 }]
+
+  drawLegacySpans(gl, caps, spans, scratch)
+
+  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', () => {
+  const gl = makeMockGl({ multiDraw: true })
+  const caps = detectLegacyMultiDrawCaps(gl)
+  const scratch = createLegacyMultiDrawScratch()
+  expect(scratch.counts.length).toBe(64)
+
+  const spanCount = 70
+  const spans = Array.from({ length: spanCount }, (_, i) => ({
+    indexStart: i * 6,
+    indexCount: 6
+  }))
+
+  drawLegacySpans(gl, caps, spans, scratch)
+
+  expect(scratch.counts.length).toBeGreaterThanOrEqual(spanCount)
+  expect(scratch.offsets.length).toBeGreaterThanOrEqual(spanCount)
+  expect(scratch.counts[69]).toBe(6)
+  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)
+})

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

@@ -0,0 +1,370 @@
+//@ts-nocheck
+import { test, expect, vi, afterEach } from 'vitest'
+import * as THREE from 'three'
+
+vi.mock('../entity/EntityMesh', () => ({
+  getMesh: vi.fn()
+}))
+
+import { ChunkMeshManager } from '../chunkMeshManager'
+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])
+  const colors = new Float32Array(12).fill(1)
+  const skyLights = new Float32Array(4).fill(1)
+  const blockLights = new Float32Array(4).fill(0)
+  const uvs = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1])
+  const indices = new Uint32Array([0, 1, 2, 0, 2, 3])
+  return { positions, colors, skyLights, blockLights, uvs, indices }
+}
+
+function makeBlendOnlyGeometry(): MesherGeometryOutput {
+  const blend = makeQuadArrays()
+  return {
+    sectionYNumber: 0,
+    chunkKey: '0,0',
+    sectionStartY: 0,
+    sectionEndY: 16,
+    sectionStartX: 0,
+    sectionEndX: 16,
+    sectionStartZ: 0,
+    sectionEndZ: 16,
+    sx: 8,
+    sy: 8,
+    sz: 8,
+    positions: new Float32Array(0),
+    normals: new Float32Array(0),
+    colors: new Float32Array(0),
+    skyLights: new Float32Array(0),
+    blockLights: new Float32Array(0),
+    uvs: new Float32Array(0),
+    indices: new Uint32Array(0),
+    indicesCount: 0,
+    using32Array: true,
+    tiles: {},
+    heads: {},
+    signs: {},
+    banners: {},
+    hadErrors: false,
+    blocksCount: 1,
+    blend: {
+      positions: blend.positions,
+      normals: new Float32Array(12),
+      colors: blend.colors,
+      skyLights: blend.skyLights,
+      blockLights: blend.blockLights,
+      uvs: blend.uvs,
+      indices: blend.indices
+    }
+  }
+}
+
+function makeOpaqueOnlyGeometry(sx = 8, sy = 8, sz = 8): MesherGeometryOutput {
+  const opaque = makeQuadArrays()
+  return {
+    sectionYNumber: 0,
+    chunkKey: '0,0',
+    sectionStartY: 0,
+    sectionEndY: 16,
+    sectionStartX: 0,
+    sectionEndX: 16,
+    sectionStartZ: 0,
+    sectionEndZ: 16,
+    sx,
+    sy,
+    sz,
+    positions: opaque.positions,
+    normals: new Float32Array(12),
+    colors: opaque.colors,
+    skyLights: opaque.skyLights,
+    blockLights: opaque.blockLights,
+    uvs: opaque.uvs,
+    indices: opaque.indices,
+    indicesCount: 6,
+    using32Array: true,
+    tiles: {},
+    heads: {},
+    signs: {},
+    banners: {},
+    hadErrors: false,
+    blocksCount: 1
+  }
+}
+
+function makeMixedGeometry(): MesherGeometryOutput {
+  const opaque = makeQuadArrays()
+  const blend = makeQuadArrays()
+  return {
+    sectionYNumber: 0,
+    chunkKey: '0,0',
+    sectionStartY: 0,
+    sectionEndY: 16,
+    sectionStartX: 0,
+    sectionEndX: 16,
+    sectionStartZ: 0,
+    sectionEndZ: 16,
+    sx: 8,
+    sy: 8,
+    sz: 8,
+    positions: opaque.positions,
+    normals: new Float32Array(12),
+    colors: opaque.colors,
+    skyLights: opaque.skyLights,
+    blockLights: opaque.blockLights,
+    uvs: opaque.uvs,
+    indices: opaque.indices,
+    indicesCount: 6,
+    using32Array: true,
+    tiles: {},
+    heads: {},
+    signs: {},
+    banners: {},
+    hadErrors: false,
+    blocksCount: 2,
+    blend: {
+      positions: blend.positions,
+      normals: new Float32Array(12),
+      colors: blend.colors,
+      skyLights: blend.skyLights,
+      blockLights: blend.blockLights,
+      uvs: blend.uvs,
+      indices: blend.indices
+    }
+  }
+}
+
+function createManager(): ChunkMeshManager {
+  const scene = new THREE.Scene()
+  const material = new THREE.MeshBasicMaterial()
+  const worldRenderer = {
+    shaderCubeBlocksEnabled: () => false,
+    getModule: () => undefined,
+    sceneOrigin: {
+      track: () => {},
+      removeAndUntrack: () => {},
+      removeAndUntrackAll: () => {}
+    },
+    blockEntities: {},
+    worldRendererConfig: {}
+  } as unknown as WorldRendererThree
+  return new ChunkMeshManager(worldRenderer, scene, material, 256, 1)
+}
+
+type ManagerInternals = {
+  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 }> {
+  return (manager as unknown as ManagerInternals).legacyCullSections
+}
+
+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)
+  camera.updateMatrixWorld()
+  return camera
+}
+
+afterEach(() => {
+  vi.restoreAllMocks()
+})
+
+test('legacyCullSections: gains key on blend add, removed after cleanup', () => {
+  const manager = createManager()
+  const key = '0,0,0'
+
+  manager.updateSection(key, makeBlendOnlyGeometry())
+  expect(getLegacyCullSections(manager).has(key)).toBe(true)
+
+  manager.cleanupSection(key)
+  expect(getLegacyCullSections(manager).has(key)).toBe(false)
+
+  manager.dispose()
+})
+
+test('legacyCullSections: mixed opaque+blend keeps key until both buffers cleared', () => {
+  const manager = createManager()
+  const key = '0,0,0'
+
+  manager.updateSection(key, makeMixedGeometry())
+  expect(getLegacyCullSections(manager).has(key)).toBe(true)
+  expect(manager.globalLegacyBuffer?.hasSection(key)).toBe(true)
+  expect(manager.globalLegacyBlendBuffer?.hasSection(key)).toBe(true)
+
+  manager.globalLegacyBuffer?.removeSection(key)
+  expect(getLegacyCullSections(manager).has(key)).toBe(true)
+
+  manager.globalLegacyBlendBuffer?.removeSection(key)
+  ;(manager as unknown as ManagerInternals).maybeUnregisterLegacyCullSection(key)
+  expect(getLegacyCullSections(manager).has(key)).toBe(false)
+
+  manager.cleanupSection(key)
+  manager.dispose()
+})
+
+test('updateSectionCullAndSort: same visible set skips span rebuild on camera move', () => {
+  const manager = createManager()
+  const key = '0,0,0'
+  manager.updateSection(key, makeBlendOnlyGeometry())
+
+  const blendBuffer = manager.globalLegacyBlendBuffer!
+  const updateDrawSpansSpy = vi.spyOn(blendBuffer, 'updateDrawSpans')
+
+  const camera1 = makeCamera(8, 8, 20)
+  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(2)
+
+  manager.cleanupSection(key)
+  manager.dispose()
+})
+
+test('updateSectionCullAndSort: layoutVersion change forces span rebuild', () => {
+  const manager = createManager()
+  const key = '0,0,0'
+  manager.updateSection(key, makeBlendOnlyGeometry())
+
+  const blendBuffer = manager.globalLegacyBlendBuffer!
+  const updateDrawSpansSpy = vi.spyOn(blendBuffer, 'updateDrawSpans')
+
+  const camera = makeCamera(8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  expect(updateDrawSpansSpy).toHaveBeenCalledTimes(1)
+
+  blendBuffer.removeSection(key)
+  blendBuffer.addSection(key, makeBlendOnlyGeometry().blend!, 8, 8, 8)
+  ;(manager as unknown as ManagerInternals).registerLegacyCullSection(key, 8, 8, 8)
+
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  expect(updateDrawSpansSpy).toHaveBeenCalledTimes(2)
+
+  manager.cleanupSection(key)
+  manager.dispose()
+})
+
+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
+
+  for (let i = 0; i < keys.length; i++) {
+    manager.updateSection(keys[i]!, makeOpaqueOnlyGeometry(8, 8, 8 + i * 8))
+  }
+
+  const opaqueBuf = manager.globalLegacyBuffer!
+  const updateDrawSpansSpy = vi.spyOn(opaqueBuf, 'updateDrawSpans')
+  const camera = makeCamera(8, 8, 20)
+
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  expect(updateDrawSpansSpy).toHaveBeenCalledTimes(1)
+
+  opaqueBuf.removeSection('1,0,0')
+  drainLegacyUploads(opaqueBuf)
+  opaqueBuf.compactStep()
+  drainLegacyUploads(opaqueBuf)
+  opaqueBuf.compactStep()
+
+  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  expect(updateDrawSpansSpy).toHaveBeenCalledTimes(2)
+
+  for (const key of keys) manager.cleanupSection(key)
+  manager.dispose()
+})

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
 }