minecraft-renderer 0.1.71 → 0.1.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.71",
+  "version": "0.1.73",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",
@@ -55,7 +55,7 @@
     "skinview3d": "^3.4.1",
     "stats-gl": "^1.0.5",
     "stats.js": "^0.17.0",
-    "three": "0.154.0",
+    "three": "0.184.0",
     "three-stdlib": "^2.36.1",
     "type-fest": "^5.3.0",
     "typed-emitter": "^2.1.0",
@@ -70,7 +70,7 @@
     "@types/lodash": "^4.17.21",
     "@types/react": "^19.2.7",
     "@types/stats.js": "^0.17.1",
-    "@types/three": "0.154.0",
+    "@types/three": "0.184.0",
     "@zardoy/react-util": "^0.2.7",
     "@zardoy/tsconfig": "^1.5.1",
     "contro-max": "*",

package/src/graphicsBackend/rendererDefaultOptions.ts

@@ -63,7 +63,6 @@ export const RENDERER_DEFAULT_OPTIONS = {
   rendererPerfDebugOverlay: false as boolean,
   disableBlockEntityTextures: false as boolean,
   rendererMesher: 'wasm' as RendererMesherPipeline,
-  rendererShaderCubeBlocks: false as boolean,
   rendererShaderCubeDebugMode: 'off' as RendererShaderCubeDebugMode,
   showChunkBorders: false as boolean,
   renderEntities: true as boolean,
@@ -110,6 +109,7 @@ export function migrateRendererOptions(saved: Record<string, unknown>): void {
   }
   delete saved.wasmExperimentalMesher
   delete saved.rendererWasmMesher
+  delete saved.rendererShaderCubeBlocks
 
   if (saved.menuBackgroundMode === 'futuristic') {
     saved.menuBackgroundMode = 'v2'
@@ -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,12 +193,7 @@ 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
-  },
-  rendererShaderCubeBlocks: {
-    text: '(UNSTABLE) Instanced shader cubes',
-    tooltip: 'Render full blocks through the global GPU instanced path. Requires WASM mesher and WebGL2.',
+    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,
   },
   rendererShaderCubeDebugMode: {
@@ -341,7 +336,7 @@ export const RENDERER_RENDER_GUI_SECTIONS: ReadonlyArray<{
     },
     {
       title: 'Mesher',
-      keys: ['rendererMesher', 'rendererShaderCubeBlocks']
+      keys: ['rendererMesher']
     },
     {
       title: 'Renderer debug',

package/src/graphicsBackend/rendererOptionsSync.ts

@@ -163,7 +163,7 @@ export function applyRendererOptions(
   cfg.fetchPlayerSkins = o.loadPlayerSkins
   cfg.highlightBlockColor = o.highlightBlockColor
   cfg.wasmMesher = wasmActive
-  cfg.shaderCubeBlocks = o.rendererShaderCubeBlocks && wasmActive
+  cfg.shaderCubeBlocks = wasmActive
   cfg.disableMesherConversionCache = !!ctx.isSafari
 
   setSkinsConfig({ apiEnabled: o.loadPlayerSkins })

package/src/lib/bakeLegacyLight.ts

@@ -0,0 +1,17 @@
+//@ts-nocheck
+/** Bake tint×AO colors with sky/block channels for static export (no live u_skyLevel uniform). */
+export function bakeLegacyVertexColors (
+  colors: ArrayLike<number>,
+  skyLights: ArrayLike<number>,
+  blockLights: ArrayLike<number>,
+  skyLevel: number,
+): number[] {
+  const vertCount = colors.length / 3
+  const out: number[] = []
+  for (let v = 0; v < vertCount; v++) {
+    const L = Math.max(blockLights[v] ?? 0, Math.min(skyLights[v] ?? 1, skyLevel))
+    const i = v * 3
+    out.push(colors[i]! * L, colors[i + 1]! * L, colors[i + 2]! * L)
+  }
+  return out
+}

package/src/lib/blockEntityLightRegistry.test.ts

@@ -0,0 +1,18 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import * as THREE from 'three'
+import { blockEntityBrightness } from './blockEntityLighting'
+import { BlockEntityLightRegistry } from './blockEntityLightRegistry'
+
+describe('BlockEntityLightRegistry', () => {
+  it('refreshes overlay brightness when sky level changes', () => {
+    const registry = new BlockEntityLightRegistry()
+    const material = new THREE.MeshBasicMaterial()
+    registry.register({ material, blockLightNorm: 0, skyLightNorm: 1 })
+    const nightSky = 4 / 15
+    registry.setSkyLevel(nightSky)
+    expect(material.color.r).toBeCloseTo(blockEntityBrightness(0, 1, nightSky), 5)
+    registry.setSkyLevel(1)
+    expect(material.color.r).toBe(1)
+  })
+})

package/src/lib/blockEntityLightRegistry.ts

@@ -0,0 +1,75 @@
+//@ts-nocheck
+import * as THREE from 'three'
+import {
+  blockEntityBrightness,
+  DEFAULT_LIGHTMAP_PARAMS,
+  type BlockLightmapParams,
+} from './blockEntityLighting'
+
+export type BlockEntityOverlayLight = {
+  material: THREE.MeshBasicMaterial
+  blockLightNorm: number
+  skyLightNorm: number
+}
+
+export class BlockEntityLightRegistry {
+  private readonly entries = new Set<BlockEntityOverlayLight>()
+  private skyLevel = 1
+  private lightmapParams: BlockLightmapParams = { ...DEFAULT_LIGHTMAP_PARAMS }
+
+  register (entry: BlockEntityOverlayLight): void {
+    this.entries.add(entry)
+    this.applyBrightness(entry)
+  }
+
+  unregister (material: THREE.Material): void {
+    for (const entry of this.entries) {
+      if (entry.material === material) {
+        this.entries.delete(entry)
+        break
+      }
+    }
+  }
+
+  setSkyLevel (value: number): void {
+    this.skyLevel = value
+    this.refreshAll()
+  }
+
+  setLightmapParams (params: BlockLightmapParams): void {
+    this.lightmapParams = { ...this.lightmapParams, ...params }
+    this.refreshAll()
+  }
+
+  getSkyLevel (): number {
+    return this.skyLevel
+  }
+
+  private refreshAll (): void {
+    for (const entry of this.entries) {
+      this.applyBrightness(entry)
+    }
+  }
+
+  private applyBrightness (entry: BlockEntityOverlayLight): void {
+    const brightness = blockEntityBrightness(
+      entry.blockLightNorm,
+      entry.skyLightNorm,
+      this.skyLevel,
+      this.lightmapParams,
+    )
+    entry.material.color.setScalar(brightness)
+  }
+}
+
+export function tintBannerMaterial (
+  material: THREE.MeshBasicMaterial,
+  blockLightNorm: number,
+  skyLightNorm: number,
+  skyLevel: number,
+  lightmapParams: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS,
+): number {
+  const brightness = blockEntityBrightness(blockLightNorm, skyLightNorm, skyLevel, lightmapParams)
+  material.color.setScalar(brightness)
+  return brightness
+}

package/src/lib/blockEntityLighting.test.ts

@@ -0,0 +1,30 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import {
+  applyLightmap,
+  blockEntityBrightness,
+  combinedBlockLight,
+  DEFAULT_LIGHTMAP_PARAMS,
+} from './blockEntityLighting'
+
+describe('blockEntityLighting', () => {
+  it('applyLightmap(1) === 1 for default params', () => {
+    expect(applyLightmap(1, DEFAULT_LIGHTMAP_PARAMS)).toBe(1)
+  })
+
+  it('combinedBlockLight caps sky by skyLevel', () => {
+    expect(combinedBlockLight(0, 1, 4 / 15)).toBeCloseTo(4 / 15, 5)
+    expect(combinedBlockLight(0.5, 1, 4 / 15)).toBeCloseTo(0.5, 5)
+  })
+
+  it('night outdoor blockEntityBrightness matches cap + lightmap', () => {
+    const skyLevel = 4 / 15
+    const L = combinedBlockLight(0, 1, skyLevel)
+    expect(blockEntityBrightness(0, 1, skyLevel)).toBeCloseTo(applyLightmap(L), 5)
+  })
+
+  it('linear curve matches raw L at minBrightness 0', () => {
+    const p = { curve: 0, minBrightness: 0, gamma: 1 }
+    expect(applyLightmap(0.5, p)).toBeCloseTo(0.5, 5)
+  })
+})

package/src/lib/blockEntityLighting.ts

@@ -0,0 +1,53 @@
+//@ts-nocheck
+/**
+ * Shared block lighting math — keep in sync with APPLY_LIGHTMAP_GLSL in shaders.
+ */
+
+export type BlockLightmapParams = {
+  curve?: number
+  minBrightness?: number
+  gamma?: number
+}
+
+export const DEFAULT_LIGHTMAP_PARAMS: Required<BlockLightmapParams> = {
+  curve: 0,
+  minBrightness: 0.12,
+  gamma: 1,
+}
+
+/** GLSL body for applyLightmap — requires u_lightCurve, u_minBrightness, u_lightGamma uniforms. */
+export const APPLY_LIGHTMAP_GLSL = /* glsl */ `
+float applyLightmap(float L) {
+    float curved = L / (4.0 - 3.0 * L);
+    float shaped = mix(L, curved, u_lightCurve);
+    shaped = mix(u_minBrightness, 1.0, shaped);
+    return clamp(pow(shaped, u_lightGamma), 0.0, 1.0);
+}
+`
+
+export function applyLightmap (L: number, params: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS): number {
+  const curve = params.curve ?? DEFAULT_LIGHTMAP_PARAMS.curve
+  const minBrightness = params.minBrightness ?? DEFAULT_LIGHTMAP_PARAMS.minBrightness
+  const gamma = params.gamma ?? DEFAULT_LIGHTMAP_PARAMS.gamma
+
+  const curved = L / (4 - 3 * L)
+  let shaped = L * (1 - curve) + curved * curve
+  shaped = minBrightness + shaped * (1 - minBrightness)
+  return Math.min(1, Math.max(0, shaped ** gamma))
+}
+
+/** Same cap as block shaders: max(block, min(sky, skyLevel)). */
+export function combinedBlockLight (block: number, sky: number, skyLevel: number): number {
+  return Math.max(block, Math.min(sky, skyLevel))
+}
+
+/** 0..1 brightness for MeshBasicMaterial.color.setScalar on block-entity overlays. */
+export function blockEntityBrightness (
+  blockNorm: number,
+  skyNorm: number,
+  skyLevel: number,
+  lightmapParams: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS,
+): number {
+  const L = combinedBlockLight(blockNorm, skyNorm, skyLevel)
+  return applyLightmap(L, lightmapParams)
+}

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()
+  })
+})