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.10",
     "mineflayer": "github:zardoy/mineflayer#gen-the-master",
     "mineflayer-mouse": "^0.1.10",
     "mineflayer-pathfinder": "^2.4.4",

renderer/viewer/lib/lightEngine.ts

@@ -0,0 +1,93 @@
+import { createPrismarineLightEngineWorker } from 'minecraft-lighting'
+import { world } from 'prismarine-world'
+// import PrismarineWorker from 'minecraft-lighting/dist/prismarineWorker.worker.js'
+import { WorldDataEmitter } from './worldDataEmitter'
+import { initMesherWorker, meshersSendMcData } from './worldrendererCommon'
+
+let lightEngineNew: ReturnType<typeof createPrismarineLightEngineWorker> | null = null
+
+export const getLightEngineSafe = () => {
+  // return lightEngine
+  return lightEngineNew
+}
+
+export const createLightEngineIfNeededNew = (worldView: WorldDataEmitter, version: string) => {
+  if (lightEngineNew) return
+  const worker = initMesherWorker((data) => {
+    // console.log('light engine worker message', data)
+  })
+  meshersSendMcData([worker], version)
+  worker.postMessage({ type: 'sideControl', value: 'lightEngine' })
+  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 = () => {
+  lightEngineNew = null
+  globalThis.lightEngine = null
+}

renderer/viewer/lib/mesher/mesher.ts

@@ -71,7 +71,10 @@ const softCleanup = () => {
   globalThis.world = world
 }
 
+let sideControl = false
 const handleMessage = data => {
+  if (sideControl) return
+
   const globalVar: any = globalThis
 
   if (data.type === 'mcData') {
@@ -92,6 +95,13 @@ const handleMessage = data => {
   }
 
   switch (data.type) {
+    case 'sideControl': {
+      if (data.value === 'lightEngine') {
+        sideControl = true
+        import('minecraft-lighting/dist/prismarineWorker.worker.js')
+      }
+      break
+    }
     case 'mesherData': {
       setMesherData(data.blockstatesModels, data.blocksAtlas, data.config.outputFormat === 'webgpu')
       allDataReady = true
@@ -107,6 +117,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,7 +103,7 @@
   return [r / 255, g / 255, b / 255]
 }
 
 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
@@ -132,7 +132,7 @@
   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++) {
@@ -488,6 +488,7 @@
 
 let unknownBlockModel: BlockModelPartsResolved
 export function getSectionGeometry (sx, sy, sz, world: World) {
+  world.hadSkyLight = false
   let delayedRender = [] as Array<() => void>
 
   const attr: MesherGeometryOutput = {
@@ -691,6 +692,8 @@
     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 }