minecraft-renderer 0.1.33 → 0.1.35

package/src/three/worldRendererThree.ts

@@ -13,7 +13,6 @@ import { addNewStat } from '../lib/ui/newStats'
 import { MesherGeometryOutput } from '../mesher/shared'
 import { ItemSpecificContextProperties } from '../playerState/types'
 import { setBlockPosition } from '../mesher/standaloneRenderer'
-import { getBannerTexture, createBannerMesh, releaseBannerTexture } from './bannerRenderer'
 import { getMyHand } from './hand'
 import { createHoldingBlock } from './holdingBlockFactory'
 import type { IHoldingBlock } from './holdingBlockTypes'
@@ -34,7 +33,7 @@ import { DEFAULT_TEMPERATURE, SkyboxRenderer } from './skyboxRenderer'
 import { FireworksManager } from './fireworks'
 import { SceneOrigin } from './sceneOrigin'
 import { downloadWorldGeometry } from './worldGeometryExport'
-import { WorldBlockGeometry } from './worldBlockGeometry'
+import { ChunkMeshManager } from './chunkMeshManager'
 import type { RendererModuleManifest, RegisteredModule, RendererModuleController } from './rendererModuleSystem'
 import { BUILTIN_MODULES } from './modules/index'
 
@@ -42,16 +41,17 @@ type SectionKey = string
 
 export class WorldRendererThree extends WorldRendererCommon {
   outputFormat = 'threeJs' as const
-  worldBlockGeometry: WorldBlockGeometry
+  chunkMeshManager: ChunkMeshManager
   get sectionObjects() {
-    return this.worldBlockGeometry.sectionObjects
+    return this.chunkMeshManager.sectionObjects
   }
   chunkTextures = new Map<string, { [pos: string]: THREE.Texture }>()
   signsCache = new Map<string, any>()
   cameraSectionPos: Vec3 = new Vec3(0, 0, 0)
   holdingBlock: IHoldingBlock
   holdingBlockLeft: IHoldingBlock
-  scene = new THREE.Scene()
+  realScene = new THREE.Scene()
+  scene = new THREE.Group()
   ambientLight = new THREE.AmbientLight(0xcc_cc_cc)
   directionalLight = new THREE.DirectionalLight(0xff_ff_ff, 0.5)
   entities = new Entities(this, (globalThis as any).mcData)
@@ -65,7 +65,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   cameraContainer!: THREE.Object3D
   media: ThreeJsMedia
   get waitingChunksToDisplay() {
-    return this.worldBlockGeometry.waitingChunksToDisplay
+    return {} as { [chunkKey: string]: string[] }
   }
   waypoints: WaypointsRenderer
   cinimaticScript: CinimaticScriptRunner
@@ -81,7 +81,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   renderTimeAvg = 0
   // Memory usage tracking (in bytes)
   get estimatedMemoryUsage() {
-    return this.worldBlockGeometry.estimatedMemoryUsage
+    return this.chunkMeshManager.getEstimatedMemoryUsage().total
   }
   // Module system
   private modules = {} as Record<string, RegisteredModule>
@@ -107,7 +107,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   DEBUG_RAYCAST = false
   skyboxRenderer: SkyboxRenderer
   fireworks: FireworksManager
-  sceneOrigin = new SceneOrigin(this.scene)
+  sceneOrigin = new SceneOrigin(this.realScene)
   /** Camera world position stored in float64 (JS number) for precision */
   cameraWorldPos = { x: 0, y: 0, z: 0 }
 
@@ -131,11 +131,11 @@ export class WorldRendererThree extends WorldRendererCommon {
   private readonly _tpChunkWorldPos = new THREE.Vector3()
 
   get tilesRendered() {
-    return Object.values(this.sectionObjects).reduce((acc, obj) => acc + (obj as any).tilesCount, 0)
+    return this.chunkMeshManager.getTotalTiles()
   }
 
   get blocksRendered() {
-    return Object.values(this.sectionObjects).reduce((acc, obj) => acc + (obj as any).blocksCount, 0)
+    return this.chunkMeshManager.getTotalBlocks()
   }
 
   constructor(public renderer: THREE.WebGLRenderer, public initOptions: GraphicsInitOptions, public displayOptions: DisplayWorldOptions) {
@@ -145,8 +145,11 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.renderer = renderer
     displayOptions.rendererState.renderer = WorldRendererThree.getRendererInfo(renderer) ?? '...'
 
-    // Initialize world block geometry handler
-    this.worldBlockGeometry = new WorldBlockGeometry(this, this.scene, this.material, displayOptions)
+    // Initialize chunk mesh manager
+    this.chunkMeshManager = new ChunkMeshManager(this, this.scene, this.material, this.worldSizeParams.worldHeight, this.viewDistance)
+    this.onRenderDistanceChanged = (viewDistance) => {
+      this.chunkMeshManager.updateViewDistance(viewDistance)
+    }
 
     this.cursorBlock = new CursorBlock(this)
     this.holdingBlock = createHoldingBlock(this)
@@ -158,7 +161,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
 
     // Initialize skybox renderer
-    this.skyboxRenderer = new SkyboxRenderer(this.scene, false, null)
+    this.skyboxRenderer = new SkyboxRenderer(this.realScene, false, null)
     void this.skyboxRenderer.init()
 
     this.addDebugOverlay()
@@ -181,7 +184,7 @@ export class WorldRendererThree extends WorldRendererCommon {
         fov: this.camera.fov
       })
     )
-    this.fireworks = new FireworksManager(this.scene, this.sceneOrigin)
+    this.fireworks = new FireworksManager(this.realScene, this.sceneOrigin)
 
     // this.fountain = new Fountain(this.scene, this.scene, {
     //   position: new THREE.Vector3(0, 10, 0),
@@ -447,19 +450,20 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.cameraWorldPos.y = 0
     this.cameraWorldPos.z = 0
 
-    this.scene.matrixAutoUpdate = false // for perf
-    this.scene.background = new THREE.Color(this.initOptions.config.sceneBackground)
-    this.scene.add(this.ambientLight)
+    this.realScene.matrixAutoUpdate = false // for perf
+    this.realScene.background = new THREE.Color(this.initOptions.config.sceneBackground)
+    this.realScene.add(this.ambientLight)
     this.directionalLight.position.set(1, 1, 0.5).normalize()
     this.directionalLight.castShadow = true
-    this.scene.add(this.directionalLight)
+    this.realScene.add(this.directionalLight)
 
     const size = this.renderer.getSize(new THREE.Vector2())
     this.camera = new THREE.PerspectiveCamera(75, size.x / size.y, 0.1, 1000)
     this._wrapCameraPositionWithWarning()
     this.cameraContainer = new THREE.Object3D()
     this.cameraContainer.add(this.camera)
-    this.scene.add(this.cameraContainer)
+    this.realScene.add(this.cameraContainer)
+    this.realScene.add(this.scene)
   }
 
   override watchReactivePlayerState() {
@@ -625,7 +629,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   changeBackgroundColor(color: [number, number, number]): void {
-    this.scene.background = new THREE.Color(color[0], color[1], color[2])
+    this.realScene.background = new THREE.Color(color[0], color[1], color[2])
   }
 
   timeUpdated(newTime: number): void {
@@ -662,7 +666,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     setBlockPosition(mesh, pos)
     const helper = new THREE.BoxHelper(mesh, 0xff_ff_00)
     mesh.add(helper)
-    this.scene.add(mesh)
+    this.realScene.add(mesh)
   }
 
   demoItem() {
@@ -675,7 +679,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     // mesh.scale.set(0.5, 0.5, 0.5)
     const helper = new THREE.BoxHelper(mesh, 0xff_ff_00)
     mesh.add(helper)
-    this.scene.add(mesh)
+    this.realScene.add(mesh)
   }
 
   debugOverlayAdded = false
@@ -695,7 +699,9 @@ export class WorldRendererThree extends WorldRendererCommon {
         text += `TE: ${formatBigNumber(this.renderer.info.memory.textures)} `
         text += `F: ${formatBigNumber(this.tilesRendered)} `
         text += `B: ${formatBigNumber(this.blocksRendered)} `
-        text += `MEM: ${this.worldBlockGeometry.getEstimatedMemoryUsage().readable}`
+        text += `MEM: ${this.chunkMeshManager.getEstimatedMemoryUsage().total} `
+        const poolStats = this.chunkMeshManager.getStats()
+        text += `POOL: ${poolStats.activeCount}/${poolStats.poolSize} HR: ${poolStats.hitRate}`
         pane.updateText(text)
         this.backendInfoReport = text
       }
@@ -709,7 +715,8 @@ export class WorldRendererThree extends WorldRendererCommon {
     const [x, y, z] = key.split(',').map(x => Math.floor(+x / 16))
     // sum of distances: x + y + z
     const chunkDistance = Math.abs(x - this.cameraSectionPos.x) + Math.abs(y - this.cameraSectionPos.y) + Math.abs(z - this.cameraSectionPos.z)
-    const section = this.sectionObjects[key].children.find(child => child.name === 'mesh')!
+    const sectionObj = this.sectionObjects[key]
+    const section = (sectionObj as any).mesh ?? sectionObj.children.find(child => child.name === 'mesh')!
     section.renderOrder = 500 - chunkDistance
   }
 
@@ -732,12 +739,15 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   finishChunk(chunkKey: string) {
-    this.worldBlockGeometry.finishChunk(chunkKey)
+    // ChunkMeshManager applies updates immediately, no buffering needed
   }
 
   handleWorkerMessage(data: { geometry: MesherGeometryOutput, key, type }): void {
     if (data.type === 'geometry') {
-      this.worldBlockGeometry.handleWorkerGeometryMessage(data)
+      const chunkCoords = data.key.split(',')
+      if (!this.loadedChunks[chunkCoords[0] + ',' + chunkCoords[2]] || !data.geometry.positions.length || !this.active) return
+      this.chunkMeshManager.updateSection(data.key, data.geometry)
+      this.updatePosDataChunk(data.key)
     }
   }
 
@@ -883,11 +893,11 @@ export class WorldRendererThree extends WorldRendererCommon {
   private debugRaycast(pos: THREE.Vector3, direction: THREE.Vector3, distance: number) {
     // Remove existing debug objects
     if (this.debugRaycastHelper) {
-      this.scene.remove(this.debugRaycastHelper)
+      this.realScene.remove(this.debugRaycastHelper)
       this.debugRaycastHelper = undefined
     }
     if (this.debugHitPoint) {
-      this.scene.remove(this.debugHitPoint)
+      this.realScene.remove(this.debugHitPoint)
       this.debugHitPoint = undefined
     }
 
@@ -907,14 +917,14 @@ export class WorldRendererThree extends WorldRendererCommon {
       distance * 0.1,
       distance * 0.05
     )
-    this.scene.add(this.debugRaycastHelper)
+    this.realScene.add(this.debugRaycastHelper)
 
     // Create hit point indicator
     const hitGeometry = new THREE.SphereGeometry(0.2, 8, 8)
     const hitMaterial = new THREE.MeshBasicMaterial({ color: 0x00_ff_00 })
     this.debugHitPoint = new THREE.Mesh(hitGeometry, hitMaterial)
     this.debugHitPoint.position.copy(scenePos).add(direction.clone().multiplyScalar(distance))
-    this.scene.add(this.debugHitPoint)
+    this.realScene.add(this.debugHitPoint)
   }
 
   prevFramePerspective = null as string | null
@@ -1012,11 +1022,11 @@ export class WorldRendererThree extends WorldRendererCommon {
 
         // remove any debug raycasting
         if (this.debugRaycastHelper) {
-          this.scene.remove(this.debugRaycastHelper)
+          this.realScene.remove(this.debugRaycastHelper)
           this.debugRaycastHelper = undefined
         }
         if (this.debugHitPoint) {
-          this.scene.remove(this.debugHitPoint)
+          this.realScene.remove(this.debugHitPoint)
           this.debugHitPoint = undefined
         }
       }
@@ -1087,9 +1097,8 @@ export class WorldRendererThree extends WorldRendererCommon {
 
     // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
     const cam = this.cameraGroupVr instanceof THREE.Group ? this.cameraGroupVr.children.find(child => child instanceof THREE.PerspectiveCamera) as THREE.PerspectiveCamera : this.camera
-    // Flush buffered geometry updates atomically before rendering
-    this.worldBlockGeometry.applyPendingUpdates()
-    this.renderer.render(this.scene, cam)
+    // ChunkMeshManager applies updates immediately, no pending updates to flush
+    this.renderer.render(this.realScene, cam)
 
     if (
       this.displayOptions.inWorldRenderingConfig.showHand &&
@@ -1118,6 +1127,9 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
     const end = performance.now()
     const totalTime = end - start
+    if (this.worldRendererConfig.autoLowerRenderDistance) {
+      this.chunkMeshManager.recordRenderTime(totalTime)
+    }
     this.renderTimeAvgCount++
     this.renderTimeAvg = ((this.renderTimeAvg * (this.renderTimeAvgCount - 1)) + totalTime) / this.renderTimeAvgCount
     this.renderTimeMax = Math.max(this.renderTimeMax, totalTime)
@@ -1233,15 +1245,16 @@ export class WorldRendererThree extends WorldRendererCommon {
   resetWorld() {
     super.resetWorld()
 
-    this.worldBlockGeometry.resetWorld()
+    this.chunkMeshManager.dispose()
+    this.chunkMeshManager = new ChunkMeshManager(this, this.scene, this.material, this.worldSizeParams.worldHeight, this.viewDistance)
 
     // Clean up debug objects
     if (this.debugRaycastHelper) {
-      this.scene.remove(this.debugRaycastHelper)
+      this.realScene.remove(this.debugRaycastHelper)
       this.debugRaycastHelper = undefined
     }
     if (this.debugHitPoint) {
-      this.scene.remove(this.debugHitPoint)
+      this.realScene.remove(this.debugHitPoint)
       this.debugHitPoint = undefined
     }
   }
@@ -1286,7 +1299,14 @@ export class WorldRendererThree extends WorldRendererCommon {
     super.removeColumn(x, z)
 
     this.cleanChunkTextures(x, z)
-    this.worldBlockGeometry.removeColumn(x, z)
+    const sectionHeight = this.getSectionHeight()
+    const worldMinY = this.worldMinYRender
+    for (let y = worldMinY; y < this.worldSizeParams.worldHeight; y += sectionHeight) {
+      const key = `${x},${y},${z}`
+      if (this.chunkMeshManager.sectionObjects[key]) {
+        this.chunkMeshManager.releaseSection(key)
+      }
+    }
   }
 
   setSectionDirty(...args: Parameters<WorldRendererCommon['setSectionDirty']>) {
@@ -1309,6 +1329,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   destroy(): void {
+    this.chunkMeshManager.dispose()
     this.disposeModules()
     this.fireworksLegacy.destroy()
     super.destroy()

package/src/three/worldBlockGeometry.ts

@@ -1,355 +0,0 @@
-//@ts-nocheck
-import * as THREE from 'three'
-import { Vec3 } from 'vec3'
-import nbt from 'prismarine-nbt'
-import { MesherGeometryOutput, IS_FULL_WORLD_SECTION } from '../mesher/shared'
-import { getBannerTexture, createBannerMesh, releaseBannerTexture } from './bannerRenderer'
-import type { WorldRendererThree } from './worldRendererThree'
-
-export interface SectionObject extends THREE.Object3D {
-  foutain?: boolean
-  tilesCount?: number
-  blocksCount?: number
-}
-
-export class WorldBlockGeometry {
-  sectionObjects: Record<string, SectionObject> = {}
-  waitingChunksToDisplay: { [chunkKey: string]: string[] } = {}
-  estimatedMemoryUsage = 0
-  private pendingUpdates: Map<string, { geometry: MesherGeometryOutput; key: string; type: string }> = new Map()
-  private pendingBufferStartTime: number | null = null
-  private static readonly MAX_BUFFER_MS = 500
-
-  constructor(
-    private readonly worldRenderer: WorldRendererThree,
-    private readonly scene: THREE.Scene,
-    private readonly material: THREE.MeshLambertMaterial,
-    private readonly displayOptions: any
-  ) { }
-
-  handleWorkerGeometryMessage(data: { geometry: MesherGeometryOutput; key: string; type: string }): void {
-    const isUpdate = !!this.sectionObjects[data.key]
-
-    if (isUpdate) {
-      // Buffer updates for existing sections — keep old mesh visible
-      this.pendingUpdates.set(data.key, data)
-      if (this.pendingBufferStartTime === null) {
-        this.pendingBufferStartTime = performance.now()
-      }
-      return
-    }
-
-    // Initial load — apply immediately
-    this._applySectionGeometry(data)
-  }
-
-  applyPendingUpdates(): void {
-    if (this.pendingUpdates.size === 0) return
-
-    const now = performance.now()
-    const sinceFirst = now - (this.pendingBufferStartTime ?? now)
-
-    // Wait for neighboring sections still being meshed (unless max timeout reached)
-    if (sinceFirst < WorldBlockGeometry.MAX_BUFFER_MS) {
-      const sectionHeight = this.worldRenderer.getSectionHeight()
-      for (const key of this.pendingUpdates.keys()) {
-        const [sx, sy, sz] = key.split(',').map(Number)
-        const neighborKeys = [
-          `${sx - 16},${sy},${sz}`, `${sx + 16},${sy},${sz}`,
-          `${sx},${sy - sectionHeight},${sz}`, `${sx},${sy + sectionHeight},${sz}`,
-          `${sx},${sy},${sz - 16}`, `${sx},${sy},${sz + 16}`,
-        ]
-        for (const neighborKey of neighborKeys) {
-          // Wait if neighbor is being meshed, hasn't arrived yet, and has a loaded mesh
-          if (this.worldRenderer.sectionsWaiting.has(neighborKey) &&
-              !this.pendingUpdates.has(neighborKey) &&
-              this.sectionObjects[neighborKey]) {
-            return
-          }
-        }
-      }
-    }
-
-    // Flush all pending updates atomically
-    for (const [key, data] of this.pendingUpdates) {
-      this._removeSectionSafely(key)
-      this._applySectionGeometry(data)
-    }
-
-    this.pendingUpdates.clear()
-    this.pendingBufferStartTime = null
-  }
-
-  private disposeSectionObject(obj: THREE.Object3D): void {
-    if (obj instanceof THREE.Mesh) {
-      obj.geometry?.dispose?.()
-      // Don't dispose material - it's shared across all sections
-    }
-    if (obj.children) {
-      obj.children.forEach(child => this.disposeSectionObject(child))
-    }
-  }
-
-  private _removeSectionSafely(key: string): void {
-    const object = this.sectionObjects[key]
-    if (!object) return
-
-    this.removeSectionMemoryUsage(object)
-    object.traverse((child) => {
-      if ((child as any).bannerTexture) {
-        releaseBannerTexture((child as any).bannerTexture)
-      }
-    })
-    this.worldRenderer.sceneOrigin.removeAndUntrackAll(object)
-    this.disposeSectionObject(object)
-    delete this.sectionObjects[key]
-  }
-
-  private _applySectionGeometry(data: { geometry: MesherGeometryOutput; key: string; type: string }): void {
-    const chunkCoords = data.key.split(',')
-    if (
-      !this.worldRenderer.loadedChunks[chunkCoords[0] + ',' + chunkCoords[2]] ||
-      !data.geometry.positions.length ||
-      !this.worldRenderer.active
-    )
-      return
-
-    const geometry = new THREE.BufferGeometry()
-    const positionAttr = new THREE.BufferAttribute(data.geometry.positions, 3)
-    const normalAttr = new THREE.BufferAttribute(data.geometry.normals, 3)
-    const colorAttr = new THREE.BufferAttribute(data.geometry.colors, 3)
-    const uvAttr = new THREE.BufferAttribute(data.geometry.uvs, 2)
-    const indexAttr = new THREE.BufferAttribute(data.geometry.indices as Uint32Array | Uint16Array, 1)
-
-    geometry.setAttribute('position', positionAttr)
-    geometry.setAttribute('normal', normalAttr)
-    geometry.setAttribute('color', colorAttr)
-    geometry.setAttribute('uv', uvAttr)
-    geometry.index = indexAttr
-
-    // Track memory usage for this section
-    this.addSectionMemoryUsage(geometry)
-
-    const mesh = new THREE.Mesh(geometry, this.material)
-    this.worldRenderer.sceneOrigin.track(mesh, { updateMatrix: true })
-    mesh.position.set(data.geometry.sx, data.geometry.sy, data.geometry.sz)
-    mesh.name = 'mesh'
-    const object: THREE.Object3D = new THREE.Group()
-    object.add(mesh)
-    // mesh with static dimensions: 16x16xsectionHeight
-    const sectionHeight = data.geometry.sectionEndY - data.geometry.sectionStartY
-    const CHUNK_SIZE = 16
-    const staticChunkMesh = new THREE.Mesh(
-      new THREE.BoxGeometry(CHUNK_SIZE, sectionHeight, CHUNK_SIZE),
-      new THREE.MeshBasicMaterial({ color: 0x00_00_00, transparent: true, opacity: 0 })
-    )
-    const boxHelper = new THREE.BoxHelper(staticChunkMesh, 0xff_ff_00)
-    boxHelper.name = 'helper'
-    this.worldRenderer.sceneOrigin.track(boxHelper, { updateMatrix: true })
-    boxHelper.position.set(data.geometry.sx, data.geometry.sy, data.geometry.sz)
-    object.add(boxHelper)
-    object.name = 'chunk'
-      ; (object as any).tilesCount = data.geometry.positions.length / 3 / 4
-      ; (object as any).blocksCount = data.geometry.blocksCount
-    if (!this.displayOptions.inWorldRenderingConfig.showChunkBorders) {
-      boxHelper.visible = false
-    }
-    // should not compute it once
-    if (Object.keys(data.geometry.signs).length) {
-      for (const [posKey, { isWall, isHanging, rotation }] of Object.entries(data.geometry.signs)) {
-        const signBlockEntity = this.worldRenderer.blockEntities[posKey]
-        if (!signBlockEntity) continue
-        const [x, y, z] = posKey.split(',')
-        const sign = this.worldRenderer.renderSign(
-          new Vec3(+x, +y, +z),
-          rotation,
-          isWall,
-          isHanging,
-          nbt.simplify(signBlockEntity)
-        )
-        if (!sign) continue
-        object.add(sign)
-      }
-    }
-    if (Object.keys(data.geometry.heads).length) {
-      for (const [posKey, { isWall, rotation }] of Object.entries(data.geometry.heads)) {
-        const headBlockEntity = this.worldRenderer.blockEntities[posKey]
-        if (!headBlockEntity) continue
-        const [x, y, z] = posKey.split(',')
-        const head = this.worldRenderer.renderHead(
-          new Vec3(+x, +y, +z),
-          rotation,
-          isWall,
-          nbt.simplify(headBlockEntity)
-        )
-        if (!head) continue
-        object.add(head)
-      }
-    }
-    if (Object.keys(data.geometry.banners).length) {
-      for (const [posKey, { isWall, rotation, blockName }] of Object.entries(data.geometry.banners)) {
-        const bannerBlockEntity = this.worldRenderer.blockEntities[posKey]
-        if (!bannerBlockEntity) continue
-        const [x, y, z] = posKey.split(',')
-        const bannerTexture = getBannerTexture(this.worldRenderer, blockName, nbt.simplify(bannerBlockEntity))
-        if (!bannerTexture) continue
-        const banner = createBannerMesh(new Vec3(+x, +y, +z), rotation, isWall, bannerTexture)
-        const { x: bwx, y: bwy, z: bwz } = banner.position
-        this.worldRenderer.sceneOrigin.track(banner)
-        banner.position.set(bwx, bwy, bwz)
-        object.add(banner)
-      }
-    }
-    this.sectionObjects[data.key] = object
-    // Store section key on object for easier lookup
-    ;(object as any).sectionKey = data.key
-    if (this.displayOptions.inWorldRenderingConfig._renderByChunks) {
-      object.visible = false
-      const chunkKey = `${chunkCoords[0]},${chunkCoords[2]}`
-      this.waitingChunksToDisplay[chunkKey] ??= []
-      this.waitingChunksToDisplay[chunkKey].push(data.key)
-      if (this.worldRenderer.finishedChunks[chunkKey]) {
-        // todo it might happen even when it was not an update
-        this.finishChunk(chunkKey)
-      }
-    }
-
-    this.worldRenderer.updatePosDataChunk(data.key)
-    object.matrixAutoUpdate = false
-    // Force matrix update after setting camera-relative position (matrixAutoUpdate is false)
-    object.updateMatrix()
-    mesh.onAfterRender = (renderer, scene, camera, geometry, material, group) => {
-      // mesh.matrixAutoUpdate = false
-    }
-
-    this.scene.add(object)
-  }
-
-  finishChunk(chunkKey: string) {
-    for (const sectionKey of this.waitingChunksToDisplay[chunkKey] ?? []) {
-      this.sectionObjects[sectionKey].visible = true
-    }
-    delete this.waitingChunksToDisplay[chunkKey]
-  }
-
-
-  /**
-   * Estimate memory usage of BufferGeometry attributes
-   */
-  private estimateGeometryMemoryUsage(geometry: THREE.BufferGeometry): number {
-    let memoryBytes = 0
-
-    // Calculate memory for each attribute
-    const { attributes } = geometry
-    for (const [name, attribute] of Object.entries(attributes)) {
-      if (attribute?.array) {
-        // Each number in typed arrays takes different bytes:
-        // Float32Array: 4 bytes per number
-        // Uint32Array: 4 bytes per number
-        // Uint16Array: 2 bytes per number
-        const bytesPerElement = attribute.array.BYTES_PER_ELEMENT
-        memoryBytes += attribute.array.length * bytesPerElement
-      }
-    }
-
-    // Calculate memory for indices
-    if (geometry.index?.array) {
-      const bytesPerElement = geometry.index.array.BYTES_PER_ELEMENT
-      memoryBytes += geometry.index.array.length * bytesPerElement
-    }
-
-    return memoryBytes
-  }
-
-  /**
-   * Update memory usage when section is added
-   */
-  private addSectionMemoryUsage(geometry: THREE.BufferGeometry): void {
-    const memoryUsage = this.estimateGeometryMemoryUsage(geometry)
-    this.estimatedMemoryUsage += memoryUsage
-  }
-
-  /**
-   * Update memory usage when section is removed
-   */
-  private removeSectionMemoryUsage(object: THREE.Object3D): void {
-    // Find mesh with geometry in the object
-    const mesh = object.children.find((child) => child.name === 'mesh') as THREE.Mesh
-    if (mesh?.geometry) {
-      const memoryUsage = this.estimateGeometryMemoryUsage(mesh.geometry)
-      this.estimatedMemoryUsage -= memoryUsage
-      this.estimatedMemoryUsage = Math.max(0, this.estimatedMemoryUsage) // Ensure non-negative
-    }
-  }
-
-  /**
-   * Get estimated memory usage in a human-readable format
-   */
-  getEstimatedMemoryUsage(): { bytes: number; readable: string } {
-    const bytes = this.estimatedMemoryUsage
-    const mb = bytes / (1024 * 1024)
-    const readable = `${mb.toFixed(2)} MB`
-    return { bytes, readable }
-  }
-
-  resetWorld() {
-    for (const mesh of Object.values(this.sectionObjects)) {
-      // Track memory usage removal for all sections
-      this.removeSectionMemoryUsage(mesh)
-      this.worldRenderer.sceneOrigin.removeAndUntrackAll(mesh)
-    }
-    this.sectionObjects = {}
-    this.waitingChunksToDisplay = {}
-
-    // Reset memory tracking since all sections are cleared
-    this.estimatedMemoryUsage = 0
-    this.pendingUpdates.clear()
-    this.pendingBufferStartTime = null
-  }
-
-  removeColumn(x: number, z: number) {
-    const sectionHeight = this.worldRenderer.getSectionHeight()
-    const worldMinY = this.worldRenderer.worldMinYRender
-    if (IS_FULL_WORLD_SECTION) {
-      // Only one section per chunk when full world section
-      const y = worldMinY
-      this.worldRenderer.setSectionDirty(new Vec3(x, y, z), false)
-      const key = `${x},${y},${z}`
-      const mesh = this.sectionObjects[key]
-      if (mesh) {
-        // Track memory usage removal
-        this.removeSectionMemoryUsage(mesh)
-        // Cleanup banner textures before disposing
-        mesh.traverse((child) => {
-          if ((child as any).bannerTexture) {
-            releaseBannerTexture((child as any).bannerTexture)
-          }
-        })
-        this.worldRenderer.sceneOrigin.removeAndUntrackAll(mesh)
-        this.disposeSectionObject(mesh)
-      }
-      delete this.sectionObjects[key]
-      this.pendingUpdates.delete(key)
-    } else {
-      for (let y = worldMinY; y < this.worldRenderer.worldSizeParams.worldHeight; y += sectionHeight) {
-        this.worldRenderer.setSectionDirty(new Vec3(x, y, z), false)
-        const key = `${x},${y},${z}`
-        const mesh = this.sectionObjects[key]
-        if (mesh) {
-          // Track memory usage removal
-          this.removeSectionMemoryUsage(mesh)
-          // Cleanup banner textures before disposing
-          mesh.traverse((child) => {
-            if ((child as any).bannerTexture) {
-              releaseBannerTexture((child as any).bannerTexture)
-            }
-          })
-          this.worldRenderer.sceneOrigin.removeAndUntrackAll(mesh)
-          this.disposeSectionObject(mesh)
-        }
-        delete this.sectionObjects[key]
-        this.pendingUpdates.delete(key)
-      }
-    }
-  }
-}