minecraft-renderer 0.1.36 → 0.1.38

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)
@@ -65,7 +67,7 @@ export class WorldRendererThree extends WorldRendererCommon {
   cameraContainer!: THREE.Object3D
   media: ThreeJsMedia
   get waitingChunksToDisplay() {
-    return {} as { [chunkKey: string]: string[] }
+    return this.chunkMeshManager.waitingChunksToDisplay
   }
   waypoints: WaypointsRenderer
   cinimaticScript: CinimaticScriptRunner
@@ -79,6 +81,16 @@ export class WorldRendererThree extends WorldRendererCommon {
    */
   camera!: THREE.PerspectiveCamera
   renderTimeAvg = 0
+  private pendingSectionUpdates = new Map<string, { geometry: MesherGeometryOutput, key: string, type: string }>()
+  /**
+   * Per-section buffering timestamps for `applyPendingSectionUpdates`.
+   * Each section gets its own deadline so a continuous stream of updates
+   * (e.g. server-side block changes from explosions, pistons, fluid ticks)
+   * does not flush freshly added sections together with stale ones via a
+   * single global timer.
+   */
+  private pendingSectionBufferStartTimes = new Map<string, number>()
+  private static readonly MAX_SECTION_UPDATE_BUFFER_MS = 500
   // Memory usage tracking (in bytes)
   get estimatedMemoryUsage() {
     return this.chunkMeshManager.getEstimatedMemoryUsage().total
@@ -107,7 +119,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 +462,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 +754,108 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   finishChunk(chunkKey: string) {
-    // ChunkMeshManager applies updates immediately, no buffering needed
+    // Reveal all sections of this chunk that were held invisible by the
+    // "Batch Chunks Display" (`_renderByChunks`) option. No-op when the
+    // option is off — `waitingChunksToDisplay` is empty in that case.
+    this.chunkMeshManager.finishChunkDisplay(chunkKey)
+  }
+
+  private applyPendingSectionUpdates() {
+    if (this.pendingSectionUpdates.size === 0) return
+
+    const now = performance.now()
+    const sectionHeight = this.getSectionHeight()
+    const ready: string[] = []
+
+    for (const key of this.pendingSectionUpdates.keys()) {
+      const startedAt = this.pendingSectionBufferStartTimes.get(key) ?? now
+      const sinceFirst = now - startedAt
+
+      if (sinceFirst < WorldRendererThree.MAX_SECTION_UPDATE_BUFFER_MS) {
+        // Still within this section's grace window — wait if any neighbor is
+        // currently being re-meshed so we don't briefly expose a hole between
+        // the just-updated section and a stale neighbor (sky-flicker bug).
+        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}`,
+        ]
+        let neighborBusy = false
+        for (const neighborKey of neighborKeys) {
+          if (
+            this.sectionsWaiting.has(neighborKey) &&
+            !this.pendingSectionUpdates.has(neighborKey) &&
+            this.sectionObjects[neighborKey]
+          ) {
+            neighborBusy = true
+            break
+          }
+        }
+        if (neighborBusy) continue
+      }
+
+      ready.push(key)
+    }
+
+    if (ready.length === 0) return
+
+    for (const key of ready) {
+      const update = this.pendingSectionUpdates.get(key)!
+      this.pendingSectionUpdates.delete(key)
+      this.pendingSectionBufferStartTimes.delete(key)
+
+      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)
+        this.pendingSectionBufferStartTimes.delete(key)
+      }
+    }
   }
 
   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)
+        this.pendingSectionBufferStartTimes.delete(data.key)
+        return
+      }
+
+      if (this.sectionObjects[data.key]) {
+        this.pendingSectionUpdates.set(data.key, data)
+        // Per-section deadline: only set if we don't already have one, so
+        // repeated updates to the same section don't postpone its flush.
+        if (!this.pendingSectionBufferStartTimes.has(data.key)) {
+          this.pendingSectionBufferStartTimes.set(data.key, 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)
     }
@@ -1052,6 +1158,7 @@ export class WorldRendererThree extends WorldRendererCommon {
       chunksRenderDistanceOverride !== undefined
     ) {
       for (const [key, object] of Object.entries(this.sectionObjects)) {
+        if (object._waitingForChunkDisplay) continue
         const [x, y, z] = key.split(',').map(Number)
         const isVisible =
           // eslint-disable-next-line no-constant-binary-expression, sonarjs/no-redundant-boolean
@@ -1064,9 +1171,11 @@ export class WorldRendererThree extends WorldRendererCommon {
         object.visible = isVisible
       }
     } else {
-      for (const object of Object.values(this.sectionObjects)) {
-        object.visible = true
-      }
+      // No debug visibility override active — defer to the manager so the
+      // performance-based override distance (set by `recordRenderTime` /
+      // `autoLowerRenderDistance`) is honored, instead of force-showing every
+      // section every frame and clobbering it.
+      this.chunkMeshManager.updateSectionsVisibility()
     }
   }
 
@@ -1101,8 +1210,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 &&
@@ -1237,18 +1346,16 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   updateShowChunksBorder(value: boolean) {
-    for (const object of Object.values(this.sectionObjects)) {
-      for (const child of object.children) {
-        if (child.name === 'helper') {
-          child.visible = value
-        }
-      }
-    }
+    // Lazily create helpers on the first toggle (they are not created upfront
+    // for sections streamed in while the option was off).
+    this.chunkMeshManager.updateAllBoxHelpers(value)
   }
 
   resetWorld() {
     super.resetWorld()
 
+    this.pendingSectionUpdates.clear()
+    this.pendingSectionBufferStartTimes.clear()
     this.chunkMeshManager.dispose()
     this.chunkMeshManager = new ChunkMeshManager(this, this.scene, this.material, this.worldSizeParams.worldHeight, this.viewDistance)
 
@@ -1279,6 +1386,11 @@ export class WorldRendererThree extends WorldRendererCommon {
       textures[key].dispose()
       delete textures[key]
     }
+    // Sign / head textures moved to ChunkMeshManager.signHeadsRenderer in PR
+    // #16; without invalidating that cache here, sign edits (and any other
+    // block-entity NBT change picked up via setSectionDirty) would re-render
+    // with the stale cached canvas until a full world reset.
+    this.chunkMeshManager.cleanSignChunkTextures(x, z)
   }
 
   readdChunks() {
@@ -1303,6 +1415,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 +1446,8 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   destroy(): void {
+    this.pendingSectionUpdates.clear()
+    this.pendingSectionBufferStartTimes.clear()
     this.chunkMeshManager.dispose()
     this.disposeModules()
     this.fireworksLegacy.destroy()