minecraft-renderer 0.1.79 → 0.1.80

package/src/mesher-legacy/mesher.ts

@@ -5,14 +5,16 @@ import { getSectionGeometry, setBlockStatesData as setMesherData, computeWirefra
 import { BlockStateModelInfo } from '../mesher-shared/shared'
 import { handleGetHeightmap, EMPTY_COLUMN_HEIGHTMAP_SENTINEL } from '../mesher-shared/computeHeightmap'
 
-globalThis.structuredClone ??= (value) => JSON.parse(JSON.stringify(value))
+globalThis.structuredClone ??= value => JSON.parse(JSON.stringify(value))
 
 if (globalThis.module && module.require) {
   // If we are in a node environement, we need to fake some env variables
   const r = module.require
   const { parentPort } = r('worker_threads')
   global.self = parentPort
-  global.postMessage = (value, transferList) => { parentPort.postMessage(value, transferList) }
+  global.postMessage = (value, transferList) => {
+    parentPort.postMessage(value, transferList)
+  }
   global.performance = r('perf_hooks').performance
 }
 
@@ -44,7 +46,10 @@ const postMessage = (data, transferList = []) => {
 
 function drainQueue(from, to) {
   const messages = queuedMessages.slice(from, to)
-  global.postMessage(messages.map(m => m.data), messages.flatMap(m => m.transferList) as unknown as string)
+  global.postMessage(
+    messages.map(m => m.data),
+    messages.flatMap(m => m.transferList) as unknown as string
+  )
   queuedMessages = queuedMessages.slice(to)
 }
 
@@ -175,7 +180,7 @@ const handleMessage = data => {
         type: 'mc-web-pong',
         workerIndex: replyWorkerIndex,
         t: data.t,
-        recvAt: typeof performance !== 'undefined' ? performance.now() : undefined,
+        recvAt: typeof performance !== 'undefined' ? performance.now() : undefined
       })
       break
     }

package/src/mesher-legacy/test/a.ts

@@ -1,4 +1,4 @@
 //@ts-nocheck
-import {MaxRectsPacker } from 'maxrects-packer'
+import { MaxRectsPacker } from 'maxrects-packer'
 
 console.log('test', MaxRectsPacker)

package/src/mesher-legacy/test/mesherTester.ts

