minecraft-renderer 0.1.91 → 0.1.92

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/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()

package/src/wasm-mesher/bridge/convertChunk.ts

@@ -1,8 +1,8 @@
 //@ts-nocheck
 import { Vec3 } from 'vec3'
 import MinecraftData from 'minecraft-data'
-import PrismarineBlockLoader from 'prismarine-block'
 import moreBlockDataGeneratedJson from '../../lib/moreBlockDataGenerated.json'
+import { getOccludingBlockMeta } from '../../mesher-shared/occludingBlocks'
 
 type BlockMeta = {
   invisibleBlocks: Uint16Array
@@ -10,6 +10,7 @@ type BlockMeta = {
   noAoBlocks: Uint16Array
   cullIdenticalBlocks: Uint16Array
   occludingBlocks: Uint16Array
+  occludingLookup: Uint8Array
 }
 
 const metaCache = new Map<string, BlockMeta>()
@@ -22,38 +23,6 @@ const blockToIds = (block: { minStateId: number; maxStateId: number }) => {
   return ids
 }
 
-const isCube = (shapes: any) => {
-  if (!shapes || shapes.length !== 1) return false
-  const s = shapes[0]
-  return s[0] === 0 && s[1] === 0 && s[2] === 0 && s[3] === 1 && s[4] === 1 && s[5] === 1
-}
-
-const isLikelyFullCubeBlockName = (name: string) => {
-  if (!name) return false
-  if (name.includes('stairs')) return false
-  if (name.includes('slab')) return false
-  if (name.includes('fence')) return false
-  if (name.includes('gate')) return false
-  if (name.includes('pane')) return false
-  if (name.includes('wall')) return false
-  if (name.includes('door')) return false
-  if (name.includes('trapdoor')) return false
-  if (name.includes('sign')) return false
-  if (name.includes('banner')) return false
-  if (name.includes('rail')) return false
-  if (name.includes('torch')) return false
-  if (name.includes('lantern')) return false
-  if (name.includes('button')) return false
-  if (name.includes('lever')) return false
-  if (name.includes('pressure_plate')) return false
-  if (name.includes('carpet')) return false
-  if (name.includes('flower')) return false
-  if (name.includes('sapling')) return false
-  if (name.includes('tall_grass')) return false
-  if (name === 'grass' || name === 'short_grass' || name === 'tall_grass') return false
-  return true
-}
-
 export const getBlockMeta = (version: string): BlockMeta => {
   const cached = metaCache.get(version)
   if (cached) return cached
@@ -64,30 +33,15 @@ export const getBlockMeta = (version: string): BlockMeta => {
   const transparentBlocks = new Uint16Array(mcData.blocksArray.filter(x => x.transparent).flatMap(blockToIds))
   const noAoBlocks = new Uint16Array(mcData.blocksArray.filter(x => moreBlockDataGeneratedJson.noOcclusions[x.name]).flatMap(blockToIds))
   const cullIdenticalBlocks = new Uint16Array(mcData.blocksArray.filter(x => x.name.includes('glass') || x.name.includes('ice')).flatMap(blockToIds))
-  const Block = PrismarineBlockLoader(version)
-  const noOcclusionsSet = new Set(Object.keys(moreBlockDataGeneratedJson.noOcclusions))
-
-  const occludingBlockIds: number[] = []
-  for (const idStr of Object.keys((mcData as any).blocksByStateId)) {
-    const id = Number(idStr)
-    if (!id) continue
-    const b = (Block as any).fromStateId(id, 0)
-    if (!b) continue
-    if (b.transparent) continue
-    if (b.boundingBox !== 'block') continue
-    if (noOcclusionsSet.has(b.name)) continue
-    if (!isCube(b.shapes)) continue
-    occludingBlockIds.push(id)
-  }
-
-  const occludingBlocks = new Uint16Array(occludingBlockIds)
+  const { occludingBlocks, occludingLookup } = getOccludingBlockMeta(version)
 
   const meta = {
     invisibleBlocks,
     transparentBlocks,
     noAoBlocks,
     cullIdenticalBlocks,
-    occludingBlocks
+    occludingBlocks,
+    occludingLookup
   }
 
   metaCache.set(version, meta)

package/src/wasm-mesher/tests/sectionVisibilityFromWorld.test.ts

@@ -0,0 +1,108 @@
+//@ts-nocheck
+import { test, expect, beforeEach } from 'vitest'
+import MinecraftData from 'minecraft-data'
+import blocksAtlasesJson from 'mc-assets/dist/blocksAtlases.json'
+import blockStatesModels from 'mc-assets/dist/blockStatesModels.json'
+import Chunks from 'prismarine-chunk'
+import { Vec3 } from 'vec3'
+import { setBlockStatesData } from '../../mesher-shared/models'
+import { getOccludingBlockMeta } from '../../mesher-shared/occludingBlocks'
+import { VisGraph, packVisibilitySet } from '../../mesher-shared/visGraph'
+import { Direction, unpackVisibilitySet } from '../../mesher-shared/visibilitySet'
+import { World } from '../../mesher-shared/world'
+
+const VERSION = '1.18.2'
+const SECTION_HEIGHT = 16
+
+beforeEach(() => {
+  const mcData = MinecraftData(VERSION)
+  setBlockStatesData(blockStatesModels, blocksAtlasesJson, false, true, VERSION, { blocks: mcData.blocksArray })
+})
+
+function buildVisibilityFromWorld(world: World, sx: number, sy: number, sz: number, sectionHeight: number): number {
+  const { occludingLookup } = getOccludingBlockMeta(VERSION)
+  const graph = new VisGraph()
+  const cursor = new Vec3(0, 0, 0)
+  for (cursor.y = sy; cursor.y < sy + sectionHeight; cursor.y++) {
+    for (cursor.z = sz; cursor.z < sz + 16; cursor.z++) {
+      for (cursor.x = sx; cursor.x < sx + 16; cursor.x++) {
+        const block = world.getBlock(cursor)
+        if (block && occludingLookup[block.stateId]) {
+          graph.setOpaque(cursor.x - sx, cursor.y - sy, cursor.z - sz)
+        }
+      }
+    }
+  }
+  return packVisibilitySet(graph.resolve())
+}
+
+function solidStoneSectionWorld(): World {
+  const mcData = MinecraftData(VERSION)
+  const stoneId = mcData.blocksByName.stone!.defaultState
+  const Chunk = Chunks(VERSION) as any
+  const chunk = new Chunk(undefined as any)
+  for (let y = 0; y < SECTION_HEIGHT; y++) {
+    for (let z = 0; z < 16; z++) {
+      for (let x = 0; x < 16; x++) {
+        chunk.setBlockStateId(new Vec3(x, y, z), stoneId)
+      }
+    }
+  }
+  const world = new World(VERSION)
+  world.addColumn(0, 0, chunk.toJson())
+  return world
+}
+
+test('occludingLookup VisGraph: solid 16³ interior packs no face pairs (not all-open)', () => {
+  const world = solidStoneSectionWorld()
+  const bits = buildVisibilityFromWorld(world, 0, 0, 0, SECTION_HEIGHT)
+  const vs = unpackVisibilitySet(bits)
+  for (let a = 0; a < 6; a++) {
+    for (let b = 0; b < 6; b++) {
+      if (a === b) continue
+      expect(vs.visibilityBetween(a, b)).toBe(false)
+    }
+  }
+  expect(vs.visibilityBetween(Direction.NORTH, Direction.SOUTH)).toBe(false)
+})
+
+test('occludingLookup VisGraph: empty section is all-open', () => {
+  const world = new World(VERSION)
+  const Chunk = Chunks(VERSION) as any
+  world.addColumn(0, 0, new Chunk(undefined as any).toJson())
+  const bits = buildVisibilityFromWorld(world, 0, 0, 0, SECTION_HEIGHT)
+  const vs = unpackVisibilitySet(bits)
+  expect(vs.visibilityBetween(Direction.NORTH, Direction.SOUTH)).toBe(true)
+})
+
+test('occludingLookup VisGraph: tunnel N↔S only → only N/S connected', () => {
+  const mcData = MinecraftData(VERSION)
+  const stoneId = mcData.blocksByName.stone!.defaultState
+  const Chunk = Chunks(VERSION) as any
+  const chunk = new Chunk(undefined as any)
+  for (let y = 0; y < SECTION_HEIGHT; y++) {
+    for (let z = 0; z < 16; z++) {
+      for (let x = 0; x < 16; x++) {
+        if (x === 0 || x === 15) {
+          chunk.setBlockStateId(new Vec3(x, y, z), stoneId)
+        }
+      }
+    }
+  }
+  const world = new World(VERSION)
+  world.addColumn(0, 0, chunk.toJson())
+  const bits = buildVisibilityFromWorld(world, 0, 0, 0, SECTION_HEIGHT)
+  const vs = unpackVisibilitySet(bits)
+  expect(vs.visibilityBetween(Direction.NORTH, Direction.SOUTH)).toBe(true)
+  expect(vs.visibilityBetween(Direction.EAST, Direction.WEST)).toBe(false)
+  expect(vs.visibilityBetween(Direction.NORTH, Direction.EAST)).toBe(false)
+})
+
+test('occludingLookup: stone is occluding, air is not', () => {
+  const mcData = MinecraftData(VERSION)
+  const { occludingLookup } = getOccludingBlockMeta(VERSION)
+  const stoneId = mcData.blocksByName.stone!.defaultState
+  const airId = mcData.blocksByName.air!.defaultState
+  expect(occludingLookup[stoneId]).toBe(1)
+  expect(occludingLookup[airId]).toBe(0)
+})

package/src/wasm-mesher/worker/mesherWasm.ts

@@ -4,6 +4,8 @@ import { convertChunkToWasm, getBlockMeta, type ChunkConversionResult } from '..
 import { extractColumnHeightmap, splitColumnWasmOutputToSections } from '../bridge/render-from-wasm'
 import { setBlockStatesData as setMesherData } from '../../mesher-shared/models'
 import { defaultMesherConfig, type MesherGeometryOutput, SECTION_HEIGHT } from '../../mesher-shared/shared'
+import { packVisibilitySet, VISIBILITY_SET_ALL_TRUE } from '../../mesher-shared/visibilitySet'
+import { VisGraph } from '../../mesher-shared/visGraph'
 import { worldColumnKey, World } from '../../mesher-shared/world'
 import { handleGetHeightmap, EMPTY_COLUMN_HEIGHTMAP_SENTINEL } from '../../mesher-shared/computeHeightmap'
 import { collectBlockEntityMetadata, type SignMeta, type HeadMeta, type BannerMeta } from '../../mesher-shared/blockEntityMetadata'
@@ -1077,7 +1079,8 @@ function makeEmptyColumnGeometry(sx: number, sy: number, sz: number, sectionHeig
     signs: {},
     banners: {},
     hadErrors,
-    blocksCount: 0
+    blocksCount: 0,
+    visibilitySet: VISIBILITY_SET_ALL_TRUE
   }
 }
 
@@ -1465,16 +1468,22 @@ function processColumnTick() {
         const banners: Record<string, BannerMeta> = {}
         const beTarget = { signs, heads, banners }
         const beOpts = { disableBlockEntityTextures: world.config.disableBlockEntityTextures }
+        const { occludingLookup } = getBlockMeta(version)
+        const visGraph = new VisGraph()
         const cursor = new Vec3(0, 0, 0)
         for (cursor.y = sy; cursor.y < sy + sectionHeight; cursor.y++) {
           for (cursor.z = sz; cursor.z < sz + 16; cursor.z++) {
             for (cursor.x = sx; cursor.x < sx + 16; cursor.x++) {
               const b = world.getBlock(cursor)
               if (!b) continue
+              if (occludingLookup[b.stateId]) {
+                visGraph.setOpaque(cursor.x - sx, cursor.y - sy, cursor.z - sz)
+              }
               collectBlockEntityMetadata(b, cursor.x, cursor.y, cursor.z, beTarget, beOpts, world)
             }
           }
         }
+        const sectionVisibilitySet = packVisibilitySet(visGraph.resolve())
 
         let geometry: MesherGeometryOutput
         let transferable: any[] = []
@@ -1516,7 +1525,8 @@ function processColumnTick() {
             // `B:` debug overlay stat) and matches the per-section path's
             // semantics: number of blocks that contributed faces to this
             // section's geometry.
-            blocksCount: sectionBlocksCount
+            blocksCount: sectionBlocksCount,
+            visibilitySet: sectionVisibilitySet
           }
           if (exported.shaderCubes) {
             geometry.shaderCubes = {
@@ -1573,6 +1583,7 @@ function processColumnTick() {
           }
         } else {
           geometry = makeEmptyColumnGeometry(sx, sy, sz, sectionHeight, false)
+          geometry.visibilitySet = sectionVisibilitySet
           // Still attach block entity metadata so the main thread sees
           // signs/heads/banners even for empty-mesh sections.
           geometry.signs = signs