minecraft-renderer 0.1.62 → 0.1.64

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

@@ -0,0 +1,182 @@
+//@ts-nocheck
+import { EventEmitter } from 'events'
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { Vec3 } from 'vec3'
+import { proxy } from 'valtio'
+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() {
+  const rendererState = proxy({
+    world: {
+      chunksLoaded: new Set<string>(),
+      heightmaps: new Map<string, Int16Array>(),
+      allChunksLoaded: false,
+      mesherWork: false,
+      instabilityFactors: {},
+      intersectMedia: null,
+    },
+    renderer: '',
+    preventEscapeMenu: false,
+  })
+
+  const displayOptions = {
+    version: '1.21.1',
+    worldView: new EventEmitter() as DisplayWorldOptions['worldView'],
+    inWorldRenderingConfig: { ...defaultWorldRendererConfig },
+    playerStateReactive: getInitialPlayerState(),
+    rendererState,
+    nonReactiveState: {
+      fps: 0,
+      worstRenderTime: 0,
+      avgRenderTime: 0,
+      world: {
+        chunksLoaded: new Set<string>(),
+        chunksTotalNumber: 0,
+        chunksFullInfo: '',
+      },
+      renderer: {
+        timeline: { live: [], frozen: [], lastSecond: [] },
+      },
+    },
+    resourcesManager: {} 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 = [{ postMessage: vi.fn() }, { postMessage: vi.fn() }]
+  renderer.viewDistance = 16
+  renderer.viewerChunkPosition = new Vec3(0, 64, 0)
+  renderer.worldSizeParams = { minY: 0, worldHeight: 256 }
+  renderer.loadedChunks['160,0'] = true
+  return renderer
+}
+
+function sectionKeysForColumn(renderer: TestWorldRenderer, x: number, z: number): string[] {
+  const keys: string[] = []
+  const sectionHeight = renderer.getSectionHeight()
+  for (let y = renderer.worldMinYRender; y < renderer.worldSizeParams.worldHeight; y += sectionHeight) {
+    keys.push(`${x},${y},${z}`)
+  }
+  return keys
+}
+
+describe('WorldRendererCommon.removeColumn sectionsWaiting reconciliation', () => {
+  beforeEach(() => {
+    ensurePromiseWithResolvers()
+    vi.useFakeTimers()
+    vi.stubGlobal('location', { href: 'http://localhost/' })
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.unstubAllGlobals()
+  })
+
+  test('clears sectionsWaiting when viewDistance gate blocks setSectionDirty(false)', () => {
+    const renderer = createRenderer()
+    const columnX = 160
+    const columnZ = 0
+    const sectionPos = new Vec3(columnX, 64, columnZ)
+
+    renderer.setSectionDirty(sectionPos, true)
+    expect(renderer.sectionsWaiting.get(`${columnX},64,${columnZ}`)).toBe(1)
+
+    renderer.viewDistance = 4
+    renderer.removeColumn(columnX, columnZ)
+
+    for (const key of sectionKeysForColumn(renderer, columnX, columnZ)) {
+      expect(renderer.sectionsWaiting.has(key)).toBe(false)
+    }
+  })
+
+  test('treats late sectionFinished as a no-op after removeColumn', () => {
+    const renderer = createRenderer()
+    const sectionKey = '160,64,0'
+    const debugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {})
+
+    renderer.sectionsWaiting.set(sectionKey, 1)
+    renderer.viewDistance = 4
+    renderer.removeColumn(160, 0)
+
+    expect(() => {
+      renderer.handleMessage({ type: 'sectionFinished', key: sectionKey, workerIndex: 0 })
+    }).not.toThrow()
+
+    expect(renderer.sectionsWaiting.has(sectionKey)).toBe(false)
+    expect(debugSpy).toHaveBeenCalledWith(
+      expect.stringContaining('sectionFinished for non-outstanding section'),
+    )
+
+    debugSpy.mockRestore()
+  })
+
+  test('clears sectionsWaiting when unload happens before batched dirty flush', () => {
+    const renderer = createRenderer()
+    renderer.forceCallFromMesherReplayer = false
+    const columnX = 160
+    const columnZ = 0
+
+    renderer.setSectionDirty(new Vec3(columnX, 64, columnZ), true)
+    expect(renderer.sectionsWaiting.get(`${columnX},64,${columnZ}`)).toBe(1)
+
+    renderer.viewDistance = 4
+    renderer.removeColumn(columnX, columnZ)
+    vi.advanceTimersByTime(0)
+
+    for (const key of sectionKeysForColumn(renderer, columnX, columnZ)) {
+      expect(renderer.sectionsWaiting.has(key)).toBe(false)
+    }
+  })
+})

