minecraft-renderer 0.1.72 → 0.1.74

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

@@ -0,0 +1,80 @@
+//@ts-nocheck
+import { test, expect } from 'vitest'
+import * as THREE from 'three'
+import { sectionIntersectsFrustum, setupLegacySectionMatrix, updateLegacySectionCullState } from '../legacySectionCull'
+
+test('setupLegacySectionMatrix: translation set once and stable across frames', () => {
+  const mesh = new THREE.Mesh(new THREE.BufferGeometry(), new THREE.MeshBasicMaterial())
+  mesh.matrixAutoUpdate = false
+
+  setupLegacySectionMatrix(mesh, 100, 64, -200, { x: 0, y: 0, z: 0 })
+
+  expect(mesh.matrix.elements[12]).toBe(100)
+  expect(mesh.matrix.elements[13]).toBe(64)
+  expect(mesh.matrix.elements[14]).toBe(-200)
+  expect(mesh.frustumCulled).toBe(false)
+
+  const before = mesh.matrix.elements.slice()
+  // No per-frame matrix write in 2a — matrix must stay unchanged across frames.
+  expect(mesh.matrix.elements.slice()).toEqual(before)
+})
+
+test('updateLegacySectionCullState: frustum hit sets visible and nearer section sorts later', () => {
+  const meshNear = new THREE.Mesh(new THREE.BufferGeometry(), new THREE.MeshBasicMaterial())
+  const meshFar = new THREE.Mesh(new THREE.BufferGeometry(), new THREE.MeshBasicMaterial())
+
+  const frustum = { intersectsBox: () => true } as unknown as THREE.Frustum
+
+  const box = new THREE.Box3()
+  const boxMin = new THREE.Vector3()
+  const boxMax = new THREE.Vector3()
+
+  updateLegacySectionCullState(meshNear, 0, 0, 0, 0, 0, 0, frustum, box, boxMin, boxMax)
+  updateLegacySectionCullState(meshFar, 32, 0, 0, 0, 0, 0, frustum, box, boxMin, boxMax)
+
+  expect(meshNear.visible).toBe(true)
+  expect(meshFar.visible).toBe(true)
+  expect(meshFar.renderOrder).toBeLessThan(meshNear.renderOrder)
+})
+
+test('sectionIntersectsFrustum: returns distSq and visibility', () => {
+  const frustum = { intersectsBox: () => true } as unknown as THREE.Frustum
+  const box = new THREE.Box3()
+  const boxMin = new THREE.Vector3()
+  const boxMax = new THREE.Vector3()
+
+  const result = sectionIntersectsFrustum(10, 0, 0, 0, 0, 0, frustum, box, boxMin, boxMax)
+  expect(result.visible).toBe(true)
+  expect(result.distSq).toBe(100)
+})
+
+test('updateLegacySectionCullState: outside frustum hides mesh', () => {
+  const mesh = new THREE.Mesh(new THREE.BufferGeometry(), new THREE.MeshBasicMaterial())
+  const frustum = new THREE.Frustum()
+  const proj = new THREE.Matrix4()
+  const camera = new THREE.PerspectiveCamera(60, 1, 0.1, 100)
+  camera.position.set(0, 0, 0)
+  camera.lookAt(0, 0, -1)
+  camera.updateMatrixWorld()
+  proj.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse)
+  frustum.setFromProjectionMatrix(proj)
+
+  const box = new THREE.Box3()
+  const boxMin = new THREE.Vector3()
+  const boxMax = new THREE.Vector3()
+
+  updateLegacySectionCullState(mesh, 500, 0, 0, 0, 0, 0, frustum, box, boxMin, boxMax)
+
+  expect(mesh.visible).toBe(false)
+})
+
+test('setupLegacySectionMatrix: non-zero render origin stores world minus R', () => {
+  const mesh = new THREE.Mesh(new THREE.BufferGeometry(), new THREE.MeshBasicMaterial())
+  mesh.matrixAutoUpdate = false
+
+  setupLegacySectionMatrix(mesh, 100, 64, -200, { x: 16, y: 0, z: 16 })
+
+  expect(mesh.matrix.elements[12]).toBe(84)
+  expect(mesh.matrix.elements[13]).toBe(64)
+  expect(mesh.matrix.elements[14]).toBe(-216)
+})

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

