minecraft-renderer 0.1.90 → 0.1.92

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