@@ -47,7 +47,7 @@ export const setup = (version, initialBlocks: Array<[number[], string]>, options
   reload()
 
   const getLights = () => {
-    return Object.fromEntries(getGeometry().faces.map(({ face, light }) => ([face, (light ?? 0) * 15 - 2])))
+    return Object.fromEntries(getGeometry().faces.map(({ face, light }) => [face, (light ?? 0) * 15 - 2]))
   }
 
   const setLight = (x: number, y: number, z: number, val = 0) => {
@@ -78,5 +78,5 @@ const addPositions = [
   [[0, 1, 0], 'stone'],
   [[0, -1, 0], 'stone'],
   [[0, 0, 1], 'stone'],
-  [[0, 0, -1], 'stone'],
+  [[0, 0, -1], 'stone']
 ]

package/src/mesher-legacy/test/playground.ts

@@ -8,7 +8,7 @@ const addPositions = [
   [[0, 1, 0], 'stone'],
   [[0, -1, 0], 'stone'],
   [[0, 0, 1], 'stone'],
-  [[0, 0, -1], 'stone'],
+  [[0, 0, -1], 'stone']
 ] as const
 
 const { mesherWorld, getGeometry, pos, mcData } = setup('1.21.1', addPositions as any)

package/src/mesher-legacy/test/run/test-js.ts

@@ -8,7 +8,7 @@ import fs from 'fs'
 import { join } from 'path'
 
 const chunk = getChunk()
-const { getGeometry } = setup(VERSION, [], { chunkOverride: chunk, noDebugTiles: true, })
+const { getGeometry } = setup(VERSION, [], { chunkOverride: chunk, noDebugTiles: true })
 
 getGeometry()
 console.time('getGeometry')

package/src/mesher-legacy/test/snapshotUtils.ts

@@ -59,15 +59,10 @@ export function deepEqual(obj1: any, obj2: any): boolean {
  * @param baseDir - Base directory for relative paths (defaults to __dirname, ignored if snapshotPath is absolute)
  * @returns true if snapshot matches or was created, throws error if mismatch
  */
-export function compareOrWriteSnapshot(
-  output: any,
-  snapshotPath: string,
-  baseDir?: string
-): boolean {
+export function compareOrWriteSnapshot(output: any, snapshotPath: string, baseDir?: string): boolean {
   // If path is absolute, use it directly; otherwise join with baseDir or __dirname
-  const fullPath = snapshotPath.startsWith('/') || snapshotPath.includes(':')
-    ? snapshotPath
-    : baseDir ? join(baseDir, snapshotPath) : join(__dirname, snapshotPath)
+  const fullPath =
+    snapshotPath.startsWith('/') || snapshotPath.includes(':') ? snapshotPath : baseDir ? join(baseDir, snapshotPath) : join(__dirname, snapshotPath)
   const serialized = serializeOutput(output)
 
   if (!existsSync(fullPath)) {

package/src/mesher-legacy/test/test-perf.ts

@@ -22,7 +22,7 @@ const fillers = {
       for (let z = 0; z < 16; z++) {
         for (let y = -64; y < 320; y++) {
           // Create a 3D checkerboard pattern where each block is surrounded by air
-          const isEvalPoint = (x % 3 === 0) && (z % 3 === 0) && (y % 3 === 0)
+          const isEvalPoint = x % 3 === 0 && z % 3 === 0 && y % 3 === 0
           // chunk.setBlockStateId(new Vec3(x, y, z), isEvalPoint ? 1 : 0)
           chunk.setBlockType(new Vec3(x, y, z), isEvalPoint ? 1 : 0)
         }

package/src/mesher-legacy/test/tests.test.ts

@@ -22,8 +22,8 @@ test('Known blocks are not rendered', () => {
 
   let time = 0
   let times = 0
-  const missingBlocks = {}/*  as {[number, number]} */
-  const erroredBlocks = {}/*  as {[number, number]} */
+  const missingBlocks = {} /*  as {[number, number]} */
+  const erroredBlocks = {} /*  as {[number, number]} */
   for (const block of mcData.blocksArray) {
     if (ignoreAsExpected.has(block.name)) continue
     // if (block.maxStateId! - block.minStateId! > 100) continue

package/src/mesher-shared/blockEntityMetadata.test.ts

@@ -8,26 +8,28 @@ describe('collectBlockEntityMetadata', () => {
     const target = { signs: {}, heads: {}, banners: {} }
     const block = {
       name: 'pink_banner',
-      getProperties: () => ({ rotation: 0 }),
+      getProperties: () => ({ rotation: 0 })
     }
     collectBlockEntityMetadata(
       block,
-      1, 2, 3,
+      1,
+      2,
+      3,
       target,
       {},
       {
         getChannelLightNorm: (pos: Vec3) => {
           expect(pos).toBeInstanceOf(Vec3)
           return { block: 0.4, sky: 0.8 }
-        },
-      },
+        }
+      }
     )
     expect(target.banners['1,2,3']).toEqual({
       isWall: false,
       blockName: 'pink_banner',
       rotation: 0,
       blockLightNorm: 0.4,
-      skyLightNorm: 0.8,
+      skyLightNorm: 0.8
     })
   })
 })

package/src/mesher-shared/blockEntityMetadata.ts

@@ -1,8 +1,15 @@
 //@ts-nocheck
 import { Vec3 } from 'vec3'
 
-export interface SignMeta { isWall: boolean; isHanging: boolean; rotation: number }
-export interface HeadMeta { isWall: boolean; rotation: number }
+export interface SignMeta {
+  isWall: boolean
+  isHanging: boolean
+  rotation: number
+}
+export interface HeadMeta {
+  isWall: boolean
+  rotation: number
+}
 export interface BannerMeta {
   isWall: boolean
   blockName: string
@@ -24,24 +31,26 @@ export interface BlockEntityMetadataOptions {
 type BlockLike = { name: string; getProperties(): any }
 
 type LightSampler = {
-  getChannelLightNorm(pos: Vec3): { block: number, sky: number }
+  getChannelLightNorm(pos: Vec3): { block: number; sky: number }
 }
 
 export function collectBlockEntityMetadata(
   block: BlockLike,
-  x: number, y: number, z: number,
+  x: number,
+  y: number,
+  z: number,
   target: BlockEntityMetadataTarget,
   options: BlockEntityMetadataOptions,
-  world?: LightSampler,
+  world?: LightSampler
 ): void {
   if ((block.name.includes('_sign') || block.name === 'sign') && !options.disableBlockEntityTextures) {
     const key = `${x},${y},${z}`
     const props: any = block.getProperties()
     const facingRotationMap = {
-      'north': 2,
-      'south': 0,
-      'west': 1,
-      'east': 3
+      north: 2,
+      south: 0,
+      west: 1,
+      east: 3
     }
     const isWall = block.name.endsWith('wall_sign') || block.name.endsWith('wall_hanging_sign')
     const isHanging = block.name.endsWith('hanging_sign')
@@ -54,10 +63,10 @@ export function collectBlockEntityMetadata(
     const key = `${x},${y},${z}`
     const props: any = block.getProperties()
     const facingRotationMap = {
-      'north': 0,
-      'south': 2,
-      'west': 3,
-      'east': 1
+      north: 0,
+      south: 2,
+      west: 3,
+      east: 1
     }
     const isWall = block.name === 'player_wall_head'
     target.heads[key] = {
@@ -68,19 +77,19 @@ export function collectBlockEntityMetadata(
     const key = `${x},${y},${z}`
     const props: any = block.getProperties()
     const facingRotationMap = {
-      'north': 2,
-      'south': 0,
-      'west': 1,
-      'east': 3
+      north: 2,
+      south: 0,
+      west: 1,
+      east: 3
     }
     const isWall = block.name.endsWith('_wall_banner')
     const light = world?.getChannelLightNorm(new Vec3(x, y, z)) ?? { block: 0, sky: 1 }
     target.banners[key] = {
       isWall,
       blockName: block.name, // Pass block name for base color extraction
-      rotation: isWall ? facingRotationMap[props.facing] : (props.rotation === undefined ? 0 : +props.rotation),
+      rotation: isWall ? facingRotationMap[props.facing] : props.rotation === undefined ? 0 : +props.rotation,
       blockLightNorm: light.block,
-      skyLightNorm: light.sky,
+      skyLightNorm: light.sky
     }
   }
 }

package/src/mesher-shared/blockPropertiesForMeshing.ts

@@ -16,7 +16,7 @@ export function resolveBlockPropertiesForMeshing(
   blockProvider: WorldBlockProvider,
   blockStateId: number,
   PrismarineBlockCtor: { fromStateId: (id: number, biome: number) => Block }
-): { name: string, properties: Record<string, unknown> } {
+): { name: string; properties: Record<string, unknown> } {
   if (world?.preflat) {
     const block = world.getBlock(cursor, blockProvider, {})
     if (block) {
@@ -45,7 +45,7 @@ export function preflatBlockCalculation(block: Block, world: World, position: Ve
       const props = {}
       let changed = false
       for (const [i, neighbor] of neighbors.entries()) {
-        const isConnectedToSolid = isSolidConnection ? (neighbor && !neighbor.transparent) : false
+        const isConnectedToSolid = isSolidConnection ? neighbor && !neighbor.transparent : false
         if (isConnectedToSolid || neighbor?.name === block.name) {
           props[['south', 'north', 'east', 'west'][i]] = 'true'
           changed = true

package/src/mesher-shared/computeHeightmap.ts

@@ -43,9 +43,7 @@ export function computeHeightmap(world: World, chunkX: number, chunkZ: number):
       // when we hit worldMinY with the column still entirely invisible/empty.
       // Only the former is a real surface; the latter is the empty-column
       // case and must use the sentinel to match Rust's encoding.
-      heightmap[index] = block && !INVISIBLE_BLOCKS.has(block.name)
-        ? blockPos.y
-        : EMPTY_COLUMN_HEIGHTMAP_SENTINEL
+      heightmap[index] = block && !INVISIBLE_BLOCKS.has(block.name) ? blockPos.y : EMPTY_COLUMN_HEIGHTMAP_SENTINEL
     }
   }
   return heightmap
@@ -59,7 +57,7 @@ export function computeHeightmap(world: World, chunkX: number, chunkZ: number):
  * Test fixtures (see `wasm-mesher/test-section-boundary.ts`) invoke this helper
  * directly to exercise the real handler path end-to-end.
  */
-export function handleGetHeightmap(world: World, x: number, z: number): { key: string, heightmap: Int16Array } {
+export function handleGetHeightmap(world: World, x: number, z: number): { key: string; heightmap: Int16Array } {
   const heightmap = computeHeightmap(world, x, z)
   const key = `${Math.floor(x / 16)},${Math.floor(z / 16)}`
   return { key, heightmap }

package/src/mesher-shared/exportedGeometryTypes.ts

@@ -3,7 +3,7 @@
 
 export interface ExportedSection {
   key: string
-  position: { x: number, y: number, z: number }
+  position: { x: number; y: number; z: number }
   geometry: {
     positions: number[]
     normals: number[]
@@ -33,8 +33,8 @@ export interface ExportedWorldGeometry {
   version: string
   exportedAt: string
   camera: {
-    position: { x: number, y: number, z: number }
-    rotation: { pitch: number, yaw: number }
+    position: { x: number; y: number; z: number }
+    rotation: { pitch: number; yaw: number }
   }
   sections: ExportedSection[]
   textureAtlasDataUrl?: string

package/src/mesher-shared/faceOcclusion.ts

@@ -0,0 +1,324 @@
+//@ts-nocheck
+import type { WorldBlockProvider } from 'mc-assets/dist/worldBlockProvider'
+import PrismarineBlockLoader from 'prismarine-block'
+import moreBlockDataGeneratedJson from '../lib/moreBlockDataGenerated.json'
+import { buildRotationMatrix, elemFaces, matmul3, matmulmat3, vecsub3 } from './modelsGeometryCommon'
+import type { BlockElement } from './modelsGeometryCommon'
+import type { BlockModelPartsResolved } from './world'
+
+export type CardinalDir = [number, number, number]
+
+type FaceName = keyof typeof elemFaces
+
+type BlockStateInfo = {
+  stateId: number
+  name: string
+}
+
+const BLOCK_CENTER: [number, number, number] = [8, 8, 8]
+const SNAP_EPS = 1e-5
+
+function snapBlockUnit(n: number): number {
+  const rounded = Math.round(n)
+  return Math.abs(n - rounded) < SNAP_EPS ? rounded : n
+}
+
+const DIR_KEYS: CardinalDir[] = [
+  [0, 1, 0],
+  [0, -1, 0],
+  [1, 0, 0],
+  [-1, 0, 0],
+  [0, 0, 1],
+  [0, 0, -1]
+]
+
+const faceProjections: Record<
+  FaceName,
+  {
+    touches: (element: BlockElement) => boolean
+    rect: (element: BlockElement) => [number, number, number, number]
+  }
+> = {
+  up: {
+    touches: e => e.to[1] === 16,
+    rect: e => [e.from[0], e.from[2], e.to[0], e.to[2]]
+  },
+  down: {
+    touches: e => e.from[1] === 0,
+    rect: e => [e.from[0], e.from[2], e.to[0], e.to[2]]
+  },
+  east: {
+    touches: e => e.to[0] === 16,
+    rect: e => [e.from[2], e.from[1], e.to[2], e.to[1]]
+  },
+  west: {
+    touches: e => e.from[0] === 0,
+    rect: e => [e.from[2], e.from[1], e.to[2], e.to[1]]
+  },
+  south: {
+    touches: e => e.to[2] === 16,
+    rect: e => [e.from[0], e.from[1], e.to[0], e.to[1]]
+  },
+  north: {
+    touches: e => e.from[2] === 0,
+    rect: e => [e.from[0], e.from[1], e.to[0], e.to[1]]
+  }
+}
+
+const shapeCache = new Map<string, Uint16Array[]>()
+const blockLoaderCache = new Map<string, ReturnType<typeof PrismarineBlockLoader>>()
+const noOcclusionsSet = new Set(Object.keys(moreBlockDataGeneratedJson.noOcclusions))
+
+export function resetFaceOcclusionCache() {
+  shapeCache.clear()
+}
+
+export function oppositeDir(dir: CardinalDir): CardinalDir {
+  return [-dir[0], -dir[1], -dir[2]]
+}
+
+export function roundCardinalDir(dir: [number, number, number]): CardinalDir {
+  return [Math.round(dir[0]), Math.round(dir[1]), Math.round(dir[2])]
+}
+
+export function buildModelGlobalMatrix(model: { x?: number; y?: number; z?: number }): number[][] | null {
+  let globalMatrix = null as number[][] | null
+  for (const axis of ['x', 'y', 'z'] as const) {
+    if (axis in model) {
+      globalMatrix = globalMatrix ? matmulmat3(globalMatrix, buildRotationMatrix(axis, -(model[axis] ?? 0))) : buildRotationMatrix(axis, -(model[axis] ?? 0))
+    }
+  }
+  return globalMatrix
+}
+
+function isAxisAligned90Rotation(model: { x?: number; y?: number; z?: number }): boolean {
+  for (const axis of ['x', 'y', 'z'] as const) {
+    if (!(axis in model)) continue
+    const deg = model[axis] ?? 0
+    if (deg !== 0 && deg % 90 !== 0) return false
+  }
+  return true
+}
+
+function dirKey(dir: CardinalDir): string {
+  return `${dir[0]},${dir[1]},${dir[2]}`
+}
+
+function dirIndex(dir: CardinalDir): number {
+  const key = dirKey(dir)
+  const idx = DIR_KEYS.findIndex(d => dirKey(d) === key)
+  return idx >= 0 ? idx : 0
+}
+
+function emptyShape(): Uint16Array {
+  return new Uint16Array(16)
+}
+
+function orRectIntoShape(u0: number, v0: number, u1: number, v1: number, shape: Uint16Array) {
+  const minU = Math.max(0, Math.floor(Math.min(u0, u1)))
+  const maxU = Math.min(15, Math.ceil(Math.max(u0, u1)) - 1)
+  const minV = Math.max(0, Math.floor(Math.min(v0, v1)))
+  const maxV = Math.min(15, Math.ceil(Math.max(v0, v1)) - 1)
+  for (let row = minV; row <= maxV; row++) {
+    for (let col = minU; col <= maxU; col++) {
+      shape[row]! |= 1 << col
+    }
+  }
+}
+
+function rectIsSubsetOfShape(u0: number, v0: number, u1: number, v1: number, shape: Uint16Array): boolean {
+  const minU = Math.max(0, Math.floor(Math.min(u0, u1)))
+  const maxU = Math.min(15, Math.ceil(Math.max(u0, u1)) - 1)
+  const minV = Math.max(0, Math.floor(Math.min(v0, v1)))
+  const maxV = Math.min(15, Math.ceil(Math.max(v0, v1)) - 1)
+  for (let row = minV; row <= maxV; row++) {
+    for (let col = minU; col <= maxU; col++) {
+      if ((shape[row]! & (1 << col)) === 0) return false
+    }
+  }
+  return true
+}
+
+function rotatePointAboutCenter(globalMatrix: number[][] | null, point: [number, number, number]): [number, number, number] {
+  if (!globalMatrix) return point
+  const centered = vecsub3(point, BLOCK_CENTER)
+  const rotated = matmul3(globalMatrix, centered)
+  return [snapBlockUnit(rotated[0] + 8), snapBlockUnit(rotated[1] + 8), snapBlockUnit(rotated[2] + 8)]
+}
+
+function rectToFaceCorners3D(faceName: FaceName, rect: [number, number, number, number]): [number, number, number][] {
+  const [u0, v0, u1, v1] = rect
+  switch (faceName) {
+    case 'up':
+      return [
+        [u0, 16, v0],
+        [u1, 16, v0],
+        [u0, 16, v1],
+        [u1, 16, v1]
+      ]
+    case 'down':
+      return [
+        [u0, 0, v0],
+        [u1, 0, v0],
+        [u0, 0, v1],
+        [u1, 0, v1]
+      ]
+    case 'east':
+      return [
+        [16, v0, u0],
+        [16, v0, u1],
+        [16, v1, u0],
+        [16, v1, u1]
+      ]
+    case 'west':
+      return [
+        [0, v0, u0],
+        [0, v0, u1],
+        [0, v1, u0],
+        [0, v1, u1]
+      ]
+    case 'south':
+      return [
+        [u0, v0, 16],
+        [u1, v0, 16],
+        [u0, v1, 16],
+        [u1, v1, 16]
+      ]
+    case 'north':
+      return [
+        [u0, v0, 0],
+        [u1, v0, 0],
+        [u0, v1, 0],
+        [u1, v1, 0]
+      ]
+  }
+}
+
+function boundingRectOnWorldPlane(corners: [number, number, number][], worldDir: CardinalDir): [number, number, number, number] {
+  const dk = dirKey(worldDir)
+  let minU = 16
+  let minV = 16
+  let maxU = 0
+  let maxV = 0
+  for (const [x, y, z] of corners) {
+    let u: number
+    let v: number
+    if (dk === '0,1,0' || dk === '0,-1,0') {
+      u = x
+      v = z
+    } else if (dk === '1,0,0' || dk === '-1,0,0') {
+      u = z
+      v = y
+    } else {
+      u = x
+      v = y
+    }
+    minU = Math.min(minU, u)
+    maxU = Math.max(maxU, u)
+    minV = Math.min(minV, v)
+    maxV = Math.max(maxV, v)
+  }
+  return [minU, minV, maxU, maxV]
+}
+
+function worldFaceRect(
+  element: BlockElement,
+  faceName: FaceName,
+  worldFaceDir: CardinalDir,
+  globalMatrix: number[][] | null
+): [number, number, number, number] | null {
+  const proj = faceProjections[faceName]
+  if (!proj || !proj.touches(element)) return null
+  const rect = proj.rect(element)
+  const corners = rectToFaceCorners3D(faceName, rect).map(c => rotatePointAboutCenter(globalMatrix, c))
+  return boundingRectOnWorldPlane(corners, worldFaceDir)
+}
+
+export function blockRendersSolid(block: { name: string; transparent?: boolean }): boolean {
+  if (block.transparent) {
+    if (/glass|ice/.test(block.name)) return false
+    if (block.name.includes('leaves')) return false
+  }
+  if (block.name === 'water' || block.name === 'lava') return false
+  if (noOcclusionsSet.has(block.name)) return false
+  return true
+}
+
+function getBlockFromStateId(version: string, stateId: number) {
+  let Block = blockLoaderCache.get(version)
+  if (!Block) {
+    Block = PrismarineBlockLoader(version)
+    blockLoaderCache.set(version, Block)
+  }
+  return Block.fromStateId(stateId, 1)
+}
+
+function getAllShapesForState(version: string, stateId: number, blockProvider: WorldBlockProvider): Uint16Array[] {
+  const cacheKey = `${version}:${stateId}`
+  const cached = shapeCache.get(cacheKey)
+  if (cached) return cached
+
+  const shapes = DIR_KEYS.map(() => emptyShape())
+  const blockObj = getBlockFromStateId(version, stateId)
+  if (!blockObj || !blockRendersSolid(blockObj)) {
+    shapeCache.set(cacheKey, shapes)
+    return shapes
+  }
+
+  const models = blockProvider.getAllResolvedModels0_1({ name: blockObj.name, properties: blockObj.getProperties() }, false) as BlockModelPartsResolved
+
+  for (const modelVars of models ?? []) {
+    const model = modelVars[0]
+    if (!model) continue
+    if (!isAxisAligned90Rotation(model)) continue
+
+    const globalMatrix = buildModelGlobalMatrix(model)
+
+    for (const element of model.elements ?? []) {
+      for (const faceName of Object.keys(element.faces) as FaceName[]) {
+        const proj = faceProjections[faceName]
+        if (!proj || !proj.touches(element)) continue
+
+        const localDir = elemFaces[faceName].dir as CardinalDir
+        const worldDir = roundCardinalDir(matmul3(globalMatrix, localDir))
+        const rect = proj.rect(element)
+        const corners = rectToFaceCorners3D(faceName, rect).map(c => rotatePointAboutCenter(globalMatrix, c))
+        const [u0, v0, u1, v1] = boundingRectOnWorldPlane(corners, worldDir)
+        orRectIntoShape(u0, v0, u1, v1, shapes[dirIndex(worldDir)]!)
+      }
+    }
+  }
+
+  shapeCache.set(cacheKey, shapes)
+  return shapes
+}
+
+export function getOcclusionShape(version: string, stateId: number, worldDir: CardinalDir, blockProvider: WorldBlockProvider): Uint16Array {
+  return getAllShapesForState(version, stateId, blockProvider)[dirIndex(worldDir)]!
+}
+
+export function faceIsCulled(
+  version: string,
+  currentElement: BlockElement,
+  faceName: string,
+  neighborStateId: number,
+  currentBlock: BlockStateInfo,
+  blockProvider: WorldBlockProvider,
+  worldFaceDir: CardinalDir,
+  globalMatrix: number[][] | null
+): boolean {
+  const face = currentElement.faces[faceName]
+  if (!face?.cullface) return false
+
+  if (neighborStateId === currentBlock.stateId && /glass|ice/.test(currentBlock.name)) {
+    return true
+  }
+
+  if (!neighborStateId) return false
+
+  const faceRect = worldFaceRect(currentElement, faceName as FaceName, worldFaceDir, globalMatrix)
+  if (!faceRect) return false
+
+  const neighborShape = getOcclusionShape(version, neighborStateId, oppositeDir(worldFaceDir), blockProvider)
+  return rectIsSubsetOfShape(faceRect[0], faceRect[1], faceRect[2], faceRect[3], neighborShape)
+}