minecraft-renderer 0.1.90 → 0.1.92

package/package.json

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

package/src/graphicsBackend/config.ts

@@ -21,6 +21,9 @@ export const defaultWorldRendererConfig = {
   debugModelVariant: undefined as undefined | number[],
   futuristicReveal: false,
 
+  /** Master toggle for section occlusion graph (smart / cave cull). Disabled in spectator. */
+  smartCull: true,
+
   // Performance settings
   wasmMesher: true,
   /** Render full 1×1 cubes through the instanced shader path (requires WebGL2). */

package/src/graphicsBackend/types.ts

@@ -18,7 +18,14 @@ import { WorldRendererConfig } from './config'
 export type MaybePromise<T> = Promise<T> | T
 
 export interface SoundSystem {
-  playSound: (position: { x: number; y: number; z: number }, path: string, volume?: number, pitch?: number, timeout?: number) => void
+  playSound: (
+    position: { x: number; y: number; z: number },
+    path: string,
+    volume?: number,
+    pitch?: number,
+    timeout?: number,
+    attenuationDistance?: number
+  ) => void
   destroy: () => void
 }
 

package/src/lib/worldrendererCommon.ts

@@ -54,7 +54,10 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     chunksRenderBelowEnabled: false,
     chunksRenderDistanceOverride: undefined as number | undefined,
     chunksRenderDistanceEnabled: false,
-    disableEntities: false
+    disableEntities: false,
+    /** Tint section borders by occlusion BFS step (perf debug overlay). */
+    caveCullingDebug: false,
+    smartCull: true
     // disableParticles: false
   })
 

package/src/mesher-shared/exportedGeometryTypes.ts

@@ -27,6 +27,7 @@ export interface ExportedSection {
     count: number
     formatVersion: 3
   }