package/src/lib/worldrendererCommon.ts

@@ -19,6 +19,7 @@ import { MesherLogReader } from './mesherlogReader'
 import { setSkinsConfig } from './utils/skins'
 import { calculateSkyLightSimple } from './skyLight'
 import { WorldViewWorker } from '../worldView'
+import { bindAbortableEmitterListener, bindAbortableListener } from './bindAbortableListener'
 import { generateSpiralMatrix } from './spiral'
 import { PlayerStateReactive } from '../playerState/playerState'
 import { IndexedData } from 'minecraft-data'
@@ -170,6 +171,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   stopMesherMessagesProcessing = false
 
   abortController = new AbortController()
+  private valtioUnsubs: Array<() => void> = []
   lastRendered = 0
   renderingActive = true
   geometryReceiveCountPerSec = 0
@@ -257,10 +259,16 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       })()
     ])
 
-    this.resourcesManager.on('assetsTexturesUpdated', async () => {
+    const onAssetsTexturesUpdated = async () => {
       if (!this.active) return
       await this.updateAssetsData()
-    })
+    }
+    bindAbortableEmitterListener(
+      this.resourcesManager,
+      'assetsTexturesUpdated',
+      onAssetsTexturesUpdated,
+      this.abortController.signal
+    )
 
     this.watchReactivePlayerState()
     this.watchReactiveConfig()
@@ -338,18 +346,24 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   }
 
   watchReactivePlayerState() {
-    this.onReactivePlayerStateUpdated('backgroundColor', (value) => {
-      this.changeBackgroundColor(value)
-    })
-    this.onReactivePlayerStateUpdated('cardinalLight', (value) => {
-      this.changeCardinalLight(value)
-    })
+    this.valtioUnsubs.push(
+      this.onReactivePlayerStateUpdated('backgroundColor', (value) => {
+        this.changeBackgroundColor(value)
+      })
+    )
+    this.valtioUnsubs.push(
+      this.onReactivePlayerStateUpdated('cardinalLight', (value) => {
+        this.changeCardinalLight(value)
+      })
+    )
   }
 
   watchReactiveConfig() {
-    this.onReactiveConfigUpdated('fetchPlayerSkins', (value) => {
-      setSkinsConfig({ apiEnabled: value })
-    })
+    this.valtioUnsubs.push(
+      this.onReactiveConfigUpdated('fetchPlayerSkins', (value) => {
+        setSkinsConfig({ apiEnabled: value })
+      })
+    )
   }
 
   async processMessageQueue(source: string) {
@@ -410,7 +424,10 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     }
     if (data.type === 'sectionFinished') { // on after load & unload section
       this.logWorkerWork(`<- ${data.workerIndex} sectionFinished ${data.key} ${JSON.stringify({ processTime: data.processTime })}`)
-      if (!this.sectionsWaiting.has(data.key)) throw new Error(`sectionFinished event for non-outstanding section ${data.key}`)
+      if (!this.sectionsWaiting.has(data.key)) {
+        console.debug(`sectionFinished for non-outstanding section ${data.key} (viewDistance=${this.viewDistance})`)
+        return
+      }
       this.sectionsWaiting.set(data.key, this.sectionsWaiting.get(data.key)! - 1)
       if (this.sectionsWaiting.get(data.key) === 0) {
         this.sectionsWaiting.delete(data.key)
@@ -432,7 +449,8 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
           // CHUNK FINISHED
           this.finishedChunks[chunkKey] = true
           const CHUNK_SIZE = 16
-          this.reactiveState.world.chunksLoaded.add(`${Math.floor(chunkCoords[0] / CHUNK_SIZE)},${Math.floor(chunkCoords[2] / CHUNK_SIZE)}`)
+          const gridKey = `${Math.floor(chunkCoords[0] / CHUNK_SIZE)},${Math.floor(chunkCoords[2] / CHUNK_SIZE)}`
+          this.reactiveState.world.chunksLoaded[gridKey] = true
           this.renderUpdateEmitter.emit(`chunkFinished`, `${chunkCoords[0]},${chunkCoords[2]}`)
           this.checkAllFinished()
           // merge highest blocks by sections into highest blocks by chunks
@@ -513,7 +531,8 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     }
 
     if (data.type === 'heightmap') {
-      this.reactiveState.world.heightmaps.set(data.key, new Int16Array(data.heightmap))
+      const heightmap = new Int16Array(data.heightmap)
+      this.reactiveState.world.heightmaps[data.key] = heightmap
     }
   }
 
