feat: Server + Client Light Engine!

README.MD

@@ -12,9 +12,10 @@ For building the project yourself / contributing, see [Development, Debugging &
 
 ### Big Features
 
+- Connect to Java servers running in both offline (cracked) and online mode* (it's possible because of proxy servers, see below)
+- Combined Lighting System - Server Parsing + Client Side Engine for block updates
 - Official Mineflayer [plugin integration](https://github.com/zardoy/mcraft-fun-mineflayer-plugin)! View / Control your bot remotely.
 - Open any zip world file or even folder in read-write mode!
-- Connect to Java servers running in both offline (cracked) and online mode* (it's possible because of proxy servers, see below)
 - Integrated JS server clone capable of opening Java world saves in any way (folders, zip, web chunks streaming, etc)
 - Singleplayer mode with simple world generations!
 - Works offline

package.json

@@ -152,6 +152,7 @@
     "https-browserify": "^1.0.0",
     "mc-assets": "^0.2.53",
     "minecraft-inventory-gui": "github:zardoy/minecraft-inventory-gui#next",
+    "minecraft-lighting": "^0.0.9",
     "mineflayer": "github:zardoy/mineflayer#gen-the-master",
     "mineflayer-mouse": "^0.1.9",
     "mineflayer-pathfinder": "^2.4.4",

renderer/viewer/lib/basePlayerState.ts

@@ -31,6 +31,8 @@ export interface IPlayerState {
   getHeldItem?(isLeftHand: boolean): HandItemBlock | undefined
   username?: string
   onlineMode?: boolean
+  lightingDisabled?: boolean
+  shouldHideHand?: boolean
 
   events: TypedEmitter<PlayerStateEvents>
 

renderer/viewer/lib/lightEngine.ts

@@ -0,0 +1,106 @@
+import { LightWorld, createLightEngineForSyncWorld, convertPrismarineBlockToWorldBlock, createPrismarineLightEngineWorker } from 'minecraft-lighting'
+import { world } from 'prismarine-world'
+// import PrismarineWorker from 'minecraft-lighting/dist/prismarineWorker.worker.js'
+import { WorldDataEmitter } from './worldDataEmitter'
+
+let lightEngine: LightWorld | null = null
+let lightEngineNew: ReturnType<typeof createPrismarineLightEngineWorker> | null = null
+
+export const getLightEngine = () => {
+  if (!lightEngine) throw new Error('Light engine not initialized')
+  return lightEngine
+}
+export const getLightEngineSafe = () => {
+  // return lightEngine
+  return lightEngineNew
+}
+
+export const createLightEngineIfNeeded = (worldView: WorldDataEmitter) => {
+  if (lightEngine) return
+  lightEngine = createLightEngineForSyncWorld(worldView.world as unknown as world.WorldSync, loadedData, {
+    minY: worldView.minY,
+    height: worldView.minY + worldView.worldHeight,
+    // writeLightToOriginalWorld: true,
+    // enableSkyLight: false,
+  })
+  lightEngine.externalWorld.setBlock = () => {}
+  lightEngine.PARALLEL_CHUNK_PROCESSING = false
+  globalThis.lightEngine = lightEngine
+}
+
+export const createLightEngineIfNeededNew = (worldView: WorldDataEmitter) => {
+  if (lightEngineNew) return
+  const worker = new Worker(new URL('minecraft-lighting/dist/prismarineWorker.worker.js', import.meta.url))
+  lightEngineNew = createPrismarineLightEngineWorker(worker, worldView.world as unknown as world.WorldSync, loadedData)
+  lightEngineNew.initialize({
+    minY: worldView.minY,
+    height: worldView.minY + worldView.worldHeight,
+    // writeLightToOriginalWorld: true,
+    // enableSkyLight: false,
+  })
+
+  globalThis.lightEngine = lightEngineNew
+}
+
+export const processLightChunk = async (x: number, z: number, doLighting: boolean) => {
+  const engine = getLightEngineSafe()
+  if (!engine) return
+
+  const chunkX = Math.floor(x / 16)
+  const chunkZ = Math.floor(z / 16)
+  // fillColumnWithZeroLight(engine.externalWorld, chunkX, chunkZ)
+
+  const updated = await engine.loadChunk(chunkX, chunkZ, doLighting)
+  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 getDebugLightValues = (x: number, y: number, z: number) => {
+  const engine = getLightEngineSafe()
+  // return {
+  //   blockLight: engine?.worldLightHolder.getBlockLight(x, y, z) ?? -1,
+  //   skyLight: engine?.worldLightHolder.getSkyLight(x, y, z) ?? -1,
+  // }
+}
+
+export const updateBlockLight = async (x: number, y: number, z: number, stateId: number, distance: number) => {
+  if (distance > 16) return []
+  const chunkX = Math.floor(x / 16) * 16
+  const chunkZ = Math.floor(z / 16) * 16
+  const engine = getLightEngineSafe()
+  if (!engine) return
+  const start = performance.now()
+  const result = await engine.setBlock(x, y, z, stateId)
+  const end = performance.now()
+  console.log(`[light engine] updateBlockLight (${x}, ${y}, ${z}) took`, Math.round(end - start), 'ms', result.length, 'chunks')
+  return result
+
+  // const engine = getLightEngineSafe()
+  // if (!engine) return
+  // const affected = engine['affectedChunksTimestamps'] as Map<string, number>
+  // const noAffected = affected.size === 0
+  // engine.setBlock(x, y, z, convertPrismarineBlockToWorldBlock(stateId, loadedData))
+
+  // if (affected.size > 0) {
+  //   const chunks = [...affected.keys()].map(key => {
+  //     return key.split(',').map(Number) as [number, number]
+  //   })
+  //   affected.clear()
+  //   return chunks
+  // }
+}
+
+export const lightRemoveColumn = (x: number, z: number) => {
+  const engine = getLightEngineSafe()
+  if (!engine) return
+  engine.unloadChunk(Math.floor(x / 16), Math.floor(z / 16))
+}
+
+export const destroyLightEngine = () => {
+  lightEngine = null
+  globalThis.lightEngine = null
+}

renderer/viewer/lib/mesher/mesher.ts

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

renderer/viewer/lib/mesher/models.ts

@@ -125,6 +125,13 @@ const isCube = (block: Block) => {
   }))
 }
 
+const getVec = (v: Vec3, dir: Vec3) => {
+  for (const coord of ['x', 'y', 'z']) {
+    if (Math.abs(dir[coord]) > 0) v[coord] = 0
+  }
+  return v.plus(dir)
+}
+
 function renderLiquid (world: World, cursor: Vec3, texture: any | undefined, type: number, biome: string, water: boolean, attr: Record<string, any>, isRealWater: boolean) {
   const heights: number[] = []
   for (let z = -1; z <= 1; z++) {
@@ -142,7 +149,7 @@ function renderLiquid (world: World, cursor: Vec3, texture: any | undefined, typ
 
   // eslint-disable-next-line guard-for-in
   for (const face in elemFaces) {
-    const { dir, corners } = elemFaces[face]
+    const { dir, corners, mask1, mask2 } = elemFaces[face]
     const isUp = dir[1] === 1
 
     const neighborPos = cursor.offset(...dir as [number, number, number])
@@ -180,6 +187,9 @@ function renderLiquid (world: World, cursor: Vec3, texture: any | undefined, typ
     const { su } = texture
     const { sv } = texture
 
+    // Get base light value for the face
+    const baseLight = world.getLight(neighborPos, undefined, undefined, water ? 'water' : 'lava') / 15
+
     for (const pos of corners) {
       const height = cornerHeights[pos[2] * 2 + pos[0]]
       attr.t_positions.push(
@@ -189,7 +199,31 @@ function renderLiquid (world: World, cursor: Vec3, texture: any | undefined, typ
       )
       attr.t_normals.push(...dir)
       attr.t_uvs.push(pos[3] * su + u, pos[4] * sv * (pos[1] ? 1 : height) + v)
-      attr.t_colors.push(tint[0], tint[1], tint[2])
+
+      let cornerLightResult = baseLight
+      if (world.config.smoothLighting) {
+        const dx = pos[0] * 2 - 1
+        const dy = pos[1] * 2 - 1
+        const dz = pos[2] * 2 - 1
+        const cornerDir: [number, number, number] = [dx, dy, dz]
+        const side1Dir: [number, number, number] = [dx * mask1[0], dy * mask1[1], dz * mask1[2]]
+        const side2Dir: [number, number, number] = [dx * mask2[0], dy * mask2[1], dz * mask2[2]]
+
+        const dirVec = new Vec3(...dir as [number, number, number])
+
+        const side1LightDir = getVec(new Vec3(...side1Dir), dirVec)
+        const side1Light = world.getLight(cursor.plus(side1LightDir)) / 15
+        const side2DirLight = getVec(new Vec3(...side2Dir), dirVec)
+        const side2Light = world.getLight(cursor.plus(side2DirLight)) / 15
+        const cornerLightDir = getVec(new Vec3(...cornerDir), dirVec)
+        const cornerLight = world.getLight(cursor.plus(cornerLightDir)) / 15
+        // interpolate
+        const lights = [side1Light, side2Light, cornerLight, baseLight]
+        cornerLightResult = lights.reduce((acc, cur) => acc + cur, 0) / lights.length
+      }
+
+      // Apply light value to tint
+      attr.t_colors.push(tint[0] * cornerLightResult, tint[1] * cornerLightResult, tint[2] * cornerLightResult)
     }
   }
 }
@@ -454,6 +488,7 @@ const isBlockWaterlogged = (block: Block) => {
 
 let unknownBlockModel: BlockModelPartsResolved
 export function getSectionGeometry (sx, sy, sz, world: World) {
+  world.hadSkyLight = false
   let delayedRender = [] as Array<() => void>
 
   const attr: MesherGeometryOutput = {
@@ -657,6 +692,8 @@ export function getSectionGeometry (sx, sy, sz, world: World) {
     delete attr.uvs
   }
 
+  attr.hasSkylight = world.hadSkyLight
+
   return attr
 }
 

renderer/viewer/lib/mesher/shared.ts

@@ -3,9 +3,13 @@ import { BlockType } from '../../../playground/shared'
 // only here for easier testing
 export const defaultMesherConfig = {
   version: '',
+
   enableLighting: true,
   skyLight: 15,
   smoothLighting: true,
+  usingCustomLightHolder: false,
+  flyingSquidWorkarounds: false,
+
   outputFormat: 'threeJs' as 'threeJs' | 'webgpu',
   textureSize: 1024, // for testing
   debugModelVariant: undefined as undefined | number[],
@@ -44,6 +48,7 @@ export type MesherGeometryOutput = {
   hadErrors: boolean
   blocksCount: number
   customBlockModels?: CustomBlockModels
+  hasSkylight?: boolean
 }
 
 export type HighestBlockInfo = { y: number, stateId: number | undefined, biomeId: number | undefined }

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,8 @@ export type WorldBlock = Omit<Block, 'position'> & {
 }
 
 export class World {
+  hadSkyLight = false
+  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 }
@@ -53,38 +56,71 @@ export class World {
   getLight (pos: Vec3, isNeighbor = false, skipMoreChecks = false, curBlockName = '') {
     // for easier testing
     if (!(pos instanceof Vec3)) pos = new Vec3(...pos as [number, number, number])
-    const { enableLighting, skyLight } = this.config
+
+    const IS_USING_LOCAL_SERVER_LIGHTING = this.config.flyingSquidWorkarounds
+    // const IS_USING_SERVER_LIGHTING = false
+
+    const { enableLighting, skyLight, usingCustomLightHolder } = this.config
     if (!enableLighting) return 15
-    // const key = `${pos.x},${pos.y},${pos.z}`
-    // 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
+    if (!column) return 15
+    if (!usingCustomLightHolder && !hasChunkSection(column, pos)) return 2
+    let result = Math.max(
+      2,
+      Math.min(
+        15,
+        Math.max(
+          this.getBlockLight(pos),
+          Math.min(skyLight, this.getSkyLight(pos))
+        )
+      )
     )
-    // 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_LOCAL_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) {
+    // if (this.config.clientSideLighting) {
+    //   return this.lightHolder.getBlockLight(pos.x, pos.y, pos.z)
+    // }
+
+    const column = this.getColumnByPos(pos)
+    if (!column) return 15
+    return column.getBlockLight(posInChunk(pos))
+  }
+
+  getSkyLight (pos: Vec3) {
+    const result = this.getSkyLightInner(pos)
+    if (result > 2) this.hadSkyLight = true
+    return result
+  }
+
+  getSkyLightInner (pos: Vec3) {
+    // if (this.config.clientSideLighting) {
+    //   return this.lightHolder.getSkyLight(pos.x, pos.y, pos.z)
+    // }
+
+    const column = this.getColumnByPos(pos)
+    if (!column) return 15
+    return column.getSkyLight(posInChunk(pos))
+  }
+
   addColumn (x, z, json) {
     const chunk = this.Chunk.fromJson(json)
     this.columns[columnKey(x, z)] = chunk as any