@@ -0,0 +1,83 @@
+//@ts-nocheck
+import { test, expect, vi, beforeEach } from 'vitest'
+import * as THREE from 'three'
+import { Vec3 } from 'vec3'
+
+vi.mock('../entity/EntityMesh', () => ({
+  getMesh: vi.fn(),
+}))
+
+const renderSignMock = vi.fn()
+vi.mock('../../sign-renderer', () => ({
+  renderSign: (...args: unknown[]) => renderSignMock(...args),
+}))
+
+vi.mock('prismarine-chat', () => ({
+  default: () => () => ({}),
+}))
+
+import { ChunkMeshManager } from '../chunkMeshManager'
+import type { WorldRendererThree } from '../worldRendererThree'
+
+function createManager (): ChunkMeshManager {
+  const scene = new THREE.Scene()
+  const material = new THREE.MeshBasicMaterial()
+  const worldRenderer = {
+    version: '1.20',
+    shaderCubeBlocksEnabled: () => false,
+    getModule: () => undefined,
+    sceneOrigin: {
+      track: () => {},
+      removeAndUntrack: () => {},
+      removeAndUntrackAll: () => {},
+    },
+    blockEntities: {},
+    worldRendererConfig: {},
+  } as unknown as WorldRendererThree
+  return new ChunkMeshManager(worldRenderer, scene, material, 256, 1)
+}
+
+function stubCanvas () {
+  return { width: 64, height: 32 } as HTMLCanvasElement
+}
+
+beforeEach(() => {
+  renderSignMock.mockReset()
+  renderSignMock.mockImplementation(() => stubCanvas())
+})
+
+test('getSignTexture: same blockEntity returns cached texture without re-render', () => {
+  const manager = createManager()
+  const signHeadsRenderer = (manager as unknown as { signHeadsRenderer: { getSignTexture: Function } }).signHeadsRenderer
+  const pos = new Vec3(10, 64, 10)
+  const blockEntity = { Text1: '{"text":"Hello"}' }
+
+  const tex1 = signHeadsRenderer.getSignTexture(pos, blockEntity, false)
+  const tex2 = signHeadsRenderer.getSignTexture(pos, blockEntity, false)
+
+  expect(tex1).toBeDefined()
+  expect(tex2).toBe(tex1)
+  expect(renderSignMock).toHaveBeenCalledTimes(1)
+
+  manager.dispose()
+})
+
+test('getSignTexture: changed blockEntity disposes old texture and renders anew', () => {
+  const manager = createManager()
+  const signHeadsRenderer = (manager as unknown as { signHeadsRenderer: { getSignTexture: Function } }).signHeadsRenderer
+  const pos = new Vec3(10, 64, 10)
+  const blockEntity = { Text1: '{"text":"Hello"}' }
+
+  const tex1 = signHeadsRenderer.getSignTexture(pos, blockEntity, false)!
+  const disposeSpy = vi.spyOn(tex1, 'dispose')
+
+  const changed = { Text1: '{"text":"World"}' }
+  const tex2 = signHeadsRenderer.getSignTexture(pos, changed, false)
+
+  expect(tex2).toBeDefined()
+  expect(tex2).not.toBe(tex1)
+  expect(disposeSpy).toHaveBeenCalledTimes(1)
+  expect(renderSignMock).toHaveBeenCalledTimes(2)
+
+  manager.dispose()
+})

package/src/three/threeJsMedia.ts

@@ -81,7 +81,7 @@ export class ThreeJsMedia {
     }
   }
 