@@ -684,7 +703,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
   updateChunksStats() {
     const loadedChunks = Object.keys(this.finishedChunks)
-    this.displayOptions.nonReactiveState.world.chunksLoaded = new Set(loadedChunks)
+    this.displayOptions.nonReactiveState.world.chunksLoadedCount = loadedChunks.length
     this.displayOptions.nonReactiveState.world.chunksTotalNumber = this.chunksLength
     this.reactiveState.world.allChunksLoaded = this.allChunksFinished
 
@@ -771,9 +790,11 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
         this.sectionDirtyPendingArgs.delete(key)
       }
     }
-    for (const worker of this.workers) {
-      worker.postMessage({ type: 'unloadChunk', x, z })
+    for (let i = 0; i < this.workers.length; i++) {
+      this.toWorkerMessagesQueue[i] ??= []
+      this.toWorkerMessagesQueue[i].push({ type: 'unloadChunk', x, z })
     }
+    this.dispatchMessages()
     this.logWorkerWork(`-> unloadChunk ${JSON.stringify({ x, z })}`)
     delete this.finishedChunks[`${x},${z}`]
     this.allChunksFinished = Object.keys(this.finishedChunks).length === this.chunksLength
@@ -782,12 +803,18 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       this.initialChunkLoadWasStartedIn = undefined
     }
     const sectionHeight = this.getSectionHeight()
-    for (let y = this.worldSizeParams.minY; y < this.worldSizeParams.worldHeight; y += sectionHeight) {
-      this.setSectionDirty(new Vec3(x, y, z), false)
-      delete this.finishedSections[`${x},${y},${z}`]
+    for (let y = this.worldMinYRender; y < this.worldSizeParams.worldHeight; y += sectionHeight) {
+      const sectionKey = `${x},${y},${z}`
+      const waitingCount = this.sectionsWaiting.get(sectionKey)
+      if (waitingCount !== undefined && waitingCount > 0) {
+        console.debug(`[removeColumn] clearing non-zero sectionsWaiting for ${sectionKey}: ${waitingCount} (chunk ${x},${z}, viewDistance=${this.viewDistance})`)
+      }
+      this.sectionsWaiting.delete(sectionKey)
+      delete this.finishedSections[sectionKey]
     }
     this.highestBlocksByChunks.delete(`${x},${z}`)
-    this.reactiveState.world.heightmaps.delete(`${Math.floor(x / 16)},${Math.floor(z / 16)}`)
+    const heightmapKey = `${Math.floor(x / 16)},${Math.floor(z / 16)}`
+    delete this.reactiveState.world.heightmaps[heightmapKey]
 
     this.updateChunksStats()
 
@@ -826,22 +853,23 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
   connect(worldView: WorldViewWorker) {
     const worldEmitter = worldView
+    const signal = this.abortController.signal
 
-    worldEmitter.on('entity', (e) => {
+    bindAbortableListener(worldEmitter, 'entity', (e) => {
       this.updateEntity(e, false)
-    })
-    worldEmitter.on('entityMoved', (e) => {
+    }, signal)
+    bindAbortableListener(worldEmitter, 'entityMoved', (e) => {
       this.updateEntity(e, true)
-    })
-    worldEmitter.on('playerEntity', (e) => {
+    }, signal)
+    bindAbortableListener(worldEmitter, 'playerEntity', (e) => {
       this.updatePlayerEntity?.(e)
-    })
+    }, signal)
 
     let currentLoadChunkBatch = null as {
       timeout
       data
     } | null
-    worldEmitter.on('loadChunk', ({ x, z, chunk, worldConfig, isLightUpdate }) => {
+    bindAbortableListener(worldEmitter, 'loadChunk', ({ x, z, chunk, worldConfig, isLightUpdate }) => {
       this.worldSizeParams = worldConfig
       this.queuedChunks.add(`${x},${z}`)
       const args = [x, z, chunk, isLightUpdate]
@@ -863,45 +891,44 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
         }
       }
       currentLoadChunkBatch.data.push(args)
-    })
+    }, signal)
     // todo remove and use other architecture instead so data flow is clear
