feat: Client Side Light Engine!

package.json

@@ -169,7 +169,8 @@
     "timers-browserify": "^2.0.12",
     "typescript": "5.5.4",
     "vitest": "^0.34.6",
-    "yaml": "^2.3.2"
+    "yaml": "^2.3.2",
+    "minecraft-lighting": "^0.0.8"
   },
   "optionalDependencies": {
     "cypress": "^10.11.0",

renderer/viewer/lib/lightEngine.ts

@@ -0,0 +1,42 @@
+import { LightWorld, createLightEngineForSyncWorld, convertPrismarineBlockToWorldBlock } from 'minecraft-lighting'
+import { world } from 'prismarine-world'
+import { WorldRendererCommon } from './worldrendererCommon'
+
+let lightEngine: LightWorld | null = null
+export const getLightEngine = () => {
+  if (!lightEngine) throw new Error('Light engine not initialized')
+  return lightEngine
+}
+export const getLightEngineSafe = () => {
+  return lightEngine
+}
+
+export const createLightEngine = (world: WorldRendererCommon) => {
+  lightEngine = createLightEngineForSyncWorld(world.displayOptions.worldView.world as unknown as world.WorldSync, loadedData, {
+    minY: world.worldSizeParams.minY,
+    height: world.worldSizeParams.worldHeight,
+    // enableSkyLight: false,
+  })
+  lightEngine.PARALLEL_CHUNK_PROCESSING = false
+  globalThis.lightEngine = lightEngine
+}
+
+export const processLightChunk = async (x: number, z: number) => {
+  const chunkX = Math.floor(x / 16)
+  const chunkZ = Math.floor(z / 16)
+  const engine = getLightEngine()
+  // fillColumnWithZeroLight(engine.externalWorld, chunkX, chunkZ)
+
+  const updated = engine.receiveUpdateColumn(chunkX, chunkZ)
+  return updated
+}
+
+export const dumpLightData = (x: number, z: number) => {
+  const engine = getLightEngineSafe()
+  return engine?.worldLightHolder.dumpChunk(Math.floor(x / 16), Math.floor(z / 16))
+}
+
+export const updateBlockLight = (x: number, y: number, z: number, stateId: number) => {
+  const engine = getLightEngine()
+  engine.setBlock(x, y, z, convertPrismarineBlockToWorldBlock(mcData.blocks[stateId], loadedData))
+}

renderer/viewer/lib/mesher/mesher.ts

@@ -107,6 +107,11 @@ const handleMessage = data => {
     }
     case 'chunk': {
       world.addColumn(data.x, data.z, data.chunk)
+      if (data.lightData) {
+        world.lightHolder.loadChunk(data.lightData)
+      } else {
+        console.warn('no light data', data.x, data.z)
+      }
       if (data.customBlockModels) {
         const chunkKey = `${data.x},${data.z}`
         world.customBlockModels.set(chunkKey, data.customBlockModels)

renderer/viewer/lib/mesher/world.ts

@@ -1,3 +1,4 @@
+import { WorldLightHolder } from 'minecraft-lighting/dist/worldLightHolder'
 import Chunks from 'prismarine-chunk'
 import mcData from 'minecraft-data'
 import { Block } from 'prismarine-block'
@@ -32,6 +33,7 @@ export type WorldBlock = Omit<Block, 'position'> & {
 }
 
 export class World {
+  lightHolder = new WorldLightHolder(0, 0)
   config = defaultMesherConfig
   Chunk: typeof import('prismarine-chunk/types/index').PCChunk
   columns = {} as { [key: string]: import('prismarine-chunk/types/index').PCChunk }
@@ -51,6 +53,7 @@ export class World {
   }
 
   getLight (pos: Vec3, isNeighbor = false, skipMoreChecks = false, curBlockName = '') {
+    const IS_USING_SERVER_LIGHTING = false
     // for easier testing
     if (!(pos instanceof Vec3)) pos = new Vec3(...pos as [number, number, number])
     const { enableLighting, skyLight } = this.config
@@ -59,32 +62,49 @@ export class World {
     // if (lightsCache.has(key)) return lightsCache.get(key)
     const column = this.getColumnByPos(pos)
     if (!column || !hasChunkSection(column, pos)) return 15
-    let result = Math.min(
-      15,
-      Math.max(
-        column.getBlockLight(posInChunk(pos)),
-        Math.min(skyLight, column.getSkyLight(posInChunk(pos)))
-      ) + 2
+    let result = Math.max(
+      3,
+      Math.min(
+        15,
+        Math.max(
+          this.getBlockLight(pos),
+          Math.min(skyLight, this.getSkyLight(pos))
+        )
+      )
     )
+    const MIN_LIGHT_LEVEL = 2
+    result = Math.max(result, MIN_LIGHT_LEVEL)
     // lightsCache.set(key, result)
-    if (result === 2 && [this.getBlock(pos)?.name ?? '', curBlockName].some(x => /_stairs|slab|glass_pane/.exec(x)) && !skipMoreChecks) { // todo this is obviously wrong
-      const lights = [
-        this.getLight(pos.offset(0, 1, 0), undefined, true),
-        this.getLight(pos.offset(0, -1, 0), undefined, true),
-        this.getLight(pos.offset(0, 0, 1), undefined, true),
-        this.getLight(pos.offset(0, 0, -1), undefined, true),
-        this.getLight(pos.offset(1, 0, 0), undefined, true),
-        this.getLight(pos.offset(-1, 0, 0), undefined, true)
-      ].filter(x => x !== 2)
-      if (lights.length) {
-        const min = Math.min(...lights)
-        result = min
+    if (result === 2 && IS_USING_SERVER_LIGHTING) {
+      if ([this.getBlock(pos)?.name ?? '', curBlockName].some(x => /_stairs|slab|glass_pane/.exec(x)) && !skipMoreChecks) { // todo this is obviously wrong
+        const lights = [
+          this.getLight(pos.offset(0, 1, 0), undefined, true),
+          this.getLight(pos.offset(0, -1, 0), undefined, true),
+          this.getLight(pos.offset(0, 0, 1), undefined, true),
+          this.getLight(pos.offset(0, 0, -1), undefined, true),
+          this.getLight(pos.offset(1, 0, 0), undefined, true),
+          this.getLight(pos.offset(-1, 0, 0), undefined, true)
+        ].filter(x => x !== 2)
+        if (lights.length) {
+          const min = Math.min(...lights)
+          result = min
+        }
       }
+      if (isNeighbor) result = 15 // TODO
     }
-    if (isNeighbor && result === 2) result = 15 // TODO
     return result
   }
 
+  getBlockLight (pos: Vec3) {
+    return this.lightHolder.getBlockLight(pos.x, pos.y, pos.z)
+    // return column.getBlockLight(posInChunk(pos))
+  }
+
+  getSkyLight (pos: Vec3) {
+    return this.lightHolder.getSkyLight(pos.x, pos.y, pos.z)
+    // return column.getSkyLight(posInChunk(pos))
+  }
+
   addColumn (x, z, json) {
     const chunk = this.Chunk.fromJson(json)
     this.columns[columnKey(x, z)] = chunk as any

renderer/viewer/lib/worldDataEmitter.ts

@@ -7,10 +7,9 @@ import { Vec3 } from 'vec3'
 import { BotEvents } from 'mineflayer'
 import { proxy } from 'valtio'
 import TypedEmitter from 'typed-emitter'
-import { getItemFromBlock } from '../../../src/chatUtils'
 import { delayedIterator } from '../../playground/shared'
-import { playerState } from '../../../src/mineflayer/playerState'
 import { chunkPos } from './simpleUtils'
+import { processLightChunk, updateBlockLight } from './lightEngine'
 
 export type ChunkPosKey = string // like '16,16'
 type ChunkPos = { x: number, z: number } // like { x: 16, z: 16 }
@@ -81,6 +80,7 @@ export class WorldDataEmitter extends (EventEmitter as new () => TypedEmitter<Wo
     //   return
     // }
 
+    updateBlockLight(position.x, position.y, position.z, stateId)
     this.emit('blockUpdate', { pos: position, stateId })
   }
 
@@ -252,13 +252,23 @@ export class WorldDataEmitter extends (EventEmitter as new () => TypedEmitter<Wo
 
   async loadChunk (pos: ChunkPos, isLightUpdate = false, reason = 'spiral') {
     const [botX, botZ] = chunkPos(this.lastPos)
+    const chunkX = Math.floor(pos.x / 16)
+    const chunkZ = Math.floor(pos.z / 16)
 
-    const dx = Math.abs(botX - Math.floor(pos.x / 16))
-    const dz = Math.abs(botZ - Math.floor(pos.z / 16))
+    const dx = Math.abs(botX - chunkX)
+    const dz = Math.abs(botZ - chunkZ)
     if (dx <= this.viewDistance && dz <= this.viewDistance) {
       // eslint-disable-next-line @typescript-eslint/await-thenable -- todo allow to use async world provider but not sure if needed
       const column = await this.world.getColumnAt(pos['y'] ? pos as Vec3 : new Vec3(pos.x, 0, pos.z))
       if (column) {
+        const result = await processLightChunk(pos.x, pos.z)
+        if (!result) return
+        for (const affectedChunk of result) {
+          if (affectedChunk.x === chunkX && affectedChunk.z === chunkZ) continue
+          const loadedChunk = this.loadedChunks[`${affectedChunk.x},${affectedChunk.z}`]
+          if (!loadedChunk) continue
+          void this.loadChunk(new Vec3(affectedChunk.x * 16, 0, affectedChunk.z * 16), true)
+        }
         // const latency = Math.floor(performance.now() - this.lastTime)
         // this.debugGotChunkLatency.push(latency)
         // this.lastTime = performance.now()

renderer/viewer/lib/worldrendererCommon.ts

@@ -19,6 +19,7 @@ import { chunkPos } from './simpleUtils'
 import { addNewStat, removeAllStats, removeStat, updatePanesVisibility, updateStatText } from './ui/newStats'
 import { WorldDataEmitter } from './worldDataEmitter'
 import { IPlayerState } from './basePlayerState'
+import { createLightEngine, dumpLightData, getLightEngine, getLightEngineSafe } from './lightEngine'
 import { MesherLogReader } from './mesherlogReader'
 
 function mod (x, n) {
@@ -39,6 +40,7 @@ export const defaultWorldRendererConfig = {
   clipWorldBelowY: undefined as number | undefined,
   smoothLighting: true,
   enableLighting: true,
+  clientSideLighting: false,
   starfield: true,
   addChunksBatchWaitTime: 200,
   vrSupport: true,
@@ -169,6 +171,8 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   }
 
   constructor (public readonly resourcesManager: ResourcesManager, public displayOptions: DisplayWorldOptions, public initOptions: GraphicsInitOptions) {
+    createLightEngine(this)
+
     // this.initWorkers(1) // preload script on page load
     this.snapshotInitialValues()
     this.worldRendererConfig = displayOptions.inWorldRenderingConfig
@@ -610,7 +614,8 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
         x,
         z,
         chunk,
-        customBlockModels: customBlockModels || undefined
+        customBlockModels: customBlockModels || undefined,
+        lightData: dumpLightData(x, z)
       })
     }
     this.logWorkerWork(() => `-> chunk ${JSON.stringify({ x, z, chunkLength: chunk.length, customBlockModelsLength: customBlockModels ? Object.keys(customBlockModels).length : 0 })}`)

renderer/viewer/three/worldrendererThree.ts

@@ -151,11 +151,13 @@ export class WorldRendererThree extends WorldRendererCommon {
     })
     this.onReactiveValueUpdated('ambientLight', (value) => {
       if (!value) return
-      this.ambientLight.intensity = value
+      // this.ambientLight.intensity = value
+      this.ambientLight.intensity = 1
     })
     this.onReactiveValueUpdated('directionalLight', (value) => {
       if (!value) return
-      this.directionalLight.intensity = value
+      // this.directionalLight.intensity = value
+      this.directionalLight.intensity = 1
     })
     this.onReactiveValueUpdated('lookingAtBlock', (value) => {
       this.cursorBlock.setHighlightCursorBlock(value ? new Vec3(value.x, value.y, value.z) : null, value?.shapes)

src/optionsStorage.ts

@@ -97,7 +97,8 @@ const defaultOptions = {
   showCursorBlockInSpectator: false,
   renderEntities: true,
   smoothLighting: true,
-  newVersionsLighting: false,
+  // lightingStrategy: 'prefer-server' as 'only-server' | 'always-client' | 'prefer-server',
+  lightingStrategy: 'prefer-server' as 'always-client' | 'prefer-server',
   chatSelect: true,
   autoJump: 'auto' as 'auto' | 'always' | 'never',
   autoParkour: false,

src/watchOptions.ts

@@ -94,12 +94,16 @@ export const watchOptionsAfterViewerInit = () => {
     appViewer.inWorldRenderingConfig.smoothLighting = options.smoothLighting
   })
 
-  subscribeKey(options, 'newVersionsLighting', () => {
-    appViewer.inWorldRenderingConfig.enableLighting = !bot.supportFeature('blockStateId') || options.newVersionsLighting
-  })
+  const updateLightingStrategy = () => {
+    const clientSideLighting = options.lightingStrategy === 'always-client' || (options.lightingStrategy === 'prefer-server' && bot.supportFeature('blockStateId'))
+    appViewer.inWorldRenderingConfig.clientSideLighting = clientSideLighting
+    appViewer.inWorldRenderingConfig.enableLighting = options.dayCycleAndLighting && (!bot.supportFeature('blockStateId') || clientSideLighting)
+  }
+
+  subscribeKey(options, 'lightingStrategy', updateLightingStrategy)
 
   customEvents.on('mineflayerBotCreated', () => {
-    appViewer.inWorldRenderingConfig.enableLighting = !bot.supportFeature('blockStateId') || options.newVersionsLighting
+    updateLightingStrategy()
   })
 
   watchValue(options, o => {