minecraft-renderer 0.1.36 → 0.1.37

package/package.json

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

package/src/three/chunkMeshManager.ts

@@ -64,7 +64,7 @@ export class ChunkMeshManager {
 
   constructor (
     public worldRenderer: WorldRendererThree,
-    public scene: THREE.Group,
+    public scene: THREE.Object3D,
     public material: THREE.Material,
     public worldHeight: number,
     viewDistance = 3,

package/src/three/holdingBlock.ts

@@ -1,7 +1,6 @@
 //@ts-nocheck
 import * as THREE from 'three'
 import * as tweenJs from '@tweenjs/tween.js'
-import PrismarineItem from 'prismarine-item'
 import { WorldBlockProvider } from 'mc-assets/dist/worldBlockProvider'
 import { BlockModel } from 'mc-assets'
 import { DebugGui } from '../lib/DebugGui'
@@ -17,8 +16,14 @@ import { getThreeBlockModelGroup } from '../mesher/standaloneRenderer'
 import { IndexedData } from 'minecraft-data'
 import { WorldRendererConfig } from '../graphicsBackend'
 import { computeCameraBob, type CameraBobInput } from '../lib/cameraBobbing'
+import { getFirstPersonItemSpecificProps, getHandItemRenderKey } from './holdingBlockItemIdentity'
 
 const _tempMat = new THREE.Matrix4()
+const wrapPi = (a: number) => {
+  a = (a + Math.PI) % (Math.PI * 2)
+  if (a < 0) a += Math.PI * 2
+  return a - Math.PI
+}
 
 // Vanilla renderPlayerArm transform chain
 function buildBareHandMatrix(swingProgress: number, equipProgress: number): THREE.Matrix4 {
@@ -94,6 +99,7 @@ export default class HoldingBlock implements IHoldingBlock {
   equipProgress = 0 // 0 = fully visible, 1 = hidden
   stopUpdate = false
   lastHeldItem: HandItemBlock | undefined
+  lastHeldItemRenderKey: string | undefined
   currentDisplayType: 'hand' | 'item' | 'block' = 'hand'
   isSwinging = false
   nextIterStopCallbacks: Array<() => void> | undefined
@@ -116,6 +122,7 @@ export default class HoldingBlock implements IHoldingBlock {
 
   constructor(public worldRenderer: WorldRendererThree, public offHand = false) {
     this.initCameraGroup()
+    this.swingAnimator = new HandSwingAnimator()
     this.unsubs.push(
       this.worldRenderer.onReactivePlayerStateUpdated('heldItemMain', () => {
         if (!this.offHand) {
@@ -332,44 +339,32 @@ export default class HoldingBlock implements IHoldingBlock {
   }
 
   isDifferentItem(block: HandItemBlock | undefined) {
-    const Item = PrismarineItem(this.worldRenderer.version)
-    if (!this.lastHeldItem) {
-      return true
-    }
-    if (this.lastHeldItem.name !== block?.name) {
-      return true
-    }
-    // eslint-disable-next-line sonarjs/prefer-single-boolean-return
-    if (!Item.equal(this.lastHeldItem.fullItem, block?.fullItem ?? {}) || JSON.stringify(this.lastHeldItem.fullItem.components) !== JSON.stringify(block?.fullItem?.components)) {
-      return true
-    }
-
-    return false
+    return this.lastHeldItemRenderKey !== getHandItemRenderKey(this.worldRenderer, block)
   }
 
   updateCameraGroup() {
     if (this.stopUpdate) return
     const { camera } = this
 
-    // Hand rotation momentum (xBob/yBob) — vanilla Minecraft inertia effect
-    // Use base rotation from CameraShake (actual player view angles)
     const now = performance.now()
     const baseRotation = this.worldRenderer.cameraShake.getBaseRotation()
     const actualPitch = baseRotation.pitch
     const actualYaw = baseRotation.yaw
+
     if (this.lastBobUpdateTime === 0) {
       this.xBob = actualPitch
       this.yBob = actualYaw
-      this.lastBobUpdateTime = now
     } else {
       const dt = Math.min((now - this.lastBobUpdateTime) / 1000, 0.1)
-      this.lastBobUpdateTime = now
-      const factor = 1 - Math.pow(0.5, dt * 20)
-      this.xBob += (actualPitch - this.xBob) * factor
-      this.yBob += (actualYaw - this.yBob) * factor
+      const pitchFactor = 1 - Math.pow(0.5, dt * 28)
+      const yawFactor = 1 - Math.pow(0.5, dt * 36)
+      this.xBob += (actualPitch - this.xBob) * pitchFactor
+      this.yBob += wrapPi(actualYaw - this.yBob) * yawFactor
     }
-    const pitchOffset = (actualPitch - this.xBob) * -0.1
-    const yawOffset = (actualYaw - this.yBob) * -0.1
+
+    this.lastBobUpdateTime = now
+    const pitchOffset = (actualPitch - this.xBob) * -0.05
+    const yawOffset = wrapPi(actualYaw - this.yBob) * -0.035
 
     this.cameraGroup.position.copy(camera.position)
     this.cameraGroup.rotation.copy(camera.rotation)
@@ -431,11 +426,7 @@ export default class HoldingBlock implements IHoldingBlock {
       const result = this.worldRenderer.entities.getItemMesh({
         ...handItem.fullItem,
         itemId: handItem.id,
-      }, {
-        'minecraft:display_context': 'firstperson',
-        'minecraft:use_duration': this.worldRenderer.playerStateReactive.itemUsageTicks,
-        'minecraft:using_item': !!this.worldRenderer.playerStateReactive.itemUsageTicks,
-      }, false, this.lastItemModelName)
+      }, getFirstPersonItemSpecificProps(this.worldRenderer), false, this.lastItemModelName)
       if (result) {
         const { mesh: itemMesh, isBlock, modelName } = result
         if (isBlock) {
@@ -487,8 +478,11 @@ export default class HoldingBlock implements IHoldingBlock {
       this.holdingBlock?.removeFromParent()
       this.holdingBlock = undefined
       this.currentDisplayType = 'hand'
-      this.swingAnimator?.stopSwing()
-      this.swingAnimator = undefined
+      const swingAnimator = this.swingAnimator
+      swingAnimator?.stopSwing()
+      if (swingAnimator) {
+        swingAnimator.type = 'hand'
+      }
       this.idleAnimator = undefined
       return
     }
@@ -516,10 +510,14 @@ export default class HoldingBlock implements IHoldingBlock {
 
   switchRequest = 0
   async setNewItem(handItem?: HandItemBlock) {
-    if (!this.isDifferentItem(handItem)) return
+    const nextRenderKey = getHandItemRenderKey(this.worldRenderer, handItem)
+    const itemChanged = this.lastHeldItemRenderKey !== nextRenderKey
+    this.lastHeldItem = handItem
+    if (!itemChanged) return
+
+    this.lastHeldItemRenderKey = nextRenderKey
     this.lastItemModelName = undefined
     const switchRequest = ++this.switchRequest
-    this.lastHeldItem = handItem
 
     let playAppearAnimation = false
     if (this.holdingBlock) {
@@ -535,7 +533,11 @@ export default class HoldingBlock implements IHoldingBlock {
 
     if (!handItem) {
       this.currentDisplayType = 'hand'
-      this.swingAnimator = undefined
+      const swingAnimator = this.swingAnimator
+      swingAnimator?.stopSwing()
+      if (swingAnimator) {
+        swingAnimator.type = 'hand'
+      }
       this.idleAnimator = undefined
       this.blockSwapAnimation = undefined
       return
@@ -553,8 +555,10 @@ export default class HoldingBlock implements IHoldingBlock {
       await this.playBlockSwapAnimation('appeared')
     }
 
-    this.swingAnimator = new HandSwingAnimator()
-    this.swingAnimator.type = result.type
+    const swingAnimator = this.swingAnimator
+    if (swingAnimator) {
+      swingAnimator.type = result.type
+    }
     // Idle animation disabled — walking bob is handled by vanilla bobView applied to cameraGroup
     this.idleAnimator = undefined
   }

package/src/three/holdingBlockItemIdentity.test.ts

@@ -0,0 +1,43 @@
+//@ts-nocheck
+import { expect, test, vi } from 'vitest'
+import { getHandItemRenderKey } from './holdingBlockItemIdentity'
+
+test('hand item render key ignores live use state but keeps first-person display context', () => {
+  const getItemRenderData = vi.fn(() => ({ modelName: 'item/bow' }))
+  const worldRenderer = {
+    playerStateReactive: {
+      itemUsageTicks: 20,
+    },
+    resourcesManager: {
+      currentResources: {},
+    },
+    getItemRenderData,
+  } as any
+
+  const handItem = {
+    type: 'item',
+    id: 261,
+    name: 'minecraft:bow',
+    fullItem: {
+      count: 1,
+    },
+  } as const
+
+  const activeKey = getHandItemRenderKey(worldRenderer, handItem)
+  worldRenderer.playerStateReactive.itemUsageTicks = 0
+  const idleKey = getHandItemRenderKey(worldRenderer, handItem)
+
+  expect(activeKey).toBe(idleKey)
+  expect(getItemRenderData).toHaveBeenNthCalledWith(1, {
+    ...handItem.fullItem,
+    itemId: handItem.id,
+  }, {
+    'minecraft:display_context': 'firstperson',
+  })
+  expect(getItemRenderData).toHaveBeenNthCalledWith(2, {
+    ...handItem.fullItem,
+    itemId: handItem.id,
+  }, {
+    'minecraft:display_context': 'firstperson',
+  })
+})

package/src/three/holdingBlockItemIdentity.ts

@@ -0,0 +1,30 @@
+//@ts-nocheck
+import type { HandItemBlock, ItemSpecificContextProperties } from '../playerState/types'
+import type { WorldRendererThree } from './worldRendererThree'
+
+export const getFirstPersonItemSpecificProps = (worldRenderer: WorldRendererThree): ItemSpecificContextProperties => ({
+  'minecraft:display_context': 'firstperson',
+  'minecraft:use_duration': worldRenderer.playerStateReactive.itemUsageTicks,
+  'minecraft:using_item': !!worldRenderer.playerStateReactive.itemUsageTicks,
+})
+
+const getFirstPersonItemIdentityProps = (): ItemSpecificContextProperties => ({
+  'minecraft:display_context': 'firstperson',
+})
+
+export const getHandItemRenderKey = (worldRenderer: WorldRendererThree, handItem?: HandItemBlock) => {
+  if (!handItem) return 'empty'
+  if (handItem.type === 'hand') return 'hand'
+
+  const itemIdentifier = handItem.name ?? (handItem.id !== undefined ? `#${handItem.id}` : 'unknown')
+  if (!worldRenderer.resourcesManager.currentResources) {
+    return `${handItem.type}:${itemIdentifier}`
+  }
+
+  const renderData = worldRenderer.getItemRenderData({
+    ...handItem.fullItem,
+    itemId: handItem.id,
+  }, getFirstPersonItemIdentityProps())
+
+  return `${handItem.type}:${itemIdentifier}:${renderData.modelName}`
+}

package/src/three/holdingBlockLegacy.ts

@@ -1,7 +1,6 @@
 //@ts-nocheck
 import * as THREE from 'three'
 import * as tweenJs from '@tweenjs/tween.js'
-import PrismarineItem from 'prismarine-item'
 import { WorldBlockProvider } from 'mc-assets/dist/worldBlockProvider'
 import { BlockModel } from 'mc-assets'
 import { DebugGui } from '../lib/DebugGui'
@@ -17,6 +16,7 @@ import { getThreeBlockModelGroup } from '../mesher/standaloneRenderer'
 import { IndexedData } from 'minecraft-data'
 import { WorldRendererConfig } from '../graphicsBackend'
 import { IHoldingBlock } from './holdingBlockTypes'
+import { getFirstPersonItemSpecificProps, getHandItemRenderKey } from './holdingBlockItemIdentity'
 
 const rotationPositionData = {
   itemRight: {
@@ -103,6 +103,7 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
   camera = new THREE.PerspectiveCamera(75, 1, 0.1, 100)
   stopUpdate = false
   lastHeldItem: HandItemBlock | undefined
+  lastHeldItemRenderKey: string | undefined
   isSwinging = false
   nextIterStopCallbacks: Array<() => void> | undefined
   idleAnimator: HandIdleAnimator | undefined
@@ -304,19 +305,7 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
   }
 
   isDifferentItem(block: HandItemBlock | undefined) {
-    const Item = PrismarineItem(this.worldRenderer.version)
-    if (!this.lastHeldItem) {
-      return true
-    }
-    if (this.lastHeldItem.name !== block?.name) {
-      return true
-    }
-    // eslint-disable-next-line sonarjs/prefer-single-boolean-return
-    if (!Item.equal(this.lastHeldItem.fullItem, block?.fullItem ?? {}) || JSON.stringify(this.lastHeldItem.fullItem.components) !== JSON.stringify(block?.fullItem?.components)) {
-      return true
-    }
-
-    return false
+    return this.lastHeldItemRenderKey !== getHandItemRenderKey(this.worldRenderer, block)
   }
 
   updateCameraGroup() {
@@ -355,11 +344,7 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
       const result = this.worldRenderer.entities.getItemMesh({
         ...handItem.fullItem,
         itemId: handItem.id,
-      }, {
-        'minecraft:display_context': 'firstperson',
-        'minecraft:use_duration': this.worldRenderer.playerStateReactive.itemUsageTicks,
-        'minecraft:using_item': !!this.worldRenderer.playerStateReactive.itemUsageTicks,
-      }, false, this.lastItemModelName)
+      }, getFirstPersonItemSpecificProps(this.worldRenderer), false, this.lastItemModelName)
       if (result) {
         const { mesh: itemMesh, isBlock, modelName } = result
         if (isBlock) {
@@ -421,10 +406,14 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
 
   switchRequest = 0
   async setNewItem(handItem?: HandItemBlock) {
-    if (!this.isDifferentItem(handItem)) return
+    const nextRenderKey = getHandItemRenderKey(this.worldRenderer, handItem)
+    const itemChanged = this.lastHeldItemRenderKey !== nextRenderKey
+    this.lastHeldItem = handItem
+    if (!itemChanged) return
+
+    this.lastHeldItemRenderKey = nextRenderKey
     this.lastItemModelName = undefined
     const switchRequest = ++this.switchRequest
-    this.lastHeldItem = handItem
     let playAppearAnimation = false
     if (this.holdingBlock) {
       // play disappear animation
@@ -472,7 +461,8 @@ export default class HoldingBlockLegacy implements IHoldingBlock {
       await this.playBlockSwapAnimation('appeared')
     }
 
-    this.swingAnimator = new HandSwingAnimator(this.holdingBlockInnerGroup)
+    this.swingAnimator ??= new HandSwingAnimator(this.holdingBlockInnerGroup)
+    this.swingAnimator.setHandMesh(this.holdingBlockInnerGroup)
     this.swingAnimator.type = result.type
     if (this.config.viewBobbing) {
       this.idleAnimator = new HandIdleAnimator(this.holdingBlockInnerGroup, this.worldRenderer.playerStateReactive)
@@ -783,9 +773,9 @@ class HandSwingAnimator {
   private lastTime = 0
   private isAnimating = false
   private stopRequested = false
-  private readonly originalRotation: THREE.Euler
-  private readonly originalPosition: THREE.Vector3
-  private readonly originalScale: THREE.Vector3
+  private originalRotation: THREE.Euler
+  private originalPosition: THREE.Vector3
+  private originalScale: THREE.Vector3
 
   readonly debugParams = {
     // Animation timing
@@ -849,6 +839,13 @@ class HandSwingAnimator {
     // this.debugGui.activate()
   }
 
+  setHandMesh(handMesh: THREE.Object3D) {
+    this.handMesh = handMesh
+    this.originalRotation.copy(handMesh.rotation)
+    this.originalPosition.copy(handMesh.position)
+    this.originalScale.copy(handMesh.scale)
+  }
+
   update() {
     if (!this.isAnimating && !this.debugParams.animationStage) {
       // If not animating, ensure we're at original position

package/src/three/modules/sciFiWorldReveal.ts

@@ -58,7 +58,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
   // Store original methods for patching
   private originalFinishChunk: ((chunkKey: string) => void) | null = null
   private originalDestroy: (() => void) | null = null
-  private originalSceneAdd: ((...object: THREE.Object3D[]) => THREE.Group) | null = null
+  private originalSceneAdd: ((...object: THREE.Object3D[]) => THREE.Scene) | null = null
   private originalHandleWorkerMessage: ((data: { geometry: MesherGeometryOutput; key: string; type: string }) => void) | null = null
 
   private configEnabled = true
@@ -163,7 +163,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
 
     // Patch scene.add to intercept mesh additions
     this.originalSceneAdd = wr.scene.add.bind(wr.scene)
-    wr.scene.add = (...objects: THREE.Object3D[]): THREE.Group => {
+    wr.scene.add = (...objects: THREE.Object3D[]): THREE.Scene => {
       // Call original add first
       const result = this.originalSceneAdd!(...objects)
 

package/src/three/sceneOrigin.ts

@@ -174,7 +174,7 @@ export class SceneOrigin {
   /** Untrack an Object3D and remove it from the scene */
   removeAndUntrack(obj: Object3D): void {
     this.untrack(obj)
-    this.scene.remove(obj)
+    obj.removeFromParent()
   }
 
   /** Untrack an Object3D and all its descendants, then remove from the scene */
@@ -182,7 +182,7 @@ export class SceneOrigin {
     obj.traverse((child) => {
       this.untrack(child)
     })
-    this.scene.remove(obj)
+    obj.removeFromParent()
   }
 
   /** Get stored world position for a tracked object */

package/src/three/worldRendererThree.ts

@@ -50,8 +50,10 @@ export class WorldRendererThree extends WorldRendererCommon {
   cameraSectionPos: Vec3 = new Vec3(0, 0, 0)
   holdingBlock: IHoldingBlock
   holdingBlockLeft: IHoldingBlock
-  realScene = new THREE.Scene()
-  scene = new THREE.Group()
+  scene = new THREE.Scene()
+  get realScene() {
+    return this.scene
+  }
   ambientLight = new THREE.AmbientLight(0xcc_cc_cc)
   directionalLight = new THREE.DirectionalLight(0xff_ff_ff, 0.5)
   entities = new Entities(this, (globalThis as any).mcData)
@@ -79,6 +81,9 @@ export class WorldRendererThree extends WorldRendererCommon {
    */
   camera!: THREE.PerspectiveCamera
   renderTimeAvg = 0
+  private pendingSectionUpdates = new Map<string, { geometry: MesherGeometryOutput, key: string, type: string }>()
+  private pendingSectionBufferStartTime: number | null = null
+  private static readonly MAX_SECTION_UPDATE_BUFFER_MS = 500
   // Memory usage tracking (in bytes)
   get estimatedMemoryUsage() {
     return this.chunkMeshManager.getEstimatedMemoryUsage().total
@@ -107,7 +112,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   DEBUG_RAYCAST = false
   skyboxRenderer: SkyboxRenderer
   fireworks: FireworksManager
-  sceneOrigin = new SceneOrigin(this.realScene)
+  sceneOrigin = new SceneOrigin(this.scene)
   /** Camera world position stored in float64 (JS number) for precision */
   cameraWorldPos = { x: 0, y: 0, z: 0 }
 
@@ -450,20 +455,19 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.cameraWorldPos.y = 0
     this.cameraWorldPos.z = 0
 
-    this.realScene.matrixAutoUpdate = false // for perf
-    this.realScene.background = new THREE.Color(this.initOptions.config.sceneBackground)
-    this.realScene.add(this.ambientLight)
+    this.scene.matrixAutoUpdate = false // for perf
+    this.scene.background = new THREE.Color(this.initOptions.config.sceneBackground)
+    this.scene.add(this.ambientLight)
     this.directionalLight.position.set(1, 1, 0.5).normalize()
     this.directionalLight.castShadow = true
-    this.realScene.add(this.directionalLight)
+    this.scene.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.realScene.add(this.cameraContainer)
-    this.realScene.add(this.scene)
+    this.scene.add(this.cameraContainer)
   }
 
   override watchReactivePlayerState() {
@@ -743,13 +747,94 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   finishChunk(chunkKey: string) {
-    // ChunkMeshManager applies updates immediately, no buffering needed
+    // Existing sections are buffered and flushed from applyPendingSectionUpdates().
+  }
+
+  private applyPendingSectionUpdates() {
+    if (this.pendingSectionUpdates.size === 0) return
+
+    const now = performance.now()
+    const sinceFirst = now - (this.pendingSectionBufferStartTime ?? now)
+
+    if (sinceFirst < WorldRendererThree.MAX_SECTION_UPDATE_BUFFER_MS) {
+      const sectionHeight = this.getSectionHeight()
+      for (const key of this.pendingSectionUpdates.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) {
+          if (
+            this.sectionsWaiting.has(neighborKey) &&
+            !this.pendingSectionUpdates.has(neighborKey) &&
+            this.sectionObjects[neighborKey]
+          ) {
+            return
+          }
+        }
+      }
+    }
+
+    const updates = [...this.pendingSectionUpdates.values()]
+    this.pendingSectionUpdates.clear()
+    this.pendingSectionBufferStartTime = null
+
+    for (const update of updates) {
+      const chunkCoords = update.key.split(',')
+      const chunkKey = `${chunkCoords[0]},${chunkCoords[2]}`
+
+      if (!this.loadedChunks[chunkKey] || !this.active) {
+        this.chunkMeshManager.releaseSection(update.key)
+        continue
+      }
+
+      if (!update.geometry.positions.length) {
+        this.chunkMeshManager.releaseSection(update.key)
+        continue
+      }
+
+      this.chunkMeshManager.updateSection(update.key, update.geometry)
+      this.updatePosDataChunk(update.key)
+    }
+  }
+
+  private clearPendingSectionUpdatesForChunk(x: number, z: number) {
+    for (const key of [...this.pendingSectionUpdates.keys()]) {
+      if (key.startsWith(`${x},`) && key.endsWith(`,${z}`)) {
+        this.pendingSectionUpdates.delete(key)
+      }
+    }
+
+    if (this.pendingSectionUpdates.size === 0) {
+      this.pendingSectionBufferStartTime = null
+    }
   }
 
   handleWorkerMessage(data: { geometry: MesherGeometryOutput, key, type }): void {
     if (data.type === 'geometry') {
       const chunkCoords = data.key.split(',')
-      if (!this.loadedChunks[chunkCoords[0] + ',' + chunkCoords[2]] || !data.geometry.positions.length || !this.active) return
+      const chunkKey = `${chunkCoords[0]},${chunkCoords[2]}`
+      if (!this.loadedChunks[chunkKey] || !this.active) {
+        this.pendingSectionUpdates.delete(data.key)
+        if (this.pendingSectionUpdates.size === 0) {
+          this.pendingSectionBufferStartTime = null
+        }
+        return
+      }
+
+      if (this.sectionObjects[data.key]) {
+        this.pendingSectionUpdates.set(data.key, data)
+        this.pendingSectionBufferStartTime ??= performance.now()
+        return
+      }
+
+      if (!data.geometry.positions.length) {
+        this.chunkMeshManager.releaseSection(data.key)
+        return
+      }
       this.chunkMeshManager.updateSection(data.key, data.geometry)
       this.updatePosDataChunk(data.key)
     }
@@ -1101,8 +1186,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
-    // ChunkMeshManager applies updates immediately, no pending updates to flush
-    this.renderer.render(this.realScene, cam)
+    this.applyPendingSectionUpdates()
+    this.renderer.render(this.scene, cam)
 
     if (
       this.displayOptions.inWorldRenderingConfig.showHand &&
@@ -1249,6 +1334,8 @@ export class WorldRendererThree extends WorldRendererCommon {
   resetWorld() {
     super.resetWorld()
 
+    this.pendingSectionUpdates.clear()
+    this.pendingSectionBufferStartTime = null
     this.chunkMeshManager.dispose()
     this.chunkMeshManager = new ChunkMeshManager(this, this.scene, this.material, this.worldSizeParams.worldHeight, this.viewDistance)
 
@@ -1303,6 +1390,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     super.removeColumn(x, z)
 
     this.cleanChunkTextures(x, z)
+    this.clearPendingSectionUpdatesForChunk(x, z)
     const sectionHeight = this.getSectionHeight()
     const worldMinY = this.worldMinYRender
     for (let y = worldMinY; y < this.worldSizeParams.worldHeight; y += sectionHeight) {
@@ -1333,6 +1421,8 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   destroy(): void {
+    this.pendingSectionUpdates.clear()
+    this.pendingSectionBufferStartTime = null
     this.chunkMeshManager.dispose()
     this.disposeModules()
     this.fireworksLegacy.destroy()