minecraft-renderer 0.1.71 → 0.1.73

package/src/lib/worldrendererCommon.ts

@@ -33,6 +33,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   worldReadyResolvers = Promise.withResolvers<void>()
   worldReadyPromise = this.worldReadyResolvers.promise
   timeOfTheDay = 0
+  lastMesherSkyLight = 15
   worldSizeParams = { minY: 0, worldHeight: 256 }
   reactiveDebugParams = proxy({
     stopRendering: false,
@@ -127,6 +128,12 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   debugStopGeometryUpdate = false
 
   protocolCustomBlocks = new Map<string, CustomBlockModels>()
+  private mesherPoolSnapshot = {
+    mesherWorkers: -1,
+    wasmMesher: false,
+    dedicatedChangeWorker: false,
+  }
+  private mesherReconfigureQueue: Promise<void> = Promise.resolve()
   private heightmapDebounceTimers = new Map<string, ReturnType<typeof setTimeout>>()
 
   // Geometry throttle: first dirty per section is instant, subsequent within window are grouped
@@ -272,6 +279,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
     this.watchReactivePlayerState()
     this.watchReactiveConfig()
+    this.watchMesherPoolConfig()
     this.worldReadyResolvers.resolve()
   }
 
@@ -309,18 +317,127 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     }
   }
 
+  private getMesherWorkerScript(): 'wasm' | 'legacy' {
+    return this.worldRendererConfig.wasmMesher ? 'wasm' : 'legacy'
+  }
+
+  private createMesherWorker() {
+    const script = this.getMesherWorkerScript()
+    return initMesherWorker((data) => {
+      if (Array.isArray(data)) {
+        this.messageQueue.push(...data)
+      } else {
+        this.messageQueue.push(data)
+      }
+      void this.processMessageQueue('worker')
+    }, script === 'wasm' ? 'mesherWasm.js' : 'mesher.js')
+  }
+
   initWorkers(numWorkers = this.worldRendererConfig.mesherWorkers) {
-    // init workers
-    for (let i = 0; i < numWorkers + 0; i++) {
-      const worker = initMesherWorker((data) => {
-        if (Array.isArray(data)) {
-          this.messageQueue.push(...data)
-        } else {
-          this.messageQueue.push(data)
-        }
-        void this.processMessageQueue('worker')
-      }, this.worldRendererConfig.wasmMesher ? 'mesherWasm.js' : 'mesher.js')
-      this.workers.push(worker)
+    for (let i = 0; i < numWorkers; i++) {
+      this.workers.push(this.createMesherWorker())
+    }
+  }
+
+  private syncMesherPoolSnapshot() {
+    this.mesherPoolSnapshot = {
+      mesherWorkers: this.worldRendererConfig.mesherWorkers,
+      wasmMesher: this.worldRendererConfig.wasmMesher,
+      dedicatedChangeWorker: this.worldRendererConfig.dedicatedChangeWorker,
+    }
+  }
+
+  private watchMesherPoolConfig() {
+    this.syncMesherPoolSnapshot()
+
+    const tryReconfigure = () => {
+      const cfg = this.worldRendererConfig
+      const snap = this.mesherPoolSnapshot
+      if (
+        cfg.mesherWorkers === snap.mesherWorkers &&
+        cfg.wasmMesher === snap.wasmMesher &&
+        cfg.dedicatedChangeWorker === snap.dedicatedChangeWorker
+      ) {
+        return
+      }
+      this.syncMesherPoolSnapshot()
+      this.enqueueMesherWorkersReconfigure()
+    }
+
+    for (const key of ['mesherWorkers', 'wasmMesher', 'dedicatedChangeWorker'] as const) {
+      this.valtioUnsubs.push(
+        this.onReactiveConfigUpdated(key, tryReconfigure, false)
+      )
+    }
+  }
+
+  private enqueueMesherWorkersReconfigure() {
+    this.mesherReconfigureQueue = this.mesherReconfigureQueue
+      .then(() => this.reconfigureMesherWorkers())
+      .catch((err) => {
+        console.error('[Mesher] Failed to reconfigure workers:', err)
+      })
+  }
+  private clearMesherPendingState() {
+    this.sectionsWaiting.clear()
+    this.toWorkerMessagesQueue = {}
+    this.queueAwaited = false
+    this.messageQueue = []
+    this.isProcessingQueue = false
+    for (const timer of this.sectionDirtyTimers.values()) {
+      clearTimeout(timer)
+    }
+    this.sectionDirtyTimers.clear()
+    this.sectionDirtyCount.clear()
+    this.sectionDirtyPendingArgs.clear()
+    this.reactiveState.world.mesherWork = false
+  }
+
+  private terminateAllMesherWorkers() {
+    for (const worker of this.workers) {
+      worker.terminate()
+    }
+    this.workers = []
+  }
+
+  private async bootstrapMesherWorkers() {
+    if (this.workers.length === 0) return
+
+    this.sendMesherMcData()
+    await this.updateAssetsData()
+    this.logWorkerWork('# mesher workers bootstrapped')
+  }
+
+  async reconfigureMesherWorkers() {
+    if (!this.active) return
+
+    this.clearMesherPendingState()
+    this.terminateAllMesherWorkers()
+    this.initWorkers()
+    await this.bootstrapMesherWorkers()
+    if (!this.active) return
+
+    await this.requestLoadedChunksReload()
+  }
+
+  private async requestLoadedChunksReload() {
+    try {
+      const worldView = this.displayOptions.worldView as {
+        reloadLoadedChunks?: () => void | Promise<void>
+      }
+
+      if (typeof worldView.reloadLoadedChunks === 'function') {
+        await worldView.reloadLoadedChunks()
+        return
+      }
+
+      const workerScope = globalThis as typeof globalThis & { WorkerGlobalScope?: typeof WorkerGlobalScope }
+      if (typeof workerScope.WorkerGlobalScope !== 'undefined' && globalThis instanceof workerScope.WorkerGlobalScope) {
+        // eslint-disable-next-line no-restricted-globals
+        self.postMessage({ type: 'reloadLoadedChunks' })
+      }
+    } catch (err) {
+      console.error('[Mesher] Failed to reload chunks after worker reconfigure:', err)
     }
   }
 
@@ -331,13 +448,18 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     return subscribeKey(this.playerStateReactive, key, callback)
   }
 
