minecraft-renderer 0.1.77 → 0.1.79

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

@@ -0,0 +1,293 @@
+//@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)
+
+  const camera2 = makeCamera(8, 8, 18)
+  manager.updateSectionCullAndSort(camera2, 8, 8, 18)
+  expect(updateDrawSpansSpy).toHaveBeenCalledTimes(1)
+
+  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()
+}
+
+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/worldRendererThree.ts

@@ -549,6 +549,12 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.chunkMeshManager.syncCubeShaderUniforms()
       this.chunkMeshManager.syncLegacyShaderUniforms()
     })
+    const pushShading = () => {
+      const cfg = this.worldRendererConfig
+      this.chunkMeshManager.setShadingTheme(cfg.shadingTheme, cfg.cardinalLight)
+    }
+    this.onReactiveConfigUpdated('shadingTheme', pushShading)
+    this.onReactiveConfigUpdated('cardinalLight', pushShading)
     this.onReactiveConfigUpdated('futuristicReveal', () => {
       this.updateModulesFromConfig()
     })
@@ -1324,12 +1330,22 @@ export class WorldRendererThree extends WorldRendererCommon {
       globalBuffer.suppressThreeDraw()
     }
     const globalLegacyBuffer = this.chunkMeshManager.globalLegacyBuffer
-    if (globalLegacyBuffer?.hasPendingUploads()) {
-      globalLegacyBuffer.uploadDirtyRange()
+    if (globalLegacyBuffer) {
+      globalLegacyBuffer.setDebugOverlay(this.displayOptions.inWorldRenderingConfig.enableDebugOverlay)
+      globalLegacyBuffer.compactStep()
+      if (globalLegacyBuffer.hasPendingUploads()) {
+        globalLegacyBuffer.uploadDirtyRange()
+      }
+      globalLegacyBuffer.suppressThreeDraw()
     }
     const globalLegacyBlendBuffer = this.chunkMeshManager.globalLegacyBlendBuffer
-    if (globalLegacyBlendBuffer?.hasPendingUploads()) {
-      globalLegacyBlendBuffer.uploadDirtyRange()
+    if (globalLegacyBlendBuffer) {
+      globalLegacyBlendBuffer.setDebugOverlay(this.displayOptions.inWorldRenderingConfig.enableDebugOverlay)
+      globalLegacyBlendBuffer.compactStep()
+      if (globalLegacyBlendBuffer.hasPendingUploads()) {
+        globalLegacyBlendBuffer.uploadDirtyRange()
+      }
+      globalLegacyBlendBuffer.suppressThreeDraw()
     }
     this.chunkMeshManager.setLegacyCameraOrigin(camX, camY, camZ)
     this.chunkMeshManager.updateCullDirtyFromCamera(cam, camX, camY, camZ)

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

@@ -17,7 +17,7 @@ import {
 } from '../bridge/shaderCubeBridge'
 import { GlobalBlockBuffer } from '../../three/globalBlockBuffer'
 import { buildVisibleCubeSpans } from '../../three/cubeDrawSpans'
-import { createCubeBlockMaterial, computeSectionOriginRel } from '../../three/shaders/cubeBlockShader'
+import { createCubeBlockMaterial, computeSectionOriginRel, setCubeShadingTheme } from '../../three/shaders/cubeBlockShader'
 import * as THREE from 'three'
 import { renderWasmOutputToGeometry } from '../bridge/render-from-wasm'
 
@@ -36,6 +36,17 @@ beforeEach(() => {
   resetShaderCubeResources()
 })
 
+test('setCubeShadingTheme: maps theme and cardinalLight to shader uniforms', () => {
+  const mat = createCubeBlockMaterial()
+  setCubeShadingTheme(mat, 'vanilla', 'default')
+  expect(mat.uniforms.u_shadingTheme.value).toBe(0)
+  expect(mat.uniforms.u_cardinalLight.value).toBe(0)
+  setCubeShadingTheme(mat, 'high-contrast', 'nether')
+  expect(mat.uniforms.u_shadingTheme.value).toBe(1)
+  expect(mat.uniforms.u_cardinalLight.value).toBe(1)
+  mat.dispose()
+})
+
 test('packWord2: AO diagonal flip sets bit 12', () => {
   const words: number[] = []
   const block = {