minecraft-renderer 0.1.72 → 0.1.73

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) {

package/src/three/worldRendererThree.ts

@@ -9,6 +9,7 @@ import { renderSign } from '../sign-renderer'
 import { DisplayWorldOptions, GraphicsInitOptions } from '../graphicsBackend/types'
 import { chunkPos, sectionPos } from '../lib/simpleUtils'
 import { WorldRendererCommon } from '../lib/worldrendererCommon'
+import { calculateSkyLightSimple } from '../lib/skyLight'
 import { addNewStat, MC_RENDERER_DEBUG_OVERLAY_CLASS } from '../lib/ui/newStats'
 import { MesherGeometryOutput } from '../mesher-shared/shared'
 import { ItemSpecificContextProperties } from '../playerState/types'
@@ -43,6 +44,9 @@ type SectionKey = string
 export class WorldRendererThree extends WorldRendererCommon {
   outputFormat = 'threeJs' as const
 
+  /** r184 removed useLegacyLights; physical intensities ≈ legacy / π. */
+  private static readonly LEGACY_TO_PHYSICAL_LIGHT = Math.PI
+
   protected override isShaderCubeBlocksEnabled(): boolean {
     return this.worldRendererConfig.shaderCubeBlocks === true
       && !!this.renderer?.capabilities?.isWebGL2
@@ -60,8 +64,8 @@ export class WorldRendererThree extends WorldRendererCommon {
   get realScene() {
     return this.scene
   }
-  ambientLight = new THREE.AmbientLight(0xcc_cc_cc)
-  directionalLight = new THREE.DirectionalLight(0xff_ff_ff, 0.5)
+  ambientLight = new THREE.AmbientLight(0xcc_cc_cc, WorldRendererThree.LEGACY_TO_PHYSICAL_LIGHT)
+  directionalLight = new THREE.DirectionalLight(0xff_ff_ff, 0.5 * WorldRendererThree.LEGACY_TO_PHYSICAL_LIGHT)
   entities = new Entities(this, (globalThis as any).mcData)
   performanceMonitor!: PerformanceMonitor
   cameraGroupVr?: THREE.Object3D
@@ -70,6 +74,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   cursorBlock: CursorBlock
   onRender: Array<(deltaTime: number) => void> = []
   private lastRenderTime = 0
+  private lastSciFiTickMs = 0
   private animatedFov = 0
   private lastFovAnimTime = 0
   private static readonly FOV_TRANSITION_MS = 200
@@ -176,6 +181,15 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.chunkMeshManager.updateViewDistance(viewDistance)
     }
 
+    // Final lightmap values TBD — compare against https://v99.mcraft.fun/
+    if (typeof window !== 'undefined') {
+      (window as any).setBlockLightmap = (params: { curve?: number, minBrightness?: number, gamma?: number }) => {
+        this.chunkMeshManager.setBlockLightmapParams(params)
+      }
+    }
+
+    this.syncSkyLevelFromTime(this.timeOfTheDay)
+
     this.cursorBlock = new CursorBlock(this)
     this.holdingBlock = createHoldingBlock(this)
     this.holdingBlockLeft = createHoldingBlock(this, true)
@@ -431,6 +445,7 @@ export class WorldRendererThree extends WorldRendererCommon {
 
   worldSwitchActions() {
     this.onWorldSwitched.push(() => {
+      this.getModule<{ onWorldSwitched?: () => void }>('futuristicReveal')?.onWorldSwitched?.()
       // clear custom blocks
       this.protocolCustomBlocks.clear()
       // Reset section animations
@@ -441,6 +456,7 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.cinimaticScript.stopScript()
       // Clear fireworks
       this.fireworks.clear()
+      this.syncSkyLevelFromTime(this.timeOfTheDay)
     })
   }
 
@@ -500,11 +516,11 @@ export class WorldRendererThree extends WorldRendererCommon {
     })
     this.onReactivePlayerStateUpdated('ambientLight', (value) => {
       if (!value) return
-      this.ambientLight.intensity = value
+      this.ambientLight.intensity = value * WorldRendererThree.LEGACY_TO_PHYSICAL_LIGHT
     })
     this.onReactivePlayerStateUpdated('directionalLight', (value) => {
       if (!value) return
-      this.directionalLight.intensity = value
+      this.directionalLight.intensity = value * WorldRendererThree.LEGACY_TO_PHYSICAL_LIGHT
     })
     this.onReactivePlayerStateUpdated('lookingAtBlock', (value) => {
       this.cursorBlock.setHighlightCursorBlock(value ? new Vec3(value.x, value.y, value.z) : null, value?.shapes)
@@ -530,6 +546,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     })
     this.onReactiveConfigUpdated('shaderCubeDebugMode', () => {
       this.chunkMeshManager.syncCubeShaderUniforms()
+      this.chunkMeshManager.syncLegacyShaderUniforms()
     })
     this.onReactiveConfigUpdated('futuristicReveal', () => {
       this.updateModulesFromConfig()
@@ -631,6 +648,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     texture.flipY = false
     this.material.map = texture
     this.chunkMeshManager.syncCubeShaderUniforms()
+    this.chunkMeshManager.syncLegacyShaderUniforms()
 
     const itemsTexture = loadThreeJsTextureFromBitmap(resources.itemsAtlasImage!)
     itemsTexture.needsUpdate = true
@@ -675,6 +693,16 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
 
     this.skyboxRenderer.updateTime(newTime)
+    this.syncSkyLevelFromTime(newTime)
+  }
+
+  private syncSkyLevelFromTime (timeOfDay: number): void {
+    const skyLevel = calculateSkyLightSimple(timeOfDay) / 15
+    this.chunkMeshManager.setSkyLevel(skyLevel)
+  }
+
+  protected onDayCycleSkyLightChanged(_skyLight: number): void {
+    // Sky cap is driven by u_skyLevel uniform; no remesh on day/night.
   }
 
   biomeUpdated(biome: Biome): void {
@@ -787,6 +815,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     // "Batch Chunks Display" (`_renderByChunks`) option. No-op when the
     // option is off — `waitingChunksToDisplay` is empty in that case.
     this.chunkMeshManager.finishChunkDisplay(chunkKey)
+    this.getModule<{ onChunkFinished?: () => void }>('futuristicReveal')?.onChunkFinished?.()
   }
 
   private applyPendingSectionUpdates() {
@@ -847,8 +876,12 @@ export class WorldRendererThree extends WorldRendererCommon {
         continue
       }
 
-      this.chunkMeshManager.updateSection(update.key, update.geometry)
+      const sectionObject = this.chunkMeshManager.updateSection(update.key, update.geometry)
       this.updatePosDataChunk(update.key)
+      if (sectionObject) {
+        this.getModule<{ onSectionMeshed?: (key: string, geometry: MesherGeometryOutput, section: typeof sectionObject) => void }>('futuristicReveal')
+          ?.onSectionMeshed?.(update.key, update.geometry, sectionObject)
+      }
     }
   }
 
@@ -885,8 +918,12 @@ export class WorldRendererThree extends WorldRendererCommon {
         this.chunkMeshManager.releaseSection(data.key)
         return
       }
-      this.chunkMeshManager.updateSection(data.key, data.geometry)
+      const sectionObject = this.chunkMeshManager.updateSection(data.key, data.geometry)
       this.updatePosDataChunk(data.key)
+      if (sectionObject) {
+        this.getModule<{ onSectionMeshed?: (key: string, geometry: MesherGeometryOutput, section: typeof sectionObject) => void }>('futuristicReveal')
+          ?.onSectionMeshed?.(data.key, data.geometry, sectionObject)
+      }
     }
   }
 
@@ -975,17 +1012,9 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.debugRaycast(pos, direction, distance)
     }
 