-  onReactiveConfigUpdated<T extends keyof typeof this.worldRendererConfig>(key: T, callback: (value: typeof this.worldRendererConfig[T]) => void) {
-    callback(this.worldRendererConfig[key])
+  onReactiveConfigUpdated<T extends keyof typeof this.worldRendererConfig>(
+    key: T,
+    callback: (value: typeof this.worldRendererConfig[T]) => void,
+    initial = true
+  ) {
+    if (initial) {
+      callback(this.worldRendererConfig[key])
+    }
     if ((key as any) === '*') {
-      subscribe(this.worldRendererConfig, callback as any)
-    } else {
-      subscribeKey(this.worldRendererConfig, key, callback)
+      return subscribe(this.worldRendererConfig, callback as any)
     }
+    return subscribeKey(this.worldRendererConfig, key, callback)
   }
 
   onReactiveDebugUpdated<T extends keyof typeof this.reactiveDebugParams>(key: T, callback: (value: typeof this.reactiveDebugParams[T]) => void) {
@@ -574,6 +696,9 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
   timeUpdated?(newTime: number): void
 
+  /** Called when day-cycle sky-light bucket changes; Three.js overrides to remesh. */
+  protected onDayCycleSkyLightChanged?(_skyLight: number): void
+
   biomeUpdated?(biome: any): void
 
   biomeReset?(): void
@@ -637,6 +762,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
     this.initWorkers()
     this.active = true
+    this.syncMesherPoolSnapshot()
 
     this.sendMesherMcData()
   }
@@ -942,16 +1068,20 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     }, signal)
 
     bindAbortableListener(worldEmitter, 'time', (timeOfDay) => {
-      if (!this.worldRendererConfig.dayCycle) return
+      if (!this.worldRendererConfig.dayCycle) {
+        return
+      }
       this.timeUpdated?.(timeOfDay)
 
       this.timeOfTheDay = timeOfDay
 
-      // if (this.worldRendererConfig.skyLight === skyLight) return
-      // this.worldRendererConfig.skyLight = skyLight
-      // if (this instanceof WorldRendererThree) {
-      //   (this).rerenderAllChunks?.()
-      // }
+      const skyLight = (timeOfDay < 0 || timeOfDay > 24_000) ? 15 : calculateSkyLightSimple(timeOfDay)
+      if (this.lastMesherSkyLight === skyLight) return
+      this.lastMesherSkyLight = skyLight
+      if (this.workers.length > 0) {
+        this.sendWorkers({ config: { skyLight } } as WorkerSend)
+      }
+      this.onDayCycleSkyLightChanged?.(skyLight)
     }, signal)
 
     bindAbortableListener(worldEmitter, 'biomeUpdate', ({ biome }) => {

package/src/mesher-shared/blockEntityMetadata.test.ts

@@ -0,0 +1,33 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import { Vec3 } from 'vec3'
+import { collectBlockEntityMetadata } from './blockEntityMetadata'
+
+describe('collectBlockEntityMetadata', () => {
+  it('stores channel light norms on banner metadata', () => {
+    const target = { signs: {}, heads: {}, banners: {} }
+    const block = {
+      name: 'pink_banner',
+      getProperties: () => ({ rotation: 0 }),
+    }
+    collectBlockEntityMetadata(
+      block,
+      1, 2, 3,
+      target,
+      {},
+      {
+        getChannelLightNorm: (pos: Vec3) => {
+          expect(pos).toBeInstanceOf(Vec3)
+          return { block: 0.4, sky: 0.8 }
+        },
+      },
+    )
+    expect(target.banners['1,2,3']).toEqual({
+      isWall: false,
+      blockName: 'pink_banner',
+      rotation: 0,
+      blockLightNorm: 0.4,
+      skyLightNorm: 0.8,
+    })
+  })
+})

package/src/mesher-shared/blockEntityMetadata.ts

@@ -1,7 +1,15 @@
 //@ts-nocheck
+import { Vec3 } from 'vec3'
+
 export interface SignMeta { isWall: boolean; isHanging: boolean; rotation: number }
 export interface HeadMeta { isWall: boolean; rotation: number }
-export interface BannerMeta { isWall: boolean; blockName: string; rotation: number }
+export interface BannerMeta {
+  isWall: boolean
+  blockName: string
+  rotation: number
+  blockLightNorm: number
+  skyLightNorm: number
+}
 
 export interface BlockEntityMetadataTarget {
   signs: Record<string, SignMeta>
@@ -15,11 +23,16 @@ export interface BlockEntityMetadataOptions {
 
 type BlockLike = { name: string; getProperties(): any }
 
+type LightSampler = {
+  getChannelLightNorm(pos: Vec3): { block: number, sky: number }
+}
+
 export function collectBlockEntityMetadata(
   block: BlockLike,
   x: number, y: number, z: number,
   target: BlockEntityMetadataTarget,
-  options: BlockEntityMetadataOptions
+  options: BlockEntityMetadataOptions,
+  world?: LightSampler,
 ): void {
   if ((block.name.includes('_sign') || block.name === 'sign') && !options.disableBlockEntityTextures) {
     const key = `${x},${y},${z}`
@@ -61,10 +74,13 @@ export function collectBlockEntityMetadata(
       'east': 3
     }
     const isWall = block.name.endsWith('_wall_banner')
+    const light = world?.getChannelLightNorm(new Vec3(x, y, z)) ?? { block: 0, sky: 1 }
     target.banners[key] = {
       isWall,
       blockName: block.name, // Pass block name for base color extraction
-      rotation: isWall ? facingRotationMap[props.facing] : (props.rotation === undefined ? 0 : +props.rotation)
+      rotation: isWall ? facingRotationMap[props.facing] : (props.rotation === undefined ? 0 : +props.rotation),
+      blockLightNorm: light.block,
+      skyLightNorm: light.sky,
     }
   }
 }

package/src/mesher-shared/exportedGeometryTypes.ts

@@ -8,6 +8,17 @@ export interface ExportedSection {
     positions: number[]
     normals: number[]
     colors: number[]
+    skyLights: number[]
+    blockLights: number[]
+    uvs: number[]
+    indices: number[]
+  }
+  blendGeometry?: {
+    positions: number[]
+    normals: number[]
+    colors: number[]
+    skyLights: number[]
+    blockLights: number[]
     uvs: number[]
     indices: number[]
   }