-    worldEmitter.on('blockEntities', (blockEntities) => {
+    bindAbortableListener(worldEmitter, 'blockEntities', (blockEntities) => {
       this.blockEntities = blockEntities
-    })
+    }, signal)
 
-    worldEmitter.on('unloadChunk', ({ x, z }) => {
+    bindAbortableListener(worldEmitter, 'unloadChunk', ({ x, z }) => {
       this.removeColumn(x, z)
-    })
+    }, signal)
 
-    worldEmitter.on('blockUpdate', ({ pos, stateId }) => {
+    bindAbortableListener(worldEmitter, 'blockUpdate', ({ pos, stateId }) => {
       this.setBlockStateId(new Vec3(pos.x, pos.y, pos.z), stateId)
-    })
+    }, signal)
 
-    worldEmitter.on('chunkPosUpdate', ({ pos }) => {
+    bindAbortableListener(worldEmitter, 'chunkPosUpdate', ({ pos }) => {
       this.updateViewerPosition(pos)
-    })
+    }, signal)
 
-    worldEmitter.on('end', () => {
+    bindAbortableListener(worldEmitter, 'end', () => {
       this.worldStop?.()
-    })
+    }, signal)
 
-
-    worldEmitter.on('renderDistance', (d) => {
+    bindAbortableListener(worldEmitter, 'renderDistance', (d) => {
       this.viewDistance = d
       this.chunksLength = d === 0 ? 1 : generateSpiralMatrix(d).length
       this.allChunksFinished = Object.keys(this.finishedChunks).length === this.chunksLength
       this.onRenderDistanceChanged?.(d)
-    })
+    }, signal)
 
-    worldEmitter.on('markAsLoaded', ({ x, z }) => {
+    bindAbortableListener(worldEmitter, 'markAsLoaded', ({ x, z }) => {
       this.markAsLoaded(x, z)
-    })
+    }, signal)
 
-    worldEmitter.on('updateLight', ({ pos }) => {
+    bindAbortableListener(worldEmitter, 'updateLight', ({ pos }) => {
       this.lightUpdate(pos.x, pos.z)
-    })
+    }, signal)
 
-    worldEmitter.on('onWorldSwitch', () => {
+    bindAbortableListener(worldEmitter, 'onWorldSwitch', () => {
       for (const fn of this.onWorldSwitched) {
         try {
           fn()
@@ -912,9 +939,9 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
           }, 0)
         }
       }
-    })
+    }, signal)
 
-    worldEmitter.on('time', (timeOfDay) => {
+    bindAbortableListener(worldEmitter, 'time', (timeOfDay) => {
       if (!this.worldRendererConfig.dayCycle) return
       this.timeUpdated?.(timeOfDay)
 
@@ -925,15 +952,15 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       // if (this instanceof WorldRendererThree) {
       //   (this).rerenderAllChunks?.()
       // }
-    })
+    }, signal)
 
-    worldEmitter.on('biomeUpdate', ({ biome }) => {
+    bindAbortableListener(worldEmitter, 'biomeUpdate', ({ biome }) => {
       this.biomeUpdated?.(biome)
-    })
+    }, signal)
 
