minecraft-renderer 0.1.90 → 0.1.92

package/src/three/tests/chunkMeshManagerLegacy.test.ts

@@ -243,13 +243,13 @@ test('ChunkMeshManager: hidden section excluded from draw spans', () => {
   camera.lookAt(8, 8, 8)
   camera.updateMatrixWorld()
 
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(manager.globalLegacyBlendBuffer?.getVisibleIndexSpans().length).toBe(0)
 
   section.visible = true
   const blendBuf = manager.globalLegacyBlendBuffer!
   while (blendBuf.hasPendingUploads()) blendBuf.uploadDirtyRange()
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(manager.globalLegacyBlendBuffer?.getVisibleIndexSpans().length).toBeGreaterThan(0)
 
   manager.cleanupSection(key)
@@ -323,15 +323,15 @@ test('ChunkMeshManager: hidden cube section excluded from draw spans', () => {
   drainCubeUploads(manager)
 
   const camera = makeCullCamera()
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBeGreaterThan(0)
 
   section.visible = false
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBe(0)
 
   section.visible = true
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBeGreaterThan(0)
 
   manager.cleanupSection(key)
@@ -346,7 +346,7 @@ test('ChunkMeshManager: finishChunkDisplay reveals cube spans and marks cull dir
   expect(manager.globalBlockBuffer?.hasSection(key)).toBe(true)
 
   const camera = makeCullCamera()
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBe(0)
 
   const markCullDirtySpy = vi.spyOn(manager, 'markCullDirty')
@@ -355,7 +355,7 @@ test('ChunkMeshManager: finishChunkDisplay reveals cube spans and marks cull dir
   expect(markCullDirtySpy).toHaveBeenCalled()
 
   drainCubeUploads(manager)
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(manager.globalBlockBuffer?.getVisibleSpans().length).toBeGreaterThan(0)
 
   markCullDirtySpy.mockRestore()

package/src/three/tests/positionalAudioAttenuation.test.ts

@@ -0,0 +1,51 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import { computeEffectiveVolume, computeIndividualGain, computePositionalAudioParams, DEFAULT_ATTENUATION_DISTANCE } from '../positionalAudioAttenuation'
+
+describe('computeEffectiveVolume', () => {
+  it('multiplies entry volume by non-negative packet volume', () => {
+    expect(computeEffectiveVolume(1, 1)).toBe(1)
+    expect(computeEffectiveVolume(12, 2)).toBe(24)
+    expect(computeEffectiveVolume(1, 0.5)).toBe(0.5)
+  })
+
+  it('does not clamp packet volume above 1', () => {
+    expect(computeEffectiveVolume(1, 2)).toBe(2)
+    expect(computeEffectiveVolume(12, 2)).toBe(24)
+  })
+
+  it('treats negative packet volume as zero', () => {
+    expect(computeEffectiveVolume(1, -1)).toBe(0)
+  })
+})
+
+describe('computePositionalAudioParams', () => {
+  it('uses default attenuation distance semantics', () => {
+    expect(computePositionalAudioParams(1, DEFAULT_ATTENUATION_DISTANCE)).toEqual({
+      individualGain: 1,
+      maxDistance: 16
+    })
+  })
+
+  it('clamps individual gain to [0, 1] while extending range for volume > 1', () => {
+    expect(computePositionalAudioParams(24, 16)).toEqual({
+      individualGain: 1,
+      maxDistance: 384
+    })
+  })
+
+  it('keeps individual gain independent of master volume', () => {
+    expect(computeIndividualGain(1)).toBe(1)
+    expect(computeIndividualGain(2)).toBe(1)
+    expect(computeIndividualGain(0.5)).toBe(0.5)
+  })
+
+  it('matches vanilla linear falloff checkpoints at distance 0/8/16', () => {
+    const { individualGain, maxDistance } = computePositionalAudioParams(1, 16)
+    const linearMultiplier = (distance: number) => 1 - distance / maxDistance
+    expect(individualGain * linearMultiplier(0)).toBe(1)
+    expect(individualGain * linearMultiplier(8)).toBe(0.5)
+    expect(individualGain * linearMultiplier(16)).toBe(0)
+    expect(individualGain * linearMultiplier(24)).toBeLessThanOrEqual(0)
+  })
+})

package/src/three/tests/pr3PerFrameCpuCuts.test.ts

@@ -217,16 +217,16 @@ test('updateSectionCullAndSort: same visible set skips span rebuild on camera mo
   const updateDrawSpansSpy = vi.spyOn(blendBuffer, 'updateDrawSpans')
 
   const camera1 = makeCamera(8, 8, 20)
-  manager.updateSectionCullAndSort(camera1, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera1, 8, 8, 20, false)
   expect(updateDrawSpansSpy).toHaveBeenCalledTimes(1)
 
   while (blendBuffer.hasPendingUploads()) blendBuffer.uploadDirtyRange()
 
-  manager.updateSectionCullAndSort(camera1, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera1, 8, 8, 20, false)
   expect(updateDrawSpansSpy).toHaveBeenCalledTimes(2)
 
   const camera2 = makeCamera(8, 8, 18)
-  manager.updateSectionCullAndSort(camera2, 8, 8, 18)
+  manager.updateSectionCullAndSort(camera2, 8, 8, 18, false)
   expect(updateDrawSpansSpy).toHaveBeenCalledTimes(2)
 
   manager.cleanupSection(key)
@@ -242,14 +242,14 @@ test('updateSectionCullAndSort: layoutVersion change forces span rebuild', () =>
   const updateDrawSpansSpy = vi.spyOn(blendBuffer, 'updateDrawSpans')
 
   const camera = makeCamera(8, 8, 20)
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(updateDrawSpansSpy).toHaveBeenCalledTimes(1)
 
   blendBuffer.removeSection(key)
   blendBuffer.addSection(key, makeBlendOnlyGeometry().blend!, 8, 8, 8)
   ;(manager as unknown as ManagerInternals).registerLegacyCullSection(key, 8, 8, 8)
 
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(updateDrawSpansSpy).toHaveBeenCalledTimes(2)
 
   manager.cleanupSection(key)
@@ -268,7 +268,7 @@ function simulateRenderCullGate(manager: ChunkMeshManager, camera: THREE.Perspec
   }
   manager.markCullDirtyIfBufferStateChanged()
   if (manager.cullDirty) {
-    manager.updateSectionCullAndSort(camera, x, y, z)
+    manager.updateSectionCullAndSort(camera, x, y, z, false)
     manager.clearCullDirty()
   }
 }
@@ -282,7 +282,7 @@ test('markCullDirtyIfBufferStateChanged: finalize layout bump marks cull dirty',
   drainLegacyUploads(opaqueBuf)
 
   const camera = makeCamera(8, 8, 20)
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   manager.clearCullDirty()
 
   opaqueBuf.addSection(
@@ -353,7 +353,7 @@ test('updateSectionCullAndSort: defrag finalize forces span rebuild with static
   const updateDrawSpansSpy = vi.spyOn(opaqueBuf, 'updateDrawSpans')
   const camera = makeCamera(8, 8, 20)
 
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(updateDrawSpansSpy).toHaveBeenCalledTimes(1)
 
   opaqueBuf.removeSection('1,0,0')
@@ -362,7 +362,7 @@ test('updateSectionCullAndSort: defrag finalize forces span rebuild with static
   drainLegacyUploads(opaqueBuf)
   opaqueBuf.compactStep()
 
-  manager.updateSectionCullAndSort(camera, 8, 8, 20)
+  manager.updateSectionCullAndSort(camera, 8, 8, 20, false)
   expect(updateDrawSpansSpy).toHaveBeenCalledTimes(2)
 
   for (const key of keys) manager.cleanupSection(key)

package/src/three/tests/sectionOcclusionCull.test.ts

@@ -0,0 +1,51 @@
+//@ts-nocheck
+import { test, expect } from 'vitest'
+import { SectionOcclusionCull } from '../occlusion/sectionOcclusionCull'
+import { computeSectionVisibilitySet } from '../../mesher-shared/visGraph'
+
+const ALL_OPEN = computeSectionVisibilitySet(16, () => false)
+
+test('isSectionVisible fails open for unregistered sections', () => {
+  const cull = new SectionOcclusionCull()
+  cull.registerSection('0,0,0', ALL_OPEN, 8, 8, 8)
+  cull.update({
+    smartCull: true,
+    cameraWorldX: 8,
+    cameraWorldY: 8,
+    cameraWorldZ: 8,
+    viewDistance: 4,
+    sectionHeight: 16,
+    worldMinY: 0,
+    worldMaxY: 256
+  })
+  expect(cull.isSectionVisible('64,0,64')).toBe(true)
+})
+
+test('notifySmartCullChanged invalidates graph', () => {
+  const cull = new SectionOcclusionCull()
+  cull.registerSection('0,0,0', ALL_OPEN, 8, 8, 8)
+  cull.update({
+    smartCull: false,
+    cameraWorldX: 8,
+    cameraWorldY: 8,
+    cameraWorldZ: 8,
+    viewDistance: 4,
+    sectionHeight: 16,
+    worldMinY: 0,
+    worldMaxY: 256
+  })
+  const offVisible = cull.getVisibleKeys()
+  expect(offVisible.has('0,0,0')).toBe(true)
+  cull.invalidate()
+  cull.update({
+    smartCull: true,
+    cameraWorldX: 8,
+    cameraWorldY: 8,
+    cameraWorldZ: 8,
+    viewDistance: 4,
+    sectionHeight: 16,
+    worldMinY: 0,
+    worldMaxY: 256
+  })
+  expect(cull.isSectionVisible('0,0,0')).toBe(true)
+})

package/src/three/tests/sectionOcclusionGraph.test.ts

@@ -0,0 +1,134 @@
+//@ts-nocheck
+import { test, expect } from 'vitest'
+import { Direction } from '../../mesher-shared/visibilitySet'
+import { SectionOcclusionGraph } from '../occlusion/sectionOcclusionGraph'
+import { computeSectionVisibilitySet } from '../../mesher-shared/visGraph'
+
+const ALL_OPEN = computeSectionVisibilitySet(16, () => false)
+const SOLID = computeSectionVisibilitySet(16, () => true)
+
+function reg(graph: SectionOcclusionGraph, key: string, vis = ALL_OPEN) {
+  const [x, y, z] = key.split(',').map(Number)
+  graph.registerSection(key, { visibilitySet: vis, worldX: x!, worldY: y!, worldZ: z! })
+}
+
+test('BFS from camera section reaches neighbors when smart cull on and faces connect', () => {
+  const graph = new SectionOcclusionGraph()
+  reg(graph, '0,0,0')
+  reg(graph, '16,0,0')
+  reg(graph, '-16,0,0')
+
+  const visible = graph.update({
+    smartCull: true,
+    cameraWorldX: 8,
+    cameraWorldY: 8,
+    cameraWorldZ: 8,
+    viewDistance: 4,
+    sectionHeight: 16,
+    worldMinY: 0,
+    worldMaxY: 256
+  })
+
+  expect(visible.has('0,0,0')).toBe(true)
+  expect(visible.has('16,0,0')).toBe(true)
+  expect(visible.has('-16,0,0')).toBe(true)
+})
+
+test('solid section blocks traversal to neighbor behind it', () => {
+  const graph = new SectionOcclusionGraph()
+  reg(graph, '0,0,0', ALL_OPEN)
+  reg(graph, '16,0,0', SOLID)
+  reg(graph, '32,0,0', ALL_OPEN)
+
+  const visible = graph.update({
+    smartCull: true,
+    cameraWorldX: 8,
+    cameraWorldY: 8,
+    cameraWorldZ: 8,
+    viewDistance: 4,
+    sectionHeight: 16,
+    worldMinY: 0,
+    worldMaxY: 256
+  })
+
+  expect(visible.has('0,0,0')).toBe(true)
+  expect(visible.has('16,0,0')).toBe(true)
+  expect(visible.has('32,0,0')).toBe(false)
+})
+
+test('smart cull off shows all registered sections', () => {
+  const graph = new SectionOcclusionGraph()
+  reg(graph, '0,0,0')
+  reg(graph, '64,0,0', SOLID)
+
+  const visible = graph.update({
+    smartCull: false,
+    cameraWorldX: 8,
+    cameraWorldY: 8,
+    cameraWorldZ: 8,
+    viewDistance: 2,
+    sectionHeight: 16,
+    worldMinY: 0,
+    worldMaxY: 256
+  })
+
+  expect(visible.has('64,0,0')).toBe(true)
+})
+
+test('BFS assigns increasing step values', () => {
+  const graph = new SectionOcclusionGraph()
+  reg(graph, '0,0,0')
+  reg(graph, '16,0,0')
+
+  graph.update({
+    smartCull: true,
+    cameraWorldX: 8,
+    cameraWorldY: 8,
+    cameraWorldZ: 8,
+    viewDistance: 4,
+    sectionHeight: 16,
+    worldMinY: 0,
+    worldMaxY: 256
+  })
+
+  expect(graph.getStep('0,0,0')).toBe(0)
+  expect(graph.getStep('16,0,0')).toBe(1)
+})
+
+test('N-S tunnel section only connects through north/south faces', () => {
+  const tunnelVis = computeSectionVisibilitySet(16, (lx, _ly, _lz) => lx === 0 || lx === 15)
+  const graph = new SectionOcclusionGraph()
+  reg(graph, '0,0,0', tunnelVis)
+  reg(graph, '0,0,16', ALL_OPEN)
+
+  const visible = graph.update({
+    smartCull: true,
+    cameraWorldX: 8,
+    cameraWorldY: 8,
+    cameraWorldZ: 8,
+    viewDistance: 4,
+    sectionHeight: 16,
+    worldMinY: 0,
+    worldMaxY: 256
+  })
+
+  expect(visible.has('0,0,16')).toBe(true)
+})
+
+test('missing camera section seeds from surface ring', () => {
+  const graph = new SectionOcclusionGraph()
+  reg(graph, '0,0,0')
+
+  const visible = graph.update({
+    smartCull: true,
+    cameraWorldX: 8,
+    cameraWorldY: -32,
+    cameraWorldZ: 8,
+    viewDistance: 4,
+    sectionHeight: 16,
+    worldMinY: 0,
+    worldMaxY: 256
+  })
+
+  expect(visible.has('0,0,0')).toBe(true)
+})

package/src/three/tests/threeJsSound.test.ts

@@ -0,0 +1,110 @@
+//@ts-nocheck
+import { describe, expect, it, vi, beforeEach } from 'vitest'
+
+const mockSetVolume = vi.fn()
+const mockPlay = vi.fn()
+const loadAsyncDeferreds: Array<{ resolve: (buffer: unknown) => void }> = []
+
+vi.mock('three', () => {
+  class MockPositionalAudio {
+    panner = {
+      distanceModel: '',
+      refDistance: 0,
+      rolloffFactor: 0,
+      maxDistance: 0,
+      positionX: { setValueAtTime: vi.fn() },
+      positionY: { setValueAtTime: vi.fn() },
+      positionZ: { setValueAtTime: vi.fn() }
+    }
+
+    position = { set: vi.fn() }
+    matrixWorld = { decompose: vi.fn() }
+    setBuffer = vi.fn()
+    setVolume = mockSetVolume
+    setPlaybackRate = vi.fn()
+    play = mockPlay
+    updateMatrixWorld = vi.fn()
+    onEnded: (() => void) | undefined
+    source = null
+    disconnect = vi.fn()
+  }
+
+  class MockAudioListener {
+    context = { currentTime: 0 }
+    removeFromParent = vi.fn()
+  }
+
+  class MockAudioLoader {
+    manager = { itemEnd: vi.fn() }
+    loadAsync() {
+      return new Promise(resolve => {
+        loadAsyncDeferreds.push({ resolve })
+      })
+    }
+  }
+
+  class MockVector3 {
+    x = 0
+    y = 0
+    z = 0
+    set = vi.fn()
+  }
+
+  return {
+    PositionalAudio: MockPositionalAudio,
+    AudioListener: MockAudioListener,
+    AudioLoader: MockAudioLoader,
+    Vector3: MockVector3,
+    Quaternion: class {}
+  }
+})
+
+import { ThreeJsSound } from '../threeJsSound'
+
+function makeWorldRenderer() {
+  return {
+    onWorldSwitched: [] as Array<() => void>,
+    onReactiveConfigUpdated: vi.fn(),
+    camera: { add: vi.fn() },
+    cameraWorldPos: { x: 0, y: 64, z: 0 },
+    sceneOrigin: {
+      addAndTrack: vi.fn(),
+      removeAndUntrack: vi.fn()
+    }
+  }
+}
+
+describe('ThreeJsSound', () => {
+  beforeEach(() => {
+    mockSetVolume.mockClear()
+    mockPlay.mockClear()
+    loadAsyncDeferreds.length = 0
+  })
+
+  it('applies master volume 0 then unmute without NaN', async () => {
+    const soundSystem = new ThreeJsSound(makeWorldRenderer() as any)
+    soundSystem.baseVolume = 0
+    soundSystem.playSound({ x: 1, y: 2, z: 3 }, '/test.mp3', 1)
+
+    loadAsyncDeferreds[0].resolve({})
+    await Promise.resolve()
+
+    expect(mockSetVolume).toHaveBeenLastCalledWith(0)
+
+    soundSystem.changeVolume(1)
+    expect(mockSetVolume).toHaveBeenLastCalledWith(1)
+    expect(Number.isNaN(mockSetVolume.mock.calls.at(-1)?.[0])).toBe(false)
+  })
+
+  it('uses current master volume after async load completes', async () => {
+    const soundSystem = new ThreeJsSound(makeWorldRenderer() as any)
+    soundSystem.baseVolume = 1
+    soundSystem.playSound({ x: 0, y: 0, z: 0 }, '/test.mp3', 0.8)
+
+    soundSystem.changeVolume(0.25)
+    loadAsyncDeferreds[0].resolve({})
+    await Promise.resolve()
+
+    expect(mockSetVolume).toHaveBeenLastCalledWith(0.2)
+  })
+})

package/src/three/threeJsSound.ts

@@ -2,11 +2,17 @@
 import * as THREE from 'three'
 import { WorldRendererThree } from './worldRendererThree'
 import { SoundSystem } from '../graphicsBackend/types'
+import { applyVanillaLinearPanner, computePositionalAudioParams, DEFAULT_ATTENUATION_DISTANCE, setPannerPositionImmediate } from './positionalAudioAttenuation'
+
+const _pannerPosition = /*@__PURE__*/ new THREE.Vector3()
+const _pannerQuaternion = /*@__PURE__*/ new THREE.Quaternion()
+const _pannerScale = /*@__PURE__*/ new THREE.Vector3()
 
 export class ThreeJsSound implements SoundSystem {
   audioListener: THREE.AudioListener | undefined
   private readonly activeSounds = new Set<THREE.PositionalAudio>()
   private readonly audioContext: AudioContext | undefined
+  /** Normalized individual gain (clamped to [0, 1], excluding master volume). */
   private readonly soundVolumes = new Map<THREE.PositionalAudio, number>()
   baseVolume = 1
 
@@ -26,28 +32,40 @@ export class ThreeJsSound implements SoundSystem {
     this.worldRenderer.camera.add(this.audioListener)
   }
 
-  playSound(position: { x: number; y: number; z: number }, path: string, volume = 1, pitch = 1, timeout = 500) {
+  playSound(
+    position: { x: number; y: number; z: number },
+    path: string,
+    volume = 1,
+    pitch = 1,
+    timeout = 500,
+    attenuationDistance = DEFAULT_ATTENUATION_DISTANCE
+  ) {
     this.initAudioListener()
 
     const sound = new THREE.PositionalAudio(this.audioListener!)
     this.activeSounds.add(sound)
-    this.soundVolumes.set(sound, volume)
+
+    const { individualGain, maxDistance } = computePositionalAudioParams(volume, attenuationDistance)
+    this.soundVolumes.set(sound, individualGain)
 
     const audioLoader = new THREE.AudioLoader()
     const start = Date.now()
     void audioLoader.loadAsync(path).then(buffer => {
       if (Date.now() - start > timeout) {
         console.warn('Ignored playing sound', path, 'due to timeout:', timeout, 'ms <', Date.now() - start, 'ms')
+        this.activeSounds.delete(sound)
+        this.soundVolumes.delete(sound)
         return
       }
-      // play
       sound.setBuffer(buffer)
-      sound.setRefDistance(20)
-      sound.setVolume(volume * this.baseVolume)
-      sound.setPlaybackRate(pitch) // set the pitch
-      // set sound position
+      applyVanillaLinearPanner(sound.panner, maxDistance)
+      sound.setVolume(individualGain * this.baseVolume)
+      sound.setPlaybackRate(pitch)
       this.worldRenderer.sceneOrigin.addAndTrack(sound)
       sound.position.set(position.x, position.y, position.z)
+      sound.updateMatrixWorld(true)
+      sound.matrixWorld.decompose(_pannerPosition, _pannerQuaternion, _pannerScale)
+      setPannerPositionImmediate(sound.panner, this.audioListener!.context, _pannerPosition.x, _pannerPosition.y, _pannerPosition.z)
       sound.onEnded = () => {
         this.worldRenderer.sceneOrigin.removeAndUntrack(sound)
         if (sound.source) {
@@ -76,14 +94,13 @@ export class ThreeJsSound implements SoundSystem {
 
   changeVolume(volume: number) {
     this.baseVolume = volume
-    for (const [sound, individualVolume] of this.soundVolumes) {
-      sound.setVolume(individualVolume * this.baseVolume)
+    for (const [sound, individualGain] of this.soundVolumes) {
+      sound.setVolume(individualGain * this.baseVolume)
     }
   }
 
   destroy() {
     this.stopAll()
-    // Remove and cleanup audio listener
     if (this.audioListener) {
       this.audioListener.removeFromParent()
       this.audioListener = undefined
@@ -91,6 +108,7 @@ export class ThreeJsSound implements SoundSystem {
   }
 
   playTestSound() {
-    this.playSound(this.worldRenderer.camera.position, '/sound.mp3')
+    const { x, y, z } = this.worldRenderer.cameraWorldPos
+    this.playSound({ x, y, z }, '/sound.mp3')
   }
 }

package/src/three/worldRendererThree.ts

@@ -49,6 +49,25 @@ export class WorldRendererThree extends WorldRendererCommon {
   protected override isShaderCubeBlocksEnabled(): boolean {
     return this.worldRendererConfig.shaderCubeBlocks === true && !!this.renderer?.capabilities?.isWebGL2
   }
+
+  /** Section occlusion graph (smart / cave cull); forced off in spectator per issue #77. */
+  isSmartCullEnabled(): boolean {
+    return this.worldRendererConfig.smartCull !== false && this.reactiveDebugParams.smartCull !== false && this.playerStateReactive.gameMode !== 'spectator'
+  }
+
+  isSectionOcclusionVisible(sectionKey: string): boolean {
+    if (!this.isSmartCullEnabled()) return true
+    return this.chunkMeshManager.isSectionOcclusionVisible(sectionKey)
+  }
+
+  entitySectionKey(worldX: number, worldY: number, worldZ: number): string {
+    const sectionHeight = this.getSectionHeight()
+    const x = Math.floor(worldX / 16) * 16
+    const y = Math.floor(worldY / sectionHeight) * sectionHeight
+    const z = Math.floor(worldZ / 16) * 16
+    return `${x},${y},${z}`
+  }
+
   chunkMeshManager: ChunkMeshManager
   get sectionObjects() {
     return this.chunkMeshManager.sectionObjects
@@ -787,6 +806,8 @@ export class WorldRendererThree extends WorldRendererCommon {
           const s = gb.legacyBlend
           text += `LEG-B: ${formatCompact(s.used)}/${formatCompact(s.capacity)}q `
         }
+        const drawn = this.chunkMeshManager.getDrawnStats()
+        text += `DRAWN: ${formatCompact(drawn.cubeFaces)}f ${formatCompact(drawn.legacyOpaqueQuads)}q ${formatCompact(drawn.legacyBlendQuads)}q `
         text += `MEM: ${this.chunkMeshManager.getEstimatedMemoryUsage().total} `
         const camCollisionBytes = this.cameraCollisionBlockCache.getAllocatedBytes()
         if (camCollisionBytes > 0) {
@@ -1285,11 +1306,6 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
 
     let entitiesRenderMs = 0
-    if (!this.reactiveDebugParams.disableEntities) {
-      const entitiesStart = performance.now()
-      this.entities.render()
-      entitiesRenderMs = performance.now() - entitiesStart
-    }
 
     // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
     const cam =
@@ -1340,10 +1356,18 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.chunkMeshManager.markCullDirtyIfBufferStateChanged()
     this.chunkMeshManager.setLegacyCameraOrigin(camX, camY, camZ)
     this.chunkMeshManager.updateCullDirtyFromCamera(cam, camX, camY, camZ)
+    const smartCull = this.isSmartCullEnabled()
+    this.chunkMeshManager.notifySmartCullChanged(smartCull)
     if (this.chunkMeshManager.cullDirty) {
-      this.chunkMeshManager.updateSectionCullAndSort(cam, this.cameraWorldPos.x, this.cameraWorldPos.y, this.cameraWorldPos.z)
+      this.chunkMeshManager.updateSectionCullAndSort(cam, this.cameraWorldPos.x, this.cameraWorldPos.y, this.cameraWorldPos.z, smartCull)
       this.chunkMeshManager.clearCullDirty()
     }
+    this.chunkMeshManager.updateCaveCullingDebug(this.reactiveDebugParams.caveCullingDebug, smartCull)
+    if (!this.reactiveDebugParams.disableEntities) {
+      const entitiesStart = performance.now()
+      this.entities.render()
+      entitiesRenderMs = performance.now() - entitiesStart
+    }
     this.chunkMeshManager.sortVisibleBlendSections(camX, camY, camZ)
     if (!didBlendAllAttrUpload && globalLegacyBlendBuffer?.hasPendingIndexUploads()) {
       globalLegacyBlendBuffer.uploadDirtyIndexRange()