+  visibilitySet?: number
 }
 
 export interface ExportedWorldGeometry {

package/src/mesher-shared/models.ts

@@ -11,6 +11,8 @@ import { MesherGeometryOutput, HighestBlockInfo } from './shared'
 import { collectBlockEntityMetadata } from './blockEntityMetadata'
 import { preflatBlockCalculation, resolveBlockPropertiesForMeshing } from './blockPropertiesForMeshing'
 import { faceIsCulled, roundCardinalDir } from './faceOcclusion'
+import { getOccludingBlockMeta } from './occludingBlocks'
+import { packVisibilitySet, VisGraph } from './visGraph'
 
 export { preflatBlockCalculation, resolveBlockPropertiesForMeshing } from './blockPropertiesForMeshing'
 
@@ -540,12 +542,18 @@ export function getSectionGeometry(sx: number, sy: number, sz: number, world: Wo
     indicesCount: 0
   }
 
+  const { occludingLookup } = getOccludingBlockMeta(world.config.version)
+  const visGraph = new VisGraph()
+
   const cursor = new Vec3(0, 0, 0)
   for (cursor.y = sy; cursor.y < sy + readHeight; cursor.y++) {
     for (cursor.z = sz; cursor.z < sz + 16; cursor.z++) {
       for (cursor.x = sx; cursor.x < sx + 16; cursor.x++) {
         let block = world.getBlock(cursor, blockProvider, attr)!
         if (INVISIBLE_BLOCKS.has(block.name)) continue
+        if (occludingLookup[block.stateId]) {
+          visGraph.setOpaque(cursor.x - sx, cursor.y - sy, cursor.z - sz)
+        }
         collectBlockEntityMetadata(block, cursor.x, cursor.y, cursor.z, attr, { disableBlockEntityTextures: world.config.disableBlockEntityTextures }, world)
         const biome = block.biome.name
 
@@ -680,6 +688,8 @@ export function getSectionGeometry(sx: number, sy: number, sz: number, world: Wo
     delete attr.uvs
   }
 
+  attr.visibilitySet = packVisibilitySet(visGraph.resolve())
+
   return attr
 }
 

package/src/mesher-shared/occludingBlocks.ts

@@ -0,0 +1,53 @@
+//@ts-nocheck
+import MinecraftData from 'minecraft-data'
+import PrismarineBlockLoader from 'prismarine-block'
+import moreBlockDataGeneratedJson from '../lib/moreBlockDataGenerated.json'
+
+export type OccludingBlockMeta = {
+  occludingBlocks: Uint16Array
+  occludingLookup: Uint8Array
+}
+
+const metaCache = new Map<string, OccludingBlockMeta>()
+
+const isCube = (shapes: unknown) => {
+  if (!shapes || !Array.isArray(shapes) || shapes.length !== 1) return false
+  const s = shapes[0] as number[]
+  return s[0] === 0 && s[1] === 0 && s[2] === 0 && s[3] === 1 && s[4] === 1 && s[5] === 1
+}
+
+/** Opaque full-cube state ids used for face culling and VisGraph — single source of truth. */
+export const getOccludingBlockMeta = (version: string): OccludingBlockMeta => {
+  const cached = metaCache.get(version)
+  if (cached) return cached
+
+  const mcData = MinecraftData(version)
+  const Block = PrismarineBlockLoader(version)
+  const noOcclusionsSet = new Set(Object.keys(moreBlockDataGeneratedJson.noOcclusions))
+
+  const occludingBlockIds: number[] = []
+  for (const idStr of Object.keys((mcData as { blocksByStateId: Record<string, unknown> }).blocksByStateId)) {
+    const id = Number(idStr)
+    if (!id) continue
+    const b = (
+      Block as { fromStateId: (id: number, y: number) => { transparent?: boolean; boundingBox?: string; name: string; shapes?: unknown } | null }
+    ).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 maxId = occludingBlockIds.length ? Math.max(...occludingBlockIds) : 0
+  const occludingLookup = new Uint8Array(maxId + 1)
+  for (const id of occludingBlockIds) {
+    occludingLookup[id] = 1
+  }
+
+  const meta = { occludingBlocks, occludingLookup }
+  metaCache.set(version, meta)
+  return meta
+}

package/src/mesher-shared/shared.ts

@@ -82,6 +82,8 @@ export type MesherGeometryOutput = {
     count: number
     formatVersion: 3
   }
+  /** Packed VisibilitySet (36 bits) for section occlusion / smart cull. */
+  visibilitySet?: number
 }
 
 export interface MesherMainEvents {

package/src/mesher-shared/tests/visGraph.test.ts

@@ -0,0 +1,62 @@
+//@ts-nocheck
+import { test, expect } from 'vitest'
+import { Direction, VisibilitySet, packVisibilitySet, unpackVisibilitySet, visibilityBetweenPacked } from '../visibilitySet'
+import { VisGraph, computeSectionVisibilitySet } from '../visGraph'
+
+test('empty section → all face pairs visible', () => {
+  const bits = computeSectionVisibilitySet(16, () => false)
+  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(true)
+    }
+  }
+})
+
+test('solid stone cube → no face pairs', () => {
+  const bits = computeSectionVisibilitySet(16, () => true)
+  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)
+    }
+  }
+})
+
+test('tunnel through section N↔S only → only N/S connected', () => {
+  const bits = computeSectionVisibilitySet(16, (lx, _ly, lz) => {
+    // walls on east/west, open north-south corridor along z
+    return lx === 0 || lx === 15
+  })
+  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('VisibilitySet pack/unpack roundtrip', () => {
+  const vs = new VisibilitySet()
+  vs.add(new Set([Direction.NORTH, Direction.SOUTH]))
+  const packed = packVisibilitySet(vs)
+  const restored = unpackVisibilitySet(packed)
+  expect(restored.visibilityBetween(Direction.NORTH, Direction.SOUTH)).toBe(true)
+  expect(restored.visibilityBetween(Direction.EAST, Direction.WEST)).toBe(false)
+  expect(visibilityBetweenPacked(packed, Direction.NORTH, Direction.SOUTH)).toBe(true)
+})
+
+test('VisGraph fast path: mostly opaque → all visible', () => {
+  const graph = new VisGraph()
+  let count = 0
+  for (let ly = 0; ly < 16 && count < 3841; ly++) {
+    for (let lz = 0; lz < 16 && count < 3841; lz++) {
+      for (let lx = 0; lx < 16 && count < 3841; lx++) {
+        graph.setOpaque(lx, ly, lz)
+        count++
+      }
+    }
+  }
+  const vs = graph.resolve()
+  expect(vs.visibilityBetween(Direction.NORTH, Direction.SOUTH)).toBe(true)
+})

package/src/mesher-shared/visGraph.ts

@@ -0,0 +1,155 @@
+//@ts-nocheck
+/**
+ * Port of Minecraft VisGraph — flood-fill air pockets in a 16³ section.
+ * @see extracted_minecraft_data/client/net/minecraft/client/renderer/chunk/VisGraph.java
+ */
+
+import { Direction, DIRECTIONS, VisibilitySet, packVisibilitySet } from './visibilitySet'
+
+const LEN = 16
+const SIZE = 4096
+const DX = 1
+const DZ = 16
+const DY = 256
+const INVALID_INDEX = -1
+
+function getIndex(x: number, y: number, z: number): number {
+  return (x << 0) | (y << 8) | (z << 4)
+}
+
+const INDEX_OF_EDGES: number[] = (() => {
+  const edges: number[] = []
+  for (let x = 0; x < 16; x++) {
+    for (let z = 0; z < 16; z++) {
+      for (let y = 0; y < 16; y++) {
+        if (x === 0 || x === 15 || z === 0 || z === 15 || y === 0 || y === 15) {
+          edges.push(getIndex(x, y, z))
+        }
+      }
+    }
+  }
+  return edges
+})()
+
+class BitSet4096 {
+  private readonly words = new Uint32Array(128)
+
+  get(index: number): boolean {
+    return ((this.words[index >> 5]! >> (index & 31)) & 1) === 1
+  }
+
+  set(index: number, value: boolean): void {
+    if (value) {
+      this.words[index >> 5]! |= 1 << (index & 31)
+    } else {
+      this.words[index >> 5]! &= ~(1 << (index & 31))
+    }
+  }
+}
+
+export class VisGraph {
+  private readonly bitSet = new BitSet4096()
+  private empty = SIZE
+
+  setOpaque(x: number, y: number, z: number): void {
+    const index = getIndex(x & 15, y & 15, z & 15)
+    if (!this.bitSet.get(index)) {
+      this.bitSet.set(index, true)
+      this.empty--
+    }
+  }
+
+  resolve(): VisibilitySet {
+    const result = new VisibilitySet()
+    if (SIZE - this.empty < 256) {
+      result.setAll(true)
+    } else if (this.empty === 0) {
+      result.setAll(false)
+    } else {
+      for (const edgeIndex of INDEX_OF_EDGES) {
+        if (!this.bitSet.get(edgeIndex)) {
+          result.add(this.floodFill(edgeIndex))
+        }
+      }
+    }
+    return result
+  }
+
+  private floodFill(startIndex: number): Set<Direction> {
+    const faces = new Set<Direction>()
+    const queue: number[] = [startIndex]
+    let head = 0
+    this.bitSet.set(startIndex, true)
+
+    while (head < queue.length) {
+      const index = queue[head++]!
+      this.addEdges(index, faces)
+
+      for (const dir of DIRECTIONS) {
+        const neighbor = this.getNeighborIndexAtFace(index, dir)
+        if (neighbor >= 0 && !this.bitSet.get(neighbor)) {
+          this.bitSet.set(neighbor, true)
+          queue.push(neighbor)
+        }
+      }
+    }
+
+    return faces
+  }
+
+  private addEdges(index: number, faces: Set<Direction>): void {
+    const x = (index >> 0) & 15
+    if (x === 0) faces.add(Direction.WEST)
+    else if (x === 15) faces.add(Direction.EAST)
+
+    const y = (index >> 8) & 15
+    if (y === 0) faces.add(Direction.DOWN)
+    else if (y === 15) faces.add(Direction.UP)
+
+    const z = (index >> 4) & 15
+    if (z === 0) faces.add(Direction.NORTH)
+    else if (z === 15) faces.add(Direction.SOUTH)
+  }
+
+  private getNeighborIndexAtFace(index: number, dir: Direction): number {
+    switch (dir) {
+      case Direction.DOWN:
+        if (((index >> 8) & 15) === 0) return INVALID_INDEX
+        return index - DY
+      case Direction.UP:
+        if (((index >> 8) & 15) === 15) return INVALID_INDEX
+        return index + DY
+      case Direction.NORTH:
+        if (((index >> 4) & 15) === 0) return INVALID_INDEX
+        return index - DZ
+      case Direction.SOUTH:
+        if (((index >> 4) & 15) === 15) return INVALID_INDEX
+        return index + DZ
+      case Direction.WEST:
+        if (((index >> 0) & 15) === 0) return INVALID_INDEX
+        return index - DX
+      case Direction.EAST:
+        if (((index >> 0) & 15) === 15) return INVALID_INDEX
+        return index + DX
+      default:
+        return INVALID_INDEX
+    }
+  }
+}
+
+export function computeSectionVisibilitySet(sectionHeight: number, isOpaqueAt: (lx: number, ly: number, lz: number) => boolean): number {
+  const graph = new VisGraph()
+  const height = Math.min(sectionHeight, LEN)
+  for (let ly = 0; ly < height; ly++) {
+    for (let lz = 0; lz < LEN; lz++) {
+      for (let lx = 0; lx < LEN; lx++) {
+        if (isOpaqueAt(lx, ly, lz)) {
+          graph.setOpaque(lx, ly, lz)
+        }
+      }
+    }
+  }
+  return packVisibilitySet(graph.resolve())
+}
+
+export { packVisibilitySet } from './visibilitySet'

package/src/mesher-shared/visibilitySet.ts

@@ -0,0 +1,124 @@
+//@ts-nocheck
+/**
+ * Port of Minecraft VisibilitySet — 6×6 face connectivity matrix for section air pockets.
+ * @see extracted_minecraft_data/client/net/minecraft/client/renderer/chunk/VisibilitySet.java
+ */
+
+/** Java Direction.values() order: DOWN, UP, NORTH, SOUTH, WEST, EAST */
+export enum Direction {
+  DOWN = 0,
+  UP = 1,
+  NORTH = 2,
+  SOUTH = 3,
+  WEST = 4,
+  EAST = 5
+}
+
+export const DIRECTIONS: readonly Direction[] = [Direction.DOWN, Direction.UP, Direction.NORTH, Direction.SOUTH, Direction.WEST, Direction.EAST]
+
+const FACINGS = DIRECTIONS.length
+
+/** All 36 bits set — fail-open default when visibility data is missing. */
+export const VISIBILITY_SET_ALL_TRUE = 2 ** 36 - 1
+
+export class VisibilitySet {
+  private data = new Uint8Array(Math.ceil((FACINGS * FACINGS) / 8))
+
+  add(faces: Set<Direction>): void {
+    for (const a of faces) {
+      for (const b of faces) {
+        this.set(a, b, true)
+      }
+    }
+  }
+
+  set(a: Direction, b: Direction, value: boolean): void {
+    this.setBit(a + b * FACINGS, value)
+    this.setBit(b + a * FACINGS, value)
+  }
+
+  setAll(value: boolean): void {
+    this.data.fill(value ? 0xff : 0)
+  }
+
+  visibilityBetween(a: Direction, b: Direction): boolean {
+    return this.getBit(a + b * FACINGS)
+  }
+
+  static allTrue(): VisibilitySet {
+    const vs = new VisibilitySet()
+    vs.setAll(true)
+    return vs
+  }
+
+  static allFalse(): VisibilitySet {
+    const vs = new VisibilitySet()
+    vs.setAll(false)
+    return vs
+  }
+
+  private setBit(index: number, value: boolean): void {
+    const byteIndex = index >> 3
+    const bitIndex = index & 7
+    if (value) {
+      this.data[byteIndex]! |= 1 << bitIndex
+    } else {
+      this.data[byteIndex]! &= ~(1 << bitIndex)
+    }
+  }
+
+  private getBit(index: number): boolean {
+    const byteIndex = index >> 3
+    const bitIndex = index & 7
+    return ((this.data[byteIndex]! >> bitIndex) & 1) === 1
+  }
+}
+
+export function packVisibilitySet(vs: VisibilitySet): number {
+  let bits = 0
+  for (let a = 0; a < FACINGS; a++) {
+    for (let b = 0; b < FACINGS; b++) {
+      if (vs.visibilityBetween(a, b)) {
+        bits += 2 ** (a + b * FACINGS)
+      }
+    }
+  }
+  return bits
+}
+
+export function unpackVisibilitySet(bits: number): VisibilitySet {
+  const vs = new VisibilitySet()
+  for (let a = 0; a < FACINGS; a++) {
+    for (let b = 0; b < FACINGS; b++) {
+      const idx = a + b * FACINGS
+      if (Math.floor(bits / 2 ** idx) % 2 === 1) {
+        vs.set(a, b, true)
+      }
+    }
+  }
+  return vs
+}
+
+export function visibilityBetweenPacked(bits: number, a: Direction, b: Direction): boolean {
+  const idx = a + b * FACINGS
+  return Math.floor(bits / 2 ** idx) % 2 === 1
+}
+
+export function oppositeDirection(dir: Direction): Direction {
+  switch (dir) {
+    case Direction.DOWN:
+      return Direction.UP
+    case Direction.UP:
+      return Direction.DOWN
+    case Direction.NORTH:
+      return Direction.SOUTH
+    case Direction.SOUTH:
+      return Direction.NORTH
+    case Direction.WEST:
+      return Direction.EAST
+    case Direction.EAST:
+      return Direction.WEST
+    default:
+      return dir
+  }
+}