minecraft-renderer 0.1.71 → 0.1.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.71",
+  "version": "0.1.72",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/graphicsBackend/rendererDefaultOptions.ts

@@ -166,8 +166,8 @@ export const RENDERER_OPTIONS_META: Partial<Record<RendererDefaultOptionKey, Ren
   },
   rendererWorldPerformance: {
     text: 'World performance',
-    tooltip: 'Background workers for chunk geometry. Reload to apply.',
-    requiresRestart: true,
+    tooltip: 'Background workers for chunk geometry. Recreates mesher workers and reloads chunks.',
+    requiresChunksReload: true,
     possibleValues: [
       ['low-energy', 'Low Energy'],
       ['normal', 'Normal'],
@@ -193,8 +193,8 @@ export const RENDERER_OPTIONS_META: Partial<Record<RendererDefaultOptionKey, Ren
   rendererMesher: {
     possibleValues: [['wasm', 'WASM'], ['legacy-js', 'Legacy JS']],
     text: 'Mesher pipeline',
-    tooltip: 'WASM is faster. Use JS if WASM is not working. Requires reload.',
-    requiresRestart: true
+    tooltip: 'Browser technology for processing world geometry before render. WASM is the fastest; if you see a dead tab icon, reloads, or other errors, switch to Legacy JS.',
+    requiresChunksReload: true,
   },
   rendererShaderCubeBlocks: {
     text: '(UNSTABLE) Instanced shader cubes',

package/src/lib/worldrendererCommon.reconfigure.test.ts

@@ -0,0 +1,202 @@
+//@ts-nocheck
+import { EventEmitter } from 'events'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { Vec3 } from 'vec3'
+import { proxy } from 'valtio'
+import * as worldRendererModule from './worldrendererCommon'
+import { WorldRendererCommon } from './worldrendererCommon'
+import { defaultWorldRendererConfig } from '../graphicsBackend/config'
+import { getInitialPlayerState } from '../playerState/playerState'
+import type { DisplayWorldOptions, GraphicsInitOptions } from '../graphicsBackend/types'
+
+vi.mock('./ui/newStats', () => ({
+  addNewStat: vi.fn(() => ({ updateText: vi.fn(), setVisibility: vi.fn() })),
+  updateStatText: vi.fn(),
+  removeAllStats: vi.fn(),
+  updatePanesVisibility: vi.fn(),
+  MC_RENDERER_DEBUG_OVERLAY_CLASS: 'mc-renderer-debug-overlay',
+}))
+
+vi.mock('./utils/skins', () => ({
+  setSkinsConfig: vi.fn(),
+  steveTexture: {},
+  stevePngUrl: '',
+}))
+
+function ensurePromiseWithResolvers() {
+  if (!Promise.withResolvers) {
+    Promise.withResolvers = function <T>() {
+      let resolve!: (value: T | PromiseLike<T>) => void
+      let reject!: (reason?: unknown) => void
+      const promise = new Promise<T>((res, rej) => {
+        resolve = res
+        reject = rej
+      })
+      return { promise, resolve, reject }
+    }
+  }
+}
+
+class TestWorldRenderer extends WorldRendererCommon {
+  outputFormat = 'threeJs' as const
+
+  changeBackgroundColor() {}
+  changeCardinalLight() {}
+  handleWorkerMessage() {}
+  updateCamera() {}
+  render() {}
+  updateShowChunksBorder() {}
+}
+
+function createRenderer(workerCount = 2, worldView?: DisplayWorldOptions['worldView']) {
+  const reloadLoadedChunks = vi.fn(async () => {})
+  const rendererState = proxy({
+    world: {
+      chunksLoaded: {} as Record<string, true>,
+      heightmaps: {} as Record<string, Int16Array>,
+      allChunksLoaded: false,
+      mesherWork: false,
+      instabilityFactors: {},
+      intersectMedia: null,
+    },
+    renderer: '',
+    preventEscapeMenu: false,
+  })
+
+  const displayOptions: DisplayWorldOptions = {
+    version: '1.21.1',
+    worldView: (worldView ?? Object.assign(new EventEmitter(), { reloadLoadedChunks })) as DisplayWorldOptions['worldView'],
+    inWorldRenderingConfig: proxy({ ...defaultWorldRendererConfig, mesherWorkers: workerCount }),
+    playerStateReactive: getInitialPlayerState(),
+    rendererState,
+    nonReactiveState: {
+      fps: 0,
+      worstRenderTime: 0,
+      avgRenderTime: 0,
+      world: {
+        chunksLoadedCount: 0,
+        chunksTotalNumber: 0,
+        chunksFullInfo: '',
+      },
+      renderer: {
+        timeline: { live: [], frozen: [], lastSecond: [] },
+      },
+    },
+    resourcesManager: {
+      currentResources: {
+        mcData: { version: {} },
+        blocksAtlasJson: {},
+        blockstatesModels: {},
+      },
+    } as DisplayWorldOptions['resourcesManager'],
+  }
+
+  const initOptions: GraphicsInitOptions = {
+    config: { sceneBackground: '#000' },
+    rendererSpecificSettings: {},
+    callbacks: {
+      displayCriticalError: vi.fn(),
+      setRendererSpecificSettings: vi.fn(),
+      fireCustomEvent: vi.fn(),
+    },
+  }
+
+  const renderer = new TestWorldRenderer(displayOptions.resourcesManager, displayOptions, initOptions)
+  renderer.active = true
+  renderer.workers = Array.from({ length: workerCount }, () => ({
+    postMessage: vi.fn(),
+    terminate: vi.fn(),
+  }))
+  renderer['syncMesherPoolSnapshot']()
+  renderer.viewDistance = 8
+  renderer.viewerChunkPosition = new Vec3(0, 64, 0)
+  renderer.worldSizeParams = { minY: 0, worldHeight: 256 }
+  return { renderer, reloadLoadedChunks }
+}
+
+describe('WorldRendererCommon.reconfigureMesherWorkers', () => {
+  beforeEach(() => {
+    ensurePromiseWithResolvers()
+    vi.stubGlobal('location', { href: 'http://localhost/' })
+    vi.stubGlobal('Worker', class MockWorker {
+      postMessage = vi.fn()
+      terminate = vi.fn()
+      addEventListener = vi.fn()
+      onmessage: ((event: MessageEvent) => void) | null = null
+    })
+    vi.spyOn(worldRendererModule, 'meshersSendMcData').mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.unstubAllGlobals()
+  })
+
+  test('recreates workers with new count and reloads chunks', async () => {
+    const { renderer, reloadLoadedChunks } = createRenderer(3)
+    const terminated = renderer.workers.map((worker) => worker.terminate)
+    renderer.worldRendererConfig.mesherWorkers = 1
+
+    await renderer.reconfigureMesherWorkers()
+
+    for (const terminate of terminated) {
+      expect(terminate).toHaveBeenCalled()
+    }
+    expect(renderer.workers).toHaveLength(1)
+    expect(reloadLoadedChunks).toHaveBeenCalledTimes(1)
+  })
+
+  test('recreates workers when mesher pipeline changes', async () => {
+    const { renderer, reloadLoadedChunks } = createRenderer(2)
+    const terminated = renderer.workers.map((worker) => worker.terminate)
+    renderer.worldRendererConfig.wasmMesher = false
+
+    await renderer.reconfigureMesherWorkers()
+
+    for (const terminate of terminated) {
+      expect(terminate).toHaveBeenCalled()
+    }
+    expect(renderer.workers).toHaveLength(2)
+    expect(reloadLoadedChunks).toHaveBeenCalledTimes(1)
+  })
+
+  test('watchMesherPoolConfig registers valtio unsubscribe functions', () => {
+    const { renderer } = createRenderer(2)
+
+    renderer['watchMesherPoolConfig']()
+    expect(renderer['valtioUnsubs']).toHaveLength(3)
+    for (const unsub of renderer['valtioUnsubs']) {
+      expect(typeof unsub).toBe('function')
+    }
+
+    expect(() => {
+      for (const unsub of renderer['valtioUnsubs']) unsub()
+      renderer.destroy()
+    }).not.toThrow()
+  })
+
+  test('config watcher enqueues reconfigure when mesherWorkers changes', async () => {
+    const enqueueSpy = vi.spyOn(TestWorldRenderer.prototype as any, 'enqueueMesherWorkersReconfigure')
+    const { renderer } = createRenderer(2)
+
+    renderer['watchMesherPoolConfig']()
+    renderer.worldRendererConfig.mesherWorkers = 4
+
+    await vi.waitFor(() => {
+      expect(enqueueSpy).toHaveBeenCalled()
+    })
+
+    enqueueSpy.mockRestore()
+  })
+
+  test('skips tail work when destroyed during bootstrap', async () => {
+    const { renderer, reloadLoadedChunks } = createRenderer(2)
+    vi.spyOn(renderer, 'updateAssetsData').mockImplementation(async () => {
+      renderer.active = false
+    })
+
+    await renderer.reconfigureMesherWorkers()
+
+    expect(reloadLoadedChunks).not.toHaveBeenCalled()
+  })
+})

package/src/lib/worldrendererCommon.ts

@@ -127,6 +127,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 +278,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
     this.watchReactivePlayerState()
     this.watchReactiveConfig()
+    this.watchMesherPoolConfig()
     this.worldReadyResolvers.resolve()
   }
 
@@ -309,18 +316,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 +447,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) {
@@ -637,6 +758,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
     this.initWorkers()
     this.active = true
+    this.syncMesherPoolSnapshot()
 
     this.sendMesherMcData()
   }

package/src/three/graphicsBackendOffThread.ts

@@ -9,6 +9,7 @@ import type { MenuBackgroundOptions } from './menuBackground/types'
 import { MENU_BACKGROUND_MC_VERSION } from './menuBackground/shared'
 import { createGraphicsBackendBase, type ThreeJsBackendMethods } from './graphicsBackendBase'
 import { addCanvasForWorker } from './documentRenderer'
+import type { WorldView } from '../worldView'
 
 function initThreeWorker(onGotMessage: (data: any) => void) {
   // Node environment needs an absolute path, but browser needs the url of the file
@@ -31,7 +32,12 @@ function initThreeWorker(onGotMessage: (data: any) => void) {
 }
 
 export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (initOptions) => {
-  const worker = initThreeWorker(() => { })
+  const workerSideChannel = {
+    onMessage: (_data: unknown) => {},
+  }
+  const worker = initThreeWorker((data) => {
+    workerSideChannel.onMessage(data)
+  })
   type WorkerType = ReturnType<ReturnType<typeof createGraphicsBackendBase>['workerProxy']>
 
   const proxy = useWorkerProxy<WorkerType>(worker)
@@ -79,6 +85,15 @@ export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (init
       }
     },
     async startWorld(options) {
+      const worldView = options.worldView as unknown as WorldView
+      workerSideChannel.onMessage = (data: any) => {
+        if (data?.type === 'reloadLoadedChunks') {
+          void worldView.reloadLoadedChunks().catch((err) => {
+            console.error('[Renderer] Failed to reload chunks after mesher reconfigure:', err)
+          })
+        }
+      }
+
       const workerThreeSendData = {
         ...dynamicMcDataFiles,
         items: 'itemsArray',

package/src/worldView/worldView.ts

@@ -320,6 +320,17 @@ export class WorldView extends (EventEmitter as new () => TypedEmitter<WorldView
     }
   }
 
+  /**
+   * Re-fetch and re-emit every loaded chunk (e.g. after mesher workers are recreated).
+   */
+  async reloadLoadedChunks(): Promise<void> {
+    const coords = Object.keys(this.loadedChunks)
+    for (const key of coords) {
+      const [x, z] = key.split(',').map(Number)
+      await this.loadChunk({ x, z }, false, 'mesher-reconfigure')
+    }
+  }
+
   /**
    * Unload all chunks.
    */