-    // Convert world position to scene-relative coordinates for raycasting
-    const scenePos = this._tpScenePos.set(
-      this.sceneOrigin.toSceneX(pos.x),
-      this.sceneOrigin.toSceneY(pos.y),
-      this.sceneOrigin.toSceneZ(pos.z)
-    )
-
-    // Perform raycast to avoid camera going through blocks
     const raycaster = this._tpRaycaster
-    raycaster.set(scenePos, direction)
-    raycaster.far = distance // Limit raycast distance
+    raycaster.set(pos, direction)
+    raycaster.far = distance
 
     const maxCenterDistance = 80
     const maxCenterDistSq = maxCenterDistance * maxCenterDistance
@@ -993,8 +1022,8 @@ export class WorldRendererThree extends WorldRendererCommon {
     const oy = pos.y
     const oz = pos.z
 
-    // Legacy / deferred-shader meshes (scene-relative raycast)
-    const meshes: THREE.Object3D[] = []
+    // Legacy section meshes: world-space raycast (static mesh.matrix translation).
+    const legacyMeshes: THREE.Object3D[] = []
     for (const obj of Object.values(this.sectionObjects)) {
       if (obj.name !== 'chunk' || !obj.visible) continue
       if (obj.worldX === undefined) continue
@@ -1002,11 +1031,11 @@ export class WorldRendererThree extends WorldRendererCommon {
       const dcy = obj.worldY! - oy
       const dcz = obj.worldZ! - oz
       if (dcx * dcx + dcy * dcy + dcz * dcz > maxCenterDistSq) continue
-      const mesh = obj.children.find(child => child.name === 'mesh' || child.name === 'shaderMesh')
-      if (mesh) meshes.push(mesh)
+      const mesh = obj.children.find(child => child.name === 'mesh')
+      if (mesh) legacyMeshes.push(mesh)
     }
 
-    const intersects = raycaster.intersectObjects(meshes, false)
+    const intersects = raycaster.intersectObjects(legacyMeshes, false)
 
     let finalDistance = distance
     if (intersects.length > 0) {
@@ -1024,6 +1053,15 @@ export class WorldRendererThree extends WorldRendererCommon {
       finalDistance = Math.max(0.5, boxHit - 0.2)
     }
 
+    const legacyGlobalHit = this.chunkMeshManager.raycastGlobalLegacySections(
+      raycaster,
+      pos,
+      maxCenterDistance,
+    )
+    if (legacyGlobalHit !== undefined) {
+      finalDistance = Math.max(0.5, legacyGlobalHit - 0.2)
+    }
+
     const finalPos = new Vec3(
       pos.x + direction.x * finalDistance,
       pos.y + direction.y * finalDistance,
@@ -1280,12 +1318,45 @@ export class WorldRendererThree extends WorldRendererCommon {
 
     // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
     const cam = this.cameraGroupVr instanceof THREE.Group ? this.cameraGroupVr.children.find(child => child instanceof THREE.PerspectiveCamera) as THREE.PerspectiveCamera : this.camera
+    // Flush buffered section geometry before reveal tick (calls onSectionMeshed synchronously in handleWorkerMessage).
     this.applyPendingSectionUpdates()
+    const sciFiNow = performance.now()
+    const sciFiDeltaMs = sciFiNow - this.lastSciFiTickMs
+    this.lastSciFiTickMs = sciFiNow
+    this.getModule<{ tick?: (deltaMs: number, now?: number) => void }>('futuristicReveal')?.tick?.(sciFiDeltaMs, sciFiNow)
+    const camX = this.cameraWorldPos.x
+    const camY = this.cameraWorldPos.y
+    const camZ = this.cameraWorldPos.z
+    this.chunkMeshManager.maybeRebase({ x: camX, y: camY, z: camZ })
+    const renderOrigin = this.chunkMeshManager.getRenderOrigin()
     const globalBuffer = this.chunkMeshManager.globalBlockBuffer
     if (globalBuffer) {
-      globalBuffer.setCameraOrigin(this.cameraWorldPos.x, this.cameraWorldPos.y, this.cameraWorldPos.z)
+      globalBuffer.setCameraOrigin(renderOrigin, camX, camY, camZ)
+      globalBuffer.setDebugOverlay(this.displayOptions.inWorldRenderingConfig.enableDebugOverlay)
       globalBuffer.compactStep()
-      globalBuffer.uploadDirtyRange()
+      if (globalBuffer.hasPendingUploads()) {
+        globalBuffer.uploadDirtyRange()
+      }
+      globalBuffer.suppressThreeDraw()
+    }
+    const globalLegacyBuffer = this.chunkMeshManager.globalLegacyBuffer
+    if (globalLegacyBuffer?.hasPendingUploads()) {
+      globalLegacyBuffer.uploadDirtyRange()
+    }
+    const globalLegacyBlendBuffer = this.chunkMeshManager.globalLegacyBlendBuffer
+    if (globalLegacyBlendBuffer?.hasPendingUploads()) {
+      globalLegacyBlendBuffer.uploadDirtyRange()
+    }
+    this.chunkMeshManager.setLegacyCameraOrigin(camX, camY, camZ)
+    this.chunkMeshManager.updateCullDirtyFromCamera(cam, camX, camY, camZ)
+    if (this.chunkMeshManager.cullDirty) {
+      this.chunkMeshManager.updateSectionCullAndSort(
+        cam,
+        this.cameraWorldPos.x,
+        this.cameraWorldPos.y,
+        this.cameraWorldPos.z,
+      )
+      this.chunkMeshManager.clearCullDirty()
     }
     this.renderer.render(this.scene, cam)
 
@@ -1524,8 +1595,6 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   setSectionDirty(...args: Parameters<WorldRendererCommon['setSectionDirty']>) {
-    const [pos] = args
-    this.cleanChunkTextures(pos.x, pos.z) // todo don't do this!
     super.setSectionDirty(...args)
   }