-    worldEmitter.on('biomeReset', () => {
+    bindAbortableListener(worldEmitter, 'biomeReset', () => {
       this.biomeReset?.()
-    })
+    }, signal)
   }
 
   setBlockStateIdInner(pos: Vec3, stateId: number | undefined, needAoRecalculation = true) {
@@ -1217,6 +1244,11 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   }
 
   destroy() {
+    for (const unsub of this.valtioUnsubs) {
+      unsub()
+    }
+    this.valtioUnsubs = []
+
     // Cancel all pending heightmap debounce timers
     for (const timer of this.heightmapDebounceTimers.values()) {
       clearTimeout(timer)

package/src/three/documentRenderer.ts

@@ -34,7 +34,7 @@ export interface NonReactiveState {
   worstRenderTime: number
   avgRenderTime: number
   world: {
-    chunksLoaded: Set<string>
+    chunksLoadedCount: number
     chunksTotalNumber: number
   }
   renderer: {

package/src/three/entities.ts

@@ -1080,6 +1080,7 @@ export class Entities {
     if (entity.delete) {
       if (!e) return
       e.userData._posTween?.stop()
+      e.userData._rotTween?.stop()
       if (e.additionalCleanup) e.additionalCleanup()
       e.traverse(c => {
         if (c['additionalCleanup']) c['additionalCleanup']()
@@ -1392,21 +1393,30 @@ export class Entities {
         })
         .start()
     }
-    if (typeof entity.yaw === 'number' && Number.isFinite(entity.yaw)) {
-      const dy = shortestYawRadians(e.rotation.y, entity.yaw)
-      new TWEEN.Tween(e.rotation).to({ y: e.rotation.y + dy }, ANIMATION_DURATION).start()
+    /** World yaw for the whole model: for PlayerObject skins, rotate body to head look dir; head mesh stays yaw-fixed (pitch only). */
+    let targetYaw: number | undefined
+    if (e.playerObject && overrides?.rotation?.head) {
+      const hy = overrides.rotation.head.y
+      const headYawWorld =
+        typeof hy === 'number' && Number.isFinite(hy) ? hy : entity.yaw
+      if (typeof headYawWorld === 'number' && Number.isFinite(headYawWorld)) {
+        targetYaw = headYawWorld
+      }
+    } else if (typeof entity.yaw === 'number' && Number.isFinite(entity.yaw)) {
+      targetYaw = entity.yaw
+    }
+    if (typeof targetYaw === 'number' && Number.isFinite(targetYaw)) {
+      const dy = shortestYawRadians(e.rotation.y, targetYaw)
+      // Stop previous rotation tween to prevent accumulation (mirror _posTween)
+      e.userData._rotTween?.stop()
+      e.userData._rotTween = new TWEEN.Tween(e.rotation)
+        .to({ y: e.rotation.y + dy }, ANIMATION_DURATION)
+        .start()
     }
 
     if (e?.playerObject && overrides?.rotation?.head) {
       const { playerObject } = e
-      const hy = overrides.rotation.head.y
-      const headYawWorld =
-        typeof hy === 'number' && Number.isFinite(hy) ? hy : entity.yaw
-      const headYawOffset =
-        typeof headYawWorld === 'number' && typeof entity.yaw === 'number' && Number.isFinite(headYawWorld) && Number.isFinite(entity.yaw)
-          ? shortestYawRadians(entity.yaw, headYawWorld)
-          : 0
-      playerObject.skin.head.rotation.y = headYawOffset
+      playerObject.skin.head.rotation.y = 0
 
       const hp = overrides.rotation.head.x
       playerObject.skin.head.rotation.x =

package/src/three/graphicsBackendBase.ts

@@ -191,25 +191,35 @@ export const createGraphicsBackendBase = () => {
   }
 
   const startWorld = async (displayOptionsArg: DisplayWorldOptions) => {
-    const displayOptionsRestorers = [ResourcesManager, WorldViewWorker]
-    const displayOptions: DisplayWorldOptions = isWebWorker ? restoreTransferred(displayOptionsArg, displayOptionsRestorers, globalThis as unknown as Worker) : displayOptionsArg
-
     if (!documentRenderer) throw new Error('Document renderer not initialized')
 
-    documentRenderer.nonReactiveState = displayOptions.nonReactiveState
-      // Set resourcesManager globally for world rendering
-      ; (globalThis as any).resourcesManager = displayOptions.resourcesManager
-
     if (menuBackgroundRenderer) {
       menuBackgroundRenderer.dispose()
       menuBackgroundRenderer = null
     }
 
+    if (worldRenderer) {
+      worldRenderer.destroy()
+      worldRenderer = null
+      frameTimingCollector = null
+      ;(globalThis as any).world = undefined
+      ;(globalThis as any).frameTimingCollector = undefined
+    }
+
+    const displayOptionsRestorers = [ResourcesManager, WorldViewWorker]
+    const displayOptions: DisplayWorldOptions = isWebWorker ? restoreTransferred(displayOptionsArg, displayOptionsRestorers, globalThis as unknown as Worker) : displayOptionsArg
+
+    documentRenderer.nonReactiveState = displayOptions.nonReactiveState
+      // Set resourcesManager globally for world rendering
+      ; (globalThis as any).resourcesManager = displayOptions.resourcesManager
+
     worldRenderer = new WorldRendererThree(documentRenderer.renderer, initOptions, displayOptions)
 
     await worldRenderer.worldReadyPromise
 
-    frameTimingCollector = new FrameTimingCollector(displayOptions.nonReactiveState)
+    frameTimingCollector = displayOptions.inWorldRenderingConfig.enableDebugOverlay
+      ? new FrameTimingCollector(displayOptions.nonReactiveState)
+      : null
       ; (globalThis as any).frameTimingCollector = frameTimingCollector
 
     const originalRender = documentRenderer.render

package/src/three/menuBackground/activeView.ts

@@ -1,7 +1,7 @@
 //@ts-nocheck
 import * as THREE from 'three'
 
-/** Contract for a main-menu background implementation (classic cubemap, futuristic scene, etc.). */
+/** Contract for a main-menu background implementation (classic cubemap, v2 scene, etc.). */
 export interface MenuBackgroundView {
   readonly scene: THREE.Scene
   readonly camera: THREE.PerspectiveCamera

package/src/three/menuBackground/config.ts

@@ -1,23 +1,23 @@
 //@ts-nocheck
 import type { MenuBackgroundMode } from './types'
-import type { FuturisticCameraId, FuturisticSceneId, MinecraftBlockGroupId } from './futuristic'
+import type { V2CameraId, V2SceneId, MinecraftBlockGroupId } from './v2'
 
 /** Single source of truth for menu-background defaults (settings + runtime fallbacks). */
 export const MENU_BACKGROUND_OPTION_DEFAULTS = {
-  mode: 'futuristic' as MenuBackgroundMode,
+  mode: 'v2' as MenuBackgroundMode,
   minecraftTextures: true as boolean,
-  futuristicScene: 'light' as FuturisticSceneId,
-  futuristicCamera: 'dive' as FuturisticCameraId,
-  futuristicBlockGroup: 'stainedGlass' as MinecraftBlockGroupId,
+  v2Scene: 'light' as V2SceneId,
+  v2Camera: 'dive' as V2CameraId,
+  v2BlockGroup: 'stainedGlass' as MinecraftBlockGroupId,
   /** 0–200 (%). 100 = 1× motion. */
-  futuristicCameraSpeedPercent: 80,
-  futuristicBlockSpeedPercent: 40
+  v2CameraSpeedPercent: 80,
+  v2BlockSpeedPercent: 40
 } as const
 
 export const menuBackgroundSpeedToMultiplier = (percent: number) => percent / 100
 
 /** Default camera / block motion multipliers (1 = 100%). */
 export const MENU_BACKGROUND_MOTION_DEFAULTS = {
-  camera: menuBackgroundSpeedToMultiplier(MENU_BACKGROUND_OPTION_DEFAULTS.futuristicCameraSpeedPercent),
-  block: menuBackgroundSpeedToMultiplier(MENU_BACKGROUND_OPTION_DEFAULTS.futuristicBlockSpeedPercent)
+  camera: menuBackgroundSpeedToMultiplier(MENU_BACKGROUND_OPTION_DEFAULTS.v2CameraSpeedPercent),
+  block: menuBackgroundSpeedToMultiplier(MENU_BACKGROUND_OPTION_DEFAULTS.v2BlockSpeedPercent)
 } as const

package/src/three/menuBackground/index.ts

@@ -6,21 +6,21 @@ export type { MenuBackgroundMode, MenuBackgroundOptions } from './types'
 export { resolveMenuBackgroundMode } from './types'
 export { ClassicMenuBackground } from './classic'
 export type {
-  FuturisticSceneId,
-  FuturisticCameraId,
-  FuturisticMenuBackgroundOptions,
+  V2SceneId,
+  V2CameraId,
+  V2MenuBackgroundOptions,
   MinecraftBlockGroupId
-} from './futuristic'
+} from './v2'
 export {
-  FuturisticMenuBackground,
-  FUTURISTIC_SCENE_IDS,
-  FUTURISTIC_CAMERA_IDS,
-  FUTURISTIC_SCENE_LABELS,
-  FUTURISTIC_CAMERA_LABELS,
+  V2MenuBackground,
+  V2_SCENE_IDS,
+  V2_CAMERA_IDS,
+  V2_SCENE_LABELS,
+  V2_CAMERA_LABELS,
   MINECRAFT_BLOCK_GROUPS,
   MINECRAFT_BLOCK_GROUP_IDS,
   MINECRAFT_BLOCK_GROUP_LABELS
-} from './futuristic'
+} from './v2'
 export { WorldBlocksMenuBackground } from './worldBlocks'
 export { MenuBackgroundRenderer } from './renderer'
 export {