minecraft-renderer 0.1.79 → 0.1.81

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

@@ -28,7 +28,7 @@ const FACE_NAME_TO_INDEX: Record<string, number> = {
   east: 2,
   west: 3,
   south: 4,
-  north: 5,
+  north: 5
 }
 
 /**
@@ -42,17 +42,13 @@ export const AO_LIGHT_REMAP: readonly (readonly number[])[] = [
   [0, 1, 2, 3], // EAST
   [0, 1, 2, 3], // WEST
   [2, 3, 0, 1], // SOUTH
-  [2, 3, 0, 1], // NORTH
+  [2, 3, 0, 1] // NORTH
 ] as const
 
 /** Reorder per-corner AO or light values for shader-space corners. */
-export function remapCornersForShaderFace(
-  faceIdx: number,
-  values: number[],
-  fallback: number,
-): number[] {
+export function remapCornersForShaderFace(faceIdx: number, values: number[], fallback: number): number[] {
   const map = AO_LIGHT_REMAP[faceIdx] ?? AO_LIGHT_REMAP[0]
-  return map.map((i) => values[i] ?? fallback)
+  return map.map(i => values[i] ?? fallback)
 }
 
 export interface ShaderCubeBlockInput {
@@ -77,8 +73,8 @@ export interface ShaderCubeModelInput {
     y?: number
     z?: number
     elements?: Array<{
-      rotation?: { axis: string, angle: number, origin: number[] }
-      faces?: Record<string, { texture?: TextureEntry & { rotation?: number }, tintindex?: number }>
+      rotation?: { axis: string; angle: number; origin: number[] }
+      faces?: Record<string, { texture?: TextureEntry & { rotation?: number }; tintindex?: number }>
     }>
   }
 }
@@ -88,11 +84,7 @@ let textureIndexMapping: TextureIndexMapping | null = null
 let tintsMissingWarned = false
 
 /** Convert mc-assets texture scales (normalized or negative) to pixel tile size for index lookup. */
-function normalizeTextureEntryForTileIndex(
-  tex: { u?: number, v?: number, su?: number, sv?: number },
-  atlasWidth: number,
-  tileSize: number,
-): TextureEntry {
+function normalizeTextureEntryForTileIndex(tex: { u?: number; v?: number; su?: number; sv?: number }, atlasWidth: number, tileSize: number): TextureEntry {
   let u = tex.u ?? 0
   let v = tex.v ?? 0
   let su = tex.su ?? tileSize
@@ -109,20 +101,13 @@ function normalizeTextureEntryForTileIndex(
 type FaceTextureRef = TextureEntry & { tileIndex?: number }
 
 /** Prefer atlas `tileIndex` from block model (legacy path uses the same). */
-export function resolveFaceTileIndex(
-  tex: FaceTextureRef,
-  texMapping: TextureIndexMapping,
-): number {
+export function resolveFaceTileIndex(tex: FaceTextureRef, texMapping: TextureIndexMapping): number {
   const fromAtlas = tex.tileIndex
   // tile 0 is a special/atlas-padding slot; use pixel fallback for block faces
   if (typeof fromAtlas === 'number' && fromAtlas > 0 && fromAtlas < 4096) {
     return fromAtlas
   }
-  const entry = normalizeTextureEntryForTileIndex(
-    tex,
-    texMapping.getTilesPerRow() * 16,
-    16,
-  )
+  const entry = normalizeTextureEntryForTileIndex(tex, texMapping.getTilesPerRow() * 16, 16)
   return texMapping.tileIndexFromTextureEntry(entry)
 }
 
@@ -158,7 +143,7 @@ export function getShaderCubeResources(): {
       height: latest.height,
       tileSize: latest.tileSize ?? 16,
       suSv: latest.suSv ?? 16,
-      textures: latest.textures ?? {},
+      textures: latest.textures ?? {}
     })
   }
   return { tintPalette, textureIndexMapping }
@@ -181,7 +166,7 @@ export function isShaderCubeBlock(
   cached: ShaderCubeModelInput & { isCube: boolean },
   model: ShaderCubeModelInput['model'],
   sectionHeight: number,
-  texMapping: TextureIndexMapping,
+  texMapping: TextureIndexMapping
 ): boolean {
   if (sectionHeight !== 16) return false
   if (!cached.isCube) return false
@@ -214,14 +199,7 @@ export function isShaderCubeBlock(
   return true
 }
 
-function packWord0(
-  lx: number,
-  ly: number,
-  lz: number,
-  faceId: number,
-  tintIndex: number,
-  ao: number[],
-): number {
+function packWord0(lx: number, ly: number, lz: number, faceId: number, tintIndex: number, ao: number[]): number {
   let w = 0
   w |= (lx & 0xf) << WORD0.LX_SHIFT
   w |= (ly & 0xf) << WORD0.LY_SHIFT
@@ -246,13 +224,7 @@ function biasedSectionIndex(sectionBaseCoord: number): number {
   return (Math.floor(sectionBaseCoord / 16) + WORD3.SECTION_BIAS) & WORD3.SECTION_MASK
 }
 
-export function packWord2(
-  texIndex: number,
-  aoDiagonalFlip: boolean,
-  sectionBaseX: number,
-  sectionBaseY: number,
-  sectionBaseZ: number,
-): number {
+export function packWord2(texIndex: number, aoDiagonalFlip: boolean, sectionBaseX: number, sectionBaseY: number, sectionBaseZ: number): number {
   let w = texIndex & ((1 << WORD2.TEX_INDEX_BITS) - 1)
   if (aoDiagonalFlip) {
     w |= 1 << WORD2.DIAGONAL_FLAG_SHIFT
@@ -273,7 +245,7 @@ export function packWord3(sectionBaseX: number, sectionBaseZ: number): number {
 }
 
 /** Decode section base block coords from packed words (round-trip helper for tests). */
-export function decodeSectionBaseFromWords(word2: number, word3: number): { x: number, y: number, z: number } {
+export function decodeSectionBaseFromWords(word2: number, word3: number): { x: number; y: number; z: number } {
   const sX = ((word3 & 0xffff) | (((word2 >>> WORD2.SECTION_X_HI_SHIFT) & 0x3f) << 16)) - WORD3.SECTION_BIAS
   const sZ = (((word3 >>> 16) & 0xffff) | (((word2 >>> WORD2.SECTION_Z_HI_SHIFT) & 0x3f) << 16)) - WORD3.SECTION_BIAS
   const sY = ((word2 >>> WORD2.SECTION_Y_SHIFT) & ((1 << WORD2.SECTION_Y_BITS) - 1)) - 4
@@ -290,16 +262,13 @@ export function unpackTexIndexFromWord2(word2: number): number {
   return word2 & ((1 << WORD2.TEX_INDEX_BITS) - 1)
 }
 
-function packCornerLightByte (skyNorm: number, blockNorm: number): number {
+function packCornerLightByte(skyNorm: number, blockNorm: number): number {
   const sky4 = Math.min(15, Math.round(Math.max(0, skyNorm) * 15))
   const block4 = Math.min(15, Math.round(Math.max(0, blockNorm) * 15))
   return ((sky4 << 4) | block4) & 0xff
 }
 
-function lightCombinedForFace(
-  block: ShaderCubeBlockInput,
-  faceDataIndex: number,
-): number[] {
+function lightCombinedForFace(block: ShaderCubeBlockInput, faceDataIndex: number): number[] {
   const packed = block.light_combined?.[faceDataIndex]
   if (packed && packed.length === 4) {
     return packed
@@ -310,7 +279,7 @@ function lightCombinedForFace(
     return sky.map((s, i) => packCornerLightByte(s ?? 1, blockL[i] ?? 0))
   }
   const floats = block.light_data?.[faceDataIndex] ?? [1, 1, 1, 1]
-  return floats.map((f) => packCornerLightByte(f, 0))
+  return floats.map(f => packCornerLightByte(f, 0))
 }
 
 function buildWasmFaceToDataIndex(visibleFaces: number): Record<number, number> {
@@ -326,7 +295,7 @@ function buildWasmFaceToDataIndex(visibleFaces: number): Record<number, number>
 }
 
 export type BuildShaderCubeInstancesOpts = {
-  sectionOrigin: { x: number, y: number, z: number }
+  sectionOrigin: { x: number; y: number; z: number }
   sectionHeight: number
   biome?: string
   tintPalette: TintPalette
@@ -336,6 +305,8 @@ export type BuildShaderCubeInstancesOpts = {
    * diagonal flip — matches legacy render-from-wasm path.
    */
   doAO?: boolean
+  /** Bitmask of faces to skip (same indices as visible_faces: 0=up … 5=north). */
+  forceCullMask?: number
 }
 
 /**
@@ -347,16 +318,9 @@ export function tryBuildShaderCubeInstances(
   cached: ShaderCubeModelInput & { isCube: boolean },
   model: ShaderCubeModelInput['model'],
   opts: BuildShaderCubeInstancesOpts,
-  words: number[],
+  words: number[]
 ): boolean {
-  const {
-    sectionOrigin,
-    sectionHeight,
-    biome,
-    tintPalette,
-    textureIndexMapping,
-    doAO = true,
-  } = opts
+  const { sectionOrigin, sectionHeight, biome, tintPalette, textureIndexMapping, doAO = true, forceCullMask = 0 } = opts
 
   if (!isShaderCubeBlock(cached, model, sectionHeight, textureIndexMapping)) {
     return false
@@ -375,6 +339,7 @@ export function tryBuildShaderCubeInstances(
   for (const faceName of WASM_FACE_ORDER) {
     const faceIdx = FACE_NAME_TO_INDEX[faceName]
     if ((block.visible_faces & (1 << faceIdx)) === 0) continue
+    if ((forceCullMask & (1 << faceIdx)) !== 0) continue
 
     const faceDataIndex = wasmFaceToDataIndex[faceIdx]
     if (faceDataIndex === undefined) continue
@@ -404,20 +369,14 @@ export function tryBuildShaderCubeInstances(
       aoDiagonalFlip = false
     }
 
-    const tintIndex = tintPalette.getTintIndex(
-      eFace.tintindex,
-      cached.blockName,
-      cached.blockProps,
-      biome ?? 'plains',
-    )
+    const tintIndex = tintPalette.getTintIndex(eFace.tintindex, cached.blockName, cached.blockProps, biome ?? 'plains')
 
     words.push(
       packWord0(lx, ly, lz, faceIdx, tintIndex, ao),
       packWord1(lightCombined),
       packWord2(texIndex, aoDiagonalFlip, sectionOrigin.x, sectionOrigin.y, sectionOrigin.z),
-      packWord3(sectionOrigin.x, sectionOrigin.z),
+      packWord3(sectionOrigin.x, sectionOrigin.z)
     )
-
   }
 
   return true
@@ -429,7 +388,7 @@ export function buildShaderCubesFromWords(wordQuads: number[]): ShaderCubesOutpu
   return {
     words: new Uint32Array(wordQuads),
     count: faceCount,
-    formatVersion: SHADER_CUBES_FORMAT_VERSION,
+    formatVersion: SHADER_CUBES_FORMAT_VERSION
   }
 }
 

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

@@ -0,0 +1,82 @@
+//@ts-nocheck
+import { test, expect } from 'vitest'
+import Chunks from 'prismarine-chunk'
+import MinecraftData from 'minecraft-data'
+import { Vec3 } from 'vec3'
+import { CAMERA_COLLISION_BYTES_PER_SECTION, CameraCollisionBlockCache } from '../../three/cameraCollisionBlockCache'
+
+const VERSION = '1.16.5'
+
+function makeChunkWithStoneFloor(y: number) {
+  const mcData = MinecraftData(VERSION)
+  const Chunk = Chunks(VERSION) as any
+  const chunk = new Chunk(undefined as any)
+  const stoneId = mcData.blocksByName.stone.defaultState
+  for (let x = 0; x < 16; x++) {
+    for (let z = 0; z < 16; z++) {
+      chunk.setBlockStateId(new Vec3(x, y, z), stoneId)
+    }
+  }
+  return chunk
+}
+
+test('CameraCollisionBlockCache: ingestColumn sets solids and skips air sections', () => {
+  const cache = new CameraCollisionBlockCache(VERSION)
+  cache.setWorldBounds(0, 256)
+  const chunk = makeChunkWithStoneFloor(64)
+  cache.ingestColumn(0, 0, chunk.toJson())
+
+  expect(cache.isSolidBlock(0, 64, 0)).toBe(true)
+  expect(cache.isSolidBlock(15, 64, 15)).toBe(true)
+  expect(cache.isSolidBlock(0, 65, 0)).toBe(false)
+  expect(cache.isSolidBlock(0, 0, 0)).toBe(false)
+
+  // One 16³ section at y=64 only (not the whole column height).
+  expect(cache.getAllocatedSectionCount()).toBe(1)
+  expect(cache.getAllocatedBytes()).toBe(CAMERA_COLLISION_BYTES_PER_SECTION)
+})
+
+test('CameraCollisionBlockCache: setBlockStateId updates and frees empty sections', () => {
+  const cache = new CameraCollisionBlockCache(VERSION)
+  cache.setWorldBounds(0, 256)
+  const mcData = MinecraftData(VERSION)
+  const stoneId = mcData.blocksByName.stone.defaultState
+
+  cache.setBlockStateId(5, 70, 5, stoneId)
+  expect(cache.isSolidBlock(5, 70, 5)).toBe(true)
+  expect(cache.getAllocatedSectionCount()).toBe(1)
+
+  cache.setBlockStateId(5, 70, 5, 0)
+  expect(cache.isSolidBlock(5, 70, 5)).toBe(false)
+  expect(cache.getAllocatedSectionCount()).toBe(0)
+})
+
+test('CameraCollisionBlockCache: removeColumn frees all section bitsets in column', () => {
+  const cache = new CameraCollisionBlockCache(VERSION)
+  cache.setWorldBounds(0, 256)
+  const mcData = MinecraftData(VERSION)
+  const stoneId = mcData.blocksByName.stone.defaultState
+
+  cache.setBlockStateId(0, 64, 0, stoneId)
+  cache.setBlockStateId(0, 80, 0, stoneId)
+  expect(cache.getAllocatedSectionCount()).toBe(2)
+
+  cache.removeColumn(0, 0)
+  expect(cache.getAllocatedSectionCount()).toBe(0)
+  expect(cache.isSolidBlock(0, 64, 0)).toBe(false)
+})
+
+test('CameraCollisionBlockCache: clear and setWorldBounds drop all sections', () => {
+  const cache = new CameraCollisionBlockCache(VERSION)
+  cache.setWorldBounds(0, 256)
+  const chunk = makeChunkWithStoneFloor(10)
+  cache.ingestColumn(16, 32, chunk.toJson())
+  expect(cache.getAllocatedSectionCount()).toBeGreaterThan(0)
+
+  cache.clear()
+  expect(cache.getAllocatedSectionCount()).toBe(0)
+
+  cache.ingestColumn(16, 32, chunk.toJson())
+  cache.setWorldBounds(-64, 320)
+  expect(cache.getAllocatedSectionCount()).toBe(0)
+})

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

@@ -0,0 +1,307 @@
+//@ts-nocheck
+import { test, expect, beforeAll, beforeEach } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+import Chunks from 'prismarine-chunk'
+import MinecraftData from 'minecraft-data'
+import { Vec3 } from 'vec3'
+import PrismarineBlockLoader from 'prismarine-block'
+import blocksAtlasesJson from 'mc-assets/dist/blocksAtlases.json'
+import blockStatesModels from 'mc-assets/dist/blockStatesModels.json'
+import { World } from '../../mesher-shared/world'
+import { setBlockStatesData, getSectionGeometry } from '../../mesher-shared/models'
+import { resetFaceOcclusionCache } from '../../mesher-shared/faceOcclusion'
+import { convertChunkToWasm } from '../bridge/convertChunk'
+import { renderWasmOutputToGeometry } from '../bridge/render-from-wasm'
+
+const VERSION = '1.18.2'
+const SECTION_Y = 0
+const SECTION_HEIGHT = 16
+
+const DRY_STAIR_PROPS = { facing: 'east', half: 'bottom', shape: 'straight', waterlogged: false } as const
+
+type BlockSpec = { x: number; y: number; z: number; name: string; props?: Record<string, string | boolean> }
+
+let wasmModule: typeof import('../runtime-build/wasm_mesher.js')
+
+beforeAll(async () => {
+  wasmModule = await import('../runtime-build/wasm_mesher.js')
+  const wasmDir = dirname(fileURLToPath(import.meta.url))
+  const wasmBytes = readFileSync(join(wasmDir, '../runtime-build/wasm_mesher_bg.wasm'))
+  wasmModule.initSync(wasmBytes)
+})
+
+beforeEach(() => {
+  resetFaceOcclusionCache()
+  const mcData = MinecraftData(VERSION)
+  setBlockStatesData(blockStatesModels, blocksAtlasesJson, false, true, VERSION, { blocks: mcData.blocksArray })
+  ;(globalThis as any).__wasmBlockModelCache = new Map()
+})
+
+function resolveStateId(mcData: ReturnType<typeof MinecraftData>, name: string, props?: Record<string, string | boolean>) {
+  const block = mcData.blocksByName[name]
+  if (!block) throw new Error(`Unknown block: ${name}`)
+  if (!props || Object.keys(props).length === 0) return block.defaultState
+  const Block = PrismarineBlockLoader(VERSION)
+  const requested = { ...props }
+  if (!('waterlogged' in requested)) requested.waterlogged = false
+
+  const matches: number[] = []
+  for (let id = block.minStateId; id <= block.maxStateId; id++) {
+    const stateProps = Block.fromStateId(id, 1).getProperties() as Record<string, string | boolean>
+    let match = true
+    for (const [key, val] of Object.entries(requested)) {
+      if (stateProps[key] !== val) {
+        match = false
+        break
+      }
+    }
+    if (match) matches.push(id)
+  }
+  if (matches.length === 0) throw new Error(`No state for ${name} ${JSON.stringify(props)}`)
+  return matches[0]!
+}
+
+function buildWorld(blocks: BlockSpec[]): World {
+  const mcData = MinecraftData(VERSION)
+  const Chunk = Chunks(VERSION) as any
+  const chunk = new Chunk(undefined as any)
+
+  for (const b of blocks) {
+    const id = resolveStateId(mcData, b.name, b.props)
+    chunk.setBlockStateId(new Vec3(b.x, b.y, b.z), id)
+    chunk.setBlockLight(new Vec3(b.x, b.y, b.z), 15)
+    chunk.setSkyLight(new Vec3(b.x, b.y, b.z), 15)
+  }
+
+  const world = new World(VERSION)
+  world.addColumn(0, 0, chunk.toJson())
+  return world
+}
+
+function countQuadsFromLegacy(world: World): number {
+  const geo = getSectionGeometry(0, SECTION_Y, 0, world, SECTION_HEIGHT)
+  const opaque = geo.indicesCount / 6
+  const blend = geo.blend ? geo.blend.indices.length / 6 : 0
+  return opaque + blend
+}
+
+function countQuadsFromWasm(world: World, shaderCubes = false): number {
+  const column = world.getColumn(0, 0)!
+  const conversion = convertChunkToWasm(column, VERSION, 0, 0, SECTION_Y, SECTION_Y + SECTION_HEIGHT, SECTION_Y, SECTION_HEIGHT)
+  const wasmResult = wasmModule.generate_geometry(
+    0,
+    SECTION_Y,
+    0,
+    SECTION_HEIGHT,
+    SECTION_Y,
+    SECTION_Y + SECTION_HEIGHT,
+    SECTION_Y,
+    conversion.blockStates,
+    conversion.blockLight,
+    conversion.skyLight,
+    conversion.biomesArray,
+    conversion.invisibleBlocks,
+    conversion.transparentBlocks,
+    conversion.noAoBlocks,
+    conversion.cullIdenticalBlocks,
+    conversion.occludingBlocks,
+    true,
+    false,
+    15
+  )
+  const section = renderWasmOutputToGeometry(wasmResult, VERSION, '0,0,0', { x: 8, y: 8, z: 8 }, world, {
+    sectionHeight: SECTION_HEIGHT,
+    shaderCubes
+  })
+  const opaque = section.geometry.indices.length / 6
+  const blend = section.blendGeometry?.indices.length ? section.blendGeometry.indices.length / 6 : 0
+  const shader = shaderCubes ? (section.shaderCubes?.count ?? 0) : 0
+  return opaque + blend + shader
+}
+
+function assertMesherParity(world: World, expectedQuads: number) {
+  const legacy = countQuadsFromLegacy(world)
+  const wasmLegacy = countQuadsFromWasm(world, false)
+  const wasmShader = countQuadsFromWasm(world, true)
+  expect(legacy).toBe(expectedQuads)
+  expect(wasmLegacy).toBe(expectedQuads)
+  expect(wasmShader).toBe(expectedQuads)
+}
+
+function farmlandFieldBlocks(): BlockSpec[] {
+  const blocks: BlockSpec[] = []
+  for (let z = 0; z < 16; z++) {
+    for (let x = 0; x < 16; x++) {
+      blocks.push({ x, y: 4, z, name: 'dirt' })
+      blocks.push({ x, y: 5, z, name: 'farmland' })
+    }
+  }
+  return blocks
+}
+
+function slabFieldBlocks(): BlockSpec[] {
+  const blocks: BlockSpec[] = []
+  for (let z = 0; z < 4; z++) {
+    for (let x = 0; x < 4; x++) {
+      blocks.push({ x, y: 0, z, name: 'stone' })
+      blocks.push({ x, y: 1, z, name: 'stone_slab' })
+    }
+  }
+  return blocks
+}
+
+function cutCopperStairsRunBlocks(): BlockSpec[] {
+  const blocks: BlockSpec[] = []
+  for (let x = 0; x < 8; x++) {
+    blocks.push({ x, y: 0, z: 0, name: 'cut_copper_stairs', props: { ...DRY_STAIR_PROPS } })
+    blocks.push({ x, y: 0, z: 1, name: 'cut_copper_stairs', props: { ...DRY_STAIR_PROPS } })
+  }
+  return blocks
+}
+
+function cutCopperStairsAscentBlocks(): BlockSpec[] {
+  const blocks: BlockSpec[] = []
+  for (let x = 0; x < 6; x++) {
+    blocks.push({ x, y: 0, z: 0, name: 'cut_copper_stairs', props: { ...DRY_STAIR_PROPS } })
+    blocks.push({ x, y: 1, z: 0, name: 'cut_copper_stairs', props: { ...DRY_STAIR_PROPS } })
+  }
+  return blocks
+}
+
+function cutCopperStairsWestRunBlocks(): BlockSpec[] {
+  const blocks: BlockSpec[] = []
+  for (let x = 0; x < 8; x++) {
+    blocks.push({
+      x,
+      y: 0,
+      z: 0,
+      name: 'cut_copper_stairs',
+      props: { facing: 'west', half: 'bottom', shape: 'straight', waterlogged: false }
+    })
+    blocks.push({
+      x,
+      y: 0,
+      z: 1,
+      name: 'cut_copper_stairs',
+      props: { facing: 'west', half: 'bottom', shape: 'straight', waterlogged: false }
+    })
+  }
+  return blocks
+}
+
+function cutCopperStairsEastWestMirrorBlocks(): BlockSpec[] {
+  const blocks: BlockSpec[] = []
+  for (let x = 0; x < 3; x++) {
+    blocks.push({ x, y: 0, z: 0, name: 'cut_copper_stairs', props: { ...DRY_STAIR_PROPS } })
+  }
+  for (let x = 0; x < 3; x++) {
+    blocks.push({
+      x: x + 4,
+      y: 0,
+      z: 0,
+      name: 'cut_copper_stairs',
+      props: { facing: 'west', half: 'bottom', shape: 'straight', waterlogged: false }
+    })
+  }
+  return blocks
+}
+
+function countQuadsForFacing(facing: 'east' | 'west' | 'south' | 'north', half: 'bottom' | 'top'): number {
+  const world = buildWorld([{ x: 0, y: 0, z: 0, name: 'cut_copper_stairs', props: { facing, half, shape: 'straight', waterlogged: false } }])
+  return countQuadsFromWasm(world)
+}
+
+function glassLeavesClusterBlocks(): BlockSpec[] {
+  return [
+    { x: 0, y: 0, z: 0, name: 'stone' },
+    { x: 1, y: 0, z: 0, name: 'glass' },
+    { x: 0, y: 0, z: 1, name: 'oak_leaves' },
+    { x: 1, y: 0, z: 1, name: 'glass' }
+  ]
+}
+
+test('culling regression: farmland field — internal side faces culled (pre-fix ~8704 quads)', () => {
+  const world = buildWorld(farmlandFieldBlocks())
+  // Post-fix: 640 quads (legacy + WASM agree). Pre-fix was ~8704 with all internal farmland sides drawn.
+  assertMesherParity(world, 640)
+})
+
+test('culling regression: slab field', () => {
+  const world = buildWorld(slabFieldBlocks())
+  assertMesherParity(world, 64)
+})
+
+test('culling regression: single cut copper stair legacy vs wasm', () => {
+  const world = buildWorld([{ x: 0, y: 0, z: 0, name: 'cut_copper_stairs', props: { ...DRY_STAIR_PROPS } }])
+  assertMesherParity(world, 11)
+})
+
+test('culling regression: cut copper stairs run (east-facing)', () => {
+  const world = buildWorld(cutCopperStairsRunBlocks())
+  assertMesherParity(world, 116)
+})
+
+test('culling regression: cut copper stairs run (west-facing, rotated)', () => {
+  const world = buildWorld(cutCopperStairsWestRunBlocks())
+  assertMesherParity(world, 116)
+})
+
+test('culling regression: cut copper stairs ascent', () => {
+  const world = buildWorld(cutCopperStairsAscentBlocks())
+  assertMesherParity(world, 106)
+})
+
+test('culling regression: 3 east + 3 west stairs mirror user scenario', () => {
+  const world = buildWorld(cutCopperStairsEastWestMirrorBlocks())
+  const legacy = countQuadsFromLegacy(world)
+  const wasmLegacy = countQuadsFromWasm(world, false)
+  const wasmShader = countQuadsFromWasm(world, true)
+  expect(legacy).toBe(wasmLegacy)
+  expect(legacy).toBe(wasmShader)
+  // 6 stairs with 2 internal interfaces culled per row; gap at x=3 prevents east↔west culling
+  expect(wasmShader).toBe(58)
+  expect(wasmShader).toBeLessThan(3 * 11 * 2)
+})
+
+test('culling regression: all stair facings and top half match east baseline', () => {
+  const east = countQuadsForFacing('east', 'bottom')
+  expect(countQuadsForFacing('west', 'bottom')).toBe(east)
+  expect(countQuadsForFacing('south', 'bottom')).toBe(east)
+  expect(countQuadsForFacing('north', 'bottom')).toBe(east)
+  expect(countQuadsForFacing('east', 'top')).toBe(east)
+})
+
+test('culling regression: glass/leaves cluster — see-through blocks not over-culled', () => {
+  const world = buildWorld(glassLeavesClusterBlocks())
+  // Leaves never occlude; glass self-culls. Baseline locks parity (pre shape-cull guard was 24 legacy-only).
+  assertMesherParity(world, 20)
+})
+
+test('shader cubes: dirt UP face culled under farmland', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'dirt' },
+    { x: 0, y: 1, z: 0, name: 'farmland' }
+  ])
+  assertMesherParity(world, 10)
+})
+
+test('shader cubes: dirt DOWN face culled under top slab', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'stone_slab', props: { type: 'top' } },
+    { x: 0, y: 1, z: 0, name: 'dirt' }
+  ])
+  assertMesherParity(world, 10)
+})
+
+test('shader cubes: dirt side not culled beside bottom slab', () => {
+  const world = buildWorld([
+    { x: 0, y: 0, z: 0, name: 'dirt' },
+    { x: 1, y: 0, z: 0, name: 'stone_slab', props: { type: 'bottom' } }
+  ])
+  const legacy = countQuadsFromLegacy(world)
+  const wasmShader = countQuadsFromWasm(world, true)
+  expect(wasmShader).toBe(legacy)
+  expect(wasmShader).toBeGreaterThan(5)
+})

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

@@ -37,9 +37,9 @@ import { extractColumnHeightmap, WasmGeometryOutput } from '../bridge/render-fro
 
 const VERSION = '1.16.5'
 
-type BlockSpec = { x: number, y: number, z: number, name: string }
+type BlockSpec = { x: number; y: number; z: number; name: string }
 
-function buildWorld(blocks: BlockSpec[]): { world: World, invisibleStateIds: Set<number> } {
+function buildWorld(blocks: BlockSpec[]): { world: World; invisibleStateIds: Set<number> } {
   const mcData = MinecraftData(VERSION)
   const Chunk = Chunks(VERSION) as any
   const chunk = new Chunk(undefined as any)
@@ -74,12 +74,7 @@ function buildWorld(blocks: BlockSpec[]): { world: World, invisibleStateIds: Set
  * Returns a plain `number[]` matching the on-the-wire shape of Rust's
  * `Vec<i16>` (length 256, indexed `z*16+x`, sentinel `-32768`).
  */
-function simulateRustColumnHeightmap(
-  world: World,
-  invisibleStateIds: Set<number>,
-  worldMinY: number,
-  worldMaxY: number
-): number[] {
+function simulateRustColumnHeightmap(world: World, invisibleStateIds: Set<number>, worldMinY: number, worldMaxY: number): number[] {
   const heightmap = new Array<number>(256).fill(-32768)
   const column = world.getColumn(0, 0)
   if (!column) return heightmap
@@ -105,20 +100,15 @@ function makeWasmOutputWithHeightmap(heightmap: number[]): WasmGeometryOutput {
     blocks: [],
     block_count: 0,
     block_iterations: 0,
-    heightmap,
+    heightmap
   }
 }
 
-function runParity(blocks: BlockSpec[]): { js: Int16Array, rust: Int16Array } {
+function runParity(blocks: BlockSpec[]): { js: Int16Array; rust: Int16Array } {
   const { world, invisibleStateIds } = buildWorld(blocks)
   const js = computeHeightmap(world, 0, 0)
 
-  const rustShaped = simulateRustColumnHeightmap(
-    world,
-    invisibleStateIds,
-    world.config.worldMinY,
-    world.config.worldMaxY
-  )
+  const rustShaped = simulateRustColumnHeightmap(world, invisibleStateIds, world.config.worldMinY, world.config.worldMaxY)
   const wasmOutput = makeWasmOutputWithHeightmap(rustShaped)
   const rust = extractColumnHeightmap(wasmOutput)
   expect(rust).not.toBeNull()
@@ -156,7 +146,7 @@ test('heightmap parity: varied heights, every column populated (Rust == JS)', ()
   blocks.push({ x: 2, y: 80, z: 0, name: 'oak_log' }) // top wins over y=64 below
   blocks.push({ x: 2, y: 64, z: 0, name: 'stone' })
   blocks.push({ x: 5, y: 255, z: 5, name: 'stone' }) // high-Y edge (worldMaxY-1)
-  blocks.push({ x: 6, y: 0, z: 6, name: 'stone' })   // low-Y edge (worldMinY)
+  blocks.push({ x: 6, y: 0, z: 6, name: 'stone' }) // low-Y edge (worldMinY)
   // Invisible block above a real surface must be skipped on both sides.
   blocks.push({ x: 7, y: 10, z: 7, name: 'stone' })
   blocks.push({ x: 7, y: 11, z: 7, name: 'barrier' })
@@ -172,7 +162,7 @@ test('heightmap parity: varied heights, every column populated (Rust == JS)', ()
   expect(js[0 * 16 + 1]).toBe(70)
   expect(js[0 * 16 + 2]).toBe(80)
   expect(js[5 * 16 + 5]).toBe(255)
-  expect(js[6 * 16 + 6]).toBe(5)  // y=0 stone is below the y=5 floor stone
+  expect(js[6 * 16 + 6]).toBe(5) // y=0 stone is below the y=5 floor stone
   expect(js[7 * 16 + 7]).toBe(10) // barrier above must be skipped
   expect(js[8 * 16 + 8]).toBe(12) // cave_air above must be skipped
 })