feat: Client Side 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

@@ -153,6 +153,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:GenerelSchwerz/mineflayer",
     "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,88 @@
+import { LightWorld, createLightEngineForSyncWorld, convertPrismarineBlockToWorldBlock } from 'minecraft-lighting'
+import { world } from 'prismarine-world'
+import { WorldRendererCommon } from './worldrendererCommon'
+import { WorldDataEmitter } from './worldDataEmitter'
+
+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 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 processLightChunk = async (x: number, z: number) => {
+  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 = 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 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 result = await engine.setBlockUpdateChunkIfNeeded(x, y, z)
+  if (!result) return
+  console.log(`[light engine] updateBlockLight (${x}, ${y}, ${z}) took`, Math.round(result.time), 'ms', result.affectedChunks?.length ?? 0, 'chunks')
+  return result.affectedChunks
+
+  // 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.columnCleanup(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

@@ -103,8 +103,8 @@ function tintToGl (tint) {
   return [r / 255, g / 255, b / 255]
 }
 
-function getLiquidRenderHeight (world: World, block: WorldBlock | null, type: number, pos: Vec3, isRealWater: boolean) {
-  if (!isRealWater || (block && isBlockWaterlogged(block))) return 8 / 9
+function getLiquidRenderHeight (world: World, block: WorldBlock | null, type: number, pos: Vec3, isWater: boolean, isRealWater: boolean) {
+  if ((isWater && !isRealWater) || (block && isBlockWaterlogged(block))) return 8 / 9
   if (!block || block.type !== type) return 1 / 9
   if (block.metadata === 0) { // source block
     const blockAbove = world.getBlock(pos.offset(0, 1, 0))
@@ -125,12 +125,19 @@ 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++) {
     for (let x = -1; x <= 1; x++) {
       const pos = cursor.offset(x, 0, z)
-      heights.push(getLiquidRenderHeight(world, world.getBlock(pos), type, pos, isRealWater))
+      heights.push(getLiquidRenderHeight(world, world.getBlock(pos), type, pos, water, isRealWater))
     }
   }
   const cornerHeights = [
@@ -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 }