-  private createErrorTexture(width: number, height: number, background = 0xff_ff_ff, error = 'Failed to load'): THREE.CanvasTexture {
+  private createErrorTexture(width: number, height: number, background = 0xff_ff_ff, error = 'Failed to load'): THREE.CanvasTexture<OffscreenCanvas> {
     const canvas = new OffscreenCanvas(100, 100)
     const MAX_DIMENSION = 100
 
@@ -111,7 +111,7 @@ export class ThreeJsMedia {
     return texture
   }
 
-  private createBackgroundTexture(width: number, height: number, color = 0x00_00_00, opacity = 1): THREE.CanvasTexture {
+  private createBackgroundTexture(width: number, height: number, color = 0x00_00_00, opacity = 1): THREE.CanvasTexture<OffscreenCanvas> {
     const canvas = new OffscreenCanvas(1, 1)
     canvas.width = 1
     canvas.height = 1

package/src/three/waypointSprite.ts

@@ -89,7 +89,7 @@ export function createWaypointSprite (options: {
   const labelCanvas = createCanvas(getLabelCanvasSize(), getLabelCanvasSize())
   drawCombinedOntoCanvas(labelCanvas, displayColor, options.label ?? '', '0m', visualScale)
 
-  const labelTexture = new THREE.CanvasTexture(labelCanvas)
+  const labelTexture: THREE.CanvasTexture<OffscreenCanvas> = new THREE.CanvasTexture(labelCanvas)
   labelTexture.anisotropy = 1
   labelTexture.magFilter = THREE.LinearFilter
   labelTexture.minFilter = THREE.LinearFilter
@@ -112,7 +112,7 @@ export function createWaypointSprite (options: {
   let arrowSprite: THREE.Sprite | undefined
   let arrowCanvas: OffscreenCanvas | undefined
   let arrowCtx: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | undefined
-  let arrowTexture: THREE.CanvasTexture | undefined
+  let arrowTexture: THREE.CanvasTexture<OffscreenCanvas> | undefined
   let arrowParent: THREE.Object3D | null = null
   let arrowEnabled = WAYPOINT_CONFIG.ARROW.enabledDefault
 

package/src/three/world/cursorBlock.ts

@@ -52,6 +52,7 @@ export class CursorBlock {
     const breakMaterial = new THREE.MeshBasicMaterial({
       transparent: true,
       blending: THREE.MultiplyBlending,
+      premultipliedAlpha: true,
       alphaTest: 0.5,
     })
     this.blockBreakMesh = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), breakMaterial)

package/src/three/world/vr.ts

@@ -124,14 +124,14 @@ export async function initVR(worldRenderer: WorldRendererThree, documentRenderer
   let hand1: any = controllerModelFactory.createControllerModel(controller1)
   controller1.addEventListener('connected', (event) => {
     hand1.xrInputSource = event.data
-    manageXrInputSource(event.data, 'left')
+    manageXrInputSource(event.data as { gamepad: Gamepad | undefined, handedness?: string }, 'left')
     user.add(controller1)
   })
   controller1.add(hand1)
   let hand2: any = controllerModelFactory.createControllerModel(controller2)
   controller2.addEventListener('connected', (event) => {
     hand2.xrInputSource = event.data
-    manageXrInputSource(event.data, 'right')
+    manageXrInputSource(event.data as { gamepad: Gamepad | undefined, handedness?: string }, 'right')
     user.add(controller2)
   })
   controller2.add(hand2)

package/src/three/worldGeometryExport.ts

@@ -2,8 +2,10 @@
 import * as THREE from 'three'
 import type { WorldRendererThree } from './worldRendererThree'
 import type { ExportedSection, ExportedWorldGeometry } from '../mesher-shared/exportedGeometryTypes'
+import { calculateSkyLightSimple } from '../lib/skyLight'
+import { bakeLegacyVertexColors } from '../lib/bakeLegacyLight'
 import { getShaderCubeResources } from '../wasm-mesher/bridge/shaderCubeBridge'
-import { createCubeBlockMaterial } from './shaders/cubeBlockShader'
+import { createCubeBlockMaterial, setCubeSkyLevel } from './shaders/cubeBlockShader'
 import { createShaderCubeMesh } from './shaderCubeMesh'
 
 export type { ExportedSection, ExportedWorldGeometry } from '../mesher-shared/exportedGeometryTypes'
@@ -20,35 +22,79 @@ export function exportWorldGeometry(
   includeTexture = false
 ): ExportedWorldGeometry {
   const sections: ExportedSection[] = []
+  const skyLevel = calculateSkyLightSimple(worldRenderer.timeOfTheDay) / 15
+
+  const globalLegacy = worldRenderer.chunkMeshManager.globalLegacyBuffer
 
   for (const [key, sectionObject] of Object.entries(worldRenderer.sectionObjects)) {
-    const mesh = sectionObject.children.find(child => child.name === 'mesh') as THREE.Mesh | undefined
-    if (!mesh?.geometry) continue
+    const positions: number[] = []
+    const normals: number[] = []
+    const colors: number[] = []
+    const skyLights: number[] = []
+    const blockLights: number[] = []
+    const uvs: number[] = []
+    const indices: number[] = []
 
-    const { geometry } = mesh
-    const positionAttr = geometry.getAttribute('position') as THREE.BufferAttribute
-    const normalAttr = geometry.getAttribute('normal') as THREE.BufferAttribute
-    const colorAttr = geometry.getAttribute('color') as THREE.BufferAttribute
-    const uvAttr = geometry.getAttribute('uv') as THREE.BufferAttribute
-    const indexAttr = geometry.index!
+    const globalSlot = globalLegacy?.getSectionGeometryData(key)
+    if (globalSlot) {
+      positions.push(...globalSlot.positions)
+      colors.push(...bakeLegacyVertexColors(globalSlot.colors, globalSlot.skyLights, globalSlot.blockLights, skyLevel))
+      skyLights.push(...globalSlot.skyLights)
+      blockLights.push(...globalSlot.blockLights)
+      uvs.push(...globalSlot.uvs)
+      indices.push(...globalSlot.indices)
+    }
 
-    if (!positionAttr || !indexAttr) continue
+    const blendMesh = sectionObject.children.find(child => child.name === 'mesh') as THREE.Mesh | undefined
+    if (blendMesh?.geometry) {
+      const { geometry } = blendMesh
+      const positionAttr = geometry.getAttribute('position') as THREE.BufferAttribute
+      const normalAttr = geometry.getAttribute('normal') as THREE.BufferAttribute
+      const colorAttr = geometry.getAttribute('color') as THREE.BufferAttribute
+      const skyAttr = geometry.getAttribute('a_skyLight') as THREE.BufferAttribute | undefined
+      const blockAttr = geometry.getAttribute('a_blockLight') as THREE.BufferAttribute | undefined
+      const uvAttr = geometry.getAttribute('uv') as THREE.BufferAttribute
+      const indexAttr = geometry.index
+      if (positionAttr && indexAttr && colorAttr) {
+        const vertOffset = positions.length / 3
+        const vertCount = positionAttr.count
+        const rawColors = Array.from(colorAttr.array as Float32Array)
+        const rawSky = skyAttr
+          ? Array.from(skyAttr.array as Float32Array)
+          : new Array(vertCount).fill(1)
+        const rawBlock = blockAttr
+          ? Array.from(blockAttr.array as Float32Array)
+          : new Array(vertCount).fill(0)
+        positions.push(...Array.from(positionAttr.array))
+        if (normalAttr) normals.push(...Array.from(normalAttr.array))
+        colors.push(...bakeLegacyVertexColors(rawColors, rawSky, rawBlock, skyLevel))
+        skyLights.push(...rawSky)
+        blockLights.push(...rawBlock)
+        if (uvAttr) uvs.push(...Array.from(uvAttr.array))
+        for (const idx of Array.from(indexAttr.array)) {
+          indices.push(idx + vertOffset)
+        }
+      }
+    }
+
+    if (positions.length === 0 || indices.length === 0) continue
 
-    const wp = worldRenderer.sceneOrigin.getWorldPosition(mesh)
     sections.push({
       key,
       position: {
-        x: wp?.x ?? worldRenderer.sceneOrigin.toWorldX(mesh.position.x),
-        y: wp?.y ?? worldRenderer.sceneOrigin.toWorldY(mesh.position.y),
-        z: wp?.z ?? worldRenderer.sceneOrigin.toWorldZ(mesh.position.z)
+        x: sectionObject.worldX ?? 0,
+        y: sectionObject.worldY ?? 0,
+        z: sectionObject.worldZ ?? 0,
       },
       geometry: {
-        positions: [...positionAttr.array],
-        normals: normalAttr ? [...normalAttr.array] : [],
-        colors: colorAttr ? [...colorAttr.array] : [],
-        uvs: uvAttr ? [...uvAttr.array] : [],
-        indices: [...indexAttr.array]
-      }
+        positions,
+        normals,
+        colors,
+        skyLights,
+        blockLights,
+        uvs,
+        indices,
+      },
     })
   }
 
@@ -65,7 +111,7 @@ export function exportWorldGeometry(
   // Optionally include texture atlas as data URL
   if (includeTexture && worldRenderer.material.map) {
     const canvas = document.createElement('canvas')
-    const texture = worldRenderer.material.map
+    const texture = worldRenderer.material.map as THREE.Texture<HTMLImageElement | ImageBitmap>
     const { image } = texture
     if (image) {
       canvas.width = image.width
@@ -117,12 +163,13 @@ export async function loadWorldGeometryFromUrl(url: string): Promise<ExportedWor
  * Recreate THREE.js meshes from exported geometry
  * Returns an array of mesh groups that can be added to a scene
  */
-function shaderMaterialForExport(legacyMaterial: THREE.Material): THREE.ShaderMaterial | null {
+function shaderMaterialForExport(legacyMaterial: THREE.Material, skyLevel: number): THREE.ShaderMaterial | null {
   const atlas = (legacyMaterial as THREE.MeshBasicMaterial).map
     ?? (legacyMaterial as THREE.MeshLambertMaterial).map
   if (!atlas) return null
   const shaderMat = createCubeBlockMaterial()
   shaderMat.uniforms.u_atlas.value = atlas
+  setCubeSkyLevel(shaderMat, skyLevel)
   const resources = getShaderCubeResources()
   if (!resources) return null
   const { tintPalette } = resources
@@ -135,9 +182,10 @@ export function createMeshesFromExport(
   exportData: ExportedWorldGeometry,
   material: THREE.Material,
   shaderMaterial?: THREE.ShaderMaterial | null,
+  skyLevel = 1,
 ): THREE.Group[] {
   const groups: THREE.Group[] = []
-  const resolvedShaderMat = shaderMaterial ?? shaderMaterialForExport(material)
+  const resolvedShaderMat = shaderMaterial ?? shaderMaterialForExport(material, skyLevel)
 
   for (const section of exportData.sections) {
     const group = new THREE.Group()
@@ -151,7 +199,15 @@ export function createMeshesFromExport(
         geometry.setAttribute('normal', new THREE.Float32BufferAttribute(section.geometry.normals, 3))
       }
       if (section.geometry.colors.length) {
-        geometry.setAttribute('color', new THREE.Float32BufferAttribute(section.geometry.colors, 3))
+        const baked = section.geometry.skyLights?.length
+          ? bakeLegacyVertexColors(
+            section.geometry.colors,
+            section.geometry.skyLights,
+            section.geometry.blockLights,
+            skyLevel,
+          )
+          : section.geometry.colors
+        geometry.setAttribute('color', new THREE.Float32BufferAttribute(baked, 3))
       }
       if (section.geometry.uvs.length) {
         geometry.setAttribute('uv', new THREE.Float32BufferAttribute(section.geometry.uvs, 2))
@@ -249,10 +305,11 @@ export async function applyWorldGeometryExport(
     material = rendererMaterial
   }
 
+  const skyLevel = calculateSkyLightSimple(worldRenderer.timeOfTheDay) / 15
   const shaderMat = exportData.sections.some(s => (s.shaderCubes?.count ?? 0) > 0)
-    ? shaderMaterialForExport(material)
+    ? shaderMaterialForExport(material, skyLevel)
     : null
-  const groups = createMeshesFromExport(exportData, material, shaderMat)
+  const groups = createMeshesFromExport(exportData, material, shaderMat, skyLevel)
   const container = new THREE.Group()
   container.name = GEOMETRY_EXPORT_GROUP_NAME
   if (hasEmbeddedTexture) {