minecraft-renderer 0.1.48 → 0.1.49

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

@@ -0,0 +1,396 @@
+//@ts-nocheck
+/**
+ * Pack visible WASM block faces into GPU-instanced shader words (4×Uint32 per face).
+ * Each emitted instance becomes one face quad on the shader-cube mesh; the legacy
+ * vertex path is bypassed for blocks that pass {@link isShaderCubeBlock}.
+ */
+
+import blocksAtlasesJson from 'mc-assets/dist/blocksAtlases.json'
+import { WORD0, WORD1, WORD2, WORD3 } from '../../three/shaders/cubeBlockShader'
+import { TextureIndexMapping, type TextureEntry } from '../../three/shaders/textureIndexMapping'
+import { TintPalette } from '../../three/shaders/tintPalette'
+
+export const SHADER_CUBES_FORMAT_VERSION = 2 as const
+export const SHADER_CUBES_WORDS_PER_FACE = 4 as const
+
+export type ShaderCubesOutput = {
+  words: Uint32Array
+  /** Number of visible faces (= instances × 1; each instance is one face) */
+  count: number
+  formatVersion: typeof SHADER_CUBES_FORMAT_VERSION
+}
+
+const CARDINAL_FACE_NAMES = ['up', 'down', 'east', 'west', 'south', 'north'] as const
+const WASM_FACE_ORDER = CARDINAL_FACE_NAMES
+const FACE_NAME_TO_INDEX: Record<string, number> = {
+  up: 0,
+  down: 1,
+  east: 2,
+  west: 3,
+  south: 4,
+  north: 5,
+}
+
+/**
+ * WASM/elemFaces corner order → shader vi corner order (BASE/DU/DV in cubeBlockShader).
+ * UP/DOWN/EAST/WEST match 1:1; NORTH/SOUTH need a 180° corner rotation because their
+ * BASE origin is on the opposite side of the quad.
+ */
+export const AO_LIGHT_REMAP: readonly (readonly number[])[] = [
+  [0, 1, 2, 3], // UP
+  [0, 1, 2, 3], // DOWN
+  [0, 1, 2, 3], // EAST
+  [0, 1, 2, 3], // WEST
+  [2, 3, 0, 1], // SOUTH
+  [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[] {
+  const map = AO_LIGHT_REMAP[faceIdx] ?? AO_LIGHT_REMAP[0]
+  return map.map((i) => values[i] ?? fallback)
+}
+
+export interface ShaderCubeBlockInput {
+  position: [number, number, number]
+  visible_faces: number
+  ao_data: number[][]
+  light_data: number[][]
+  light_combined?: number[][]
+}
+
+export interface ShaderCubeModelInput {
+  blockName: string
+  blockProps: Record<string, any>
+  isCube: boolean
+  /** Resolved variant `models[variantIndex][0]` */
+  model: {
+    x?: number
+    y?: number
+    z?: number
+    elements?: Array<{
+      rotation?: { axis: string, angle: number, origin: number[] }
+      faces?: Record<string, { texture?: TextureEntry & { rotation?: number }, tintindex?: number }>
+    }>
+  }
+}
+
+let tintPalette: TintPalette | null = null
+let textureIndexMapping: TextureIndexMapping | null = null
+
+/** 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 {
+  let u = tex.u ?? 0
+  let v = tex.v ?? 0
+  let su = tex.su ?? tileSize
+  let sv = tex.sv ?? tileSize
+  if (u > 0 && u <= 1) u = Math.round(u * atlasWidth)
+  if (v > 0 && v <= 1) v = Math.round(v * atlasWidth)
+  if (Math.abs(su) > 0 && Math.abs(su) <= 1) su = Math.round(Math.abs(su) * atlasWidth) || tileSize
+  else if (su < 0) su = tileSize
+  if (Math.abs(sv) > 0 && Math.abs(sv) <= 1) sv = Math.round(Math.abs(sv) * atlasWidth) || tileSize
+  else if (sv < 0) sv = tileSize
+  return { u, v, su, sv }
+}
+
+type FaceTextureRef = TextureEntry & { tileIndex?: number }
+
+/** Prefer atlas `tileIndex` from block model (legacy path uses the same). */
+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,
+  )
+  return texMapping.tileIndexFromTextureEntry(entry)
+}
+
+/** Tints via esbuild-data (worker plugin, web-client rsbuild alias, vitest alias). */
+function getTintsJson(): Record<string, any> {
+  const mod = require('esbuild-data') as { tints?: Record<string, any>, default?: { tints?: Record<string, any> } }
+  return mod.tints ?? mod.default?.tints ?? {}
+}
+
+export function getShaderCubeResources(): {
+  tintPalette: TintPalette
+  textureIndexMapping: TextureIndexMapping
+} {
+  if (!tintPalette) {
+    tintPalette = TintPalette.fromTintsData(getTintsJson())
+    tintPalette.createTexture()
+  }
+  if (!textureIndexMapping) {
+    const latest = (blocksAtlasesJson as any).latest ?? (blocksAtlasesJson as any)
+    textureIndexMapping = new TextureIndexMapping({
+      width: latest.width,
+      height: latest.height,
+      tileSize: latest.tileSize ?? 16,
+      suSv: latest.suSv ?? 16,
+      textures: latest.textures ?? {},
+    })
+  }
+  return { tintPalette, textureIndexMapping }
+}
+
+/** Reset cached palette/atlas (tests). */
+export function resetShaderCubeResources(): void {
+  tintPalette = null
+  textureIndexMapping = null
+}
+
+/**
+ * Returns true when the block is a plain 1×1×1 cube that the instanced shader path
+ * can render exactly like the legacy mesher (no model rotation, single un-rotated
+ * element with all 6 cardinal faces present, atlas matches shader gate).
+ * Pass the already-resolved model variant (`modelVars[variantIndex][0]`).
+ */
+export function isShaderCubeBlock(
+  cached: ShaderCubeModelInput & { isCube: boolean },
+  model: ShaderCubeModelInput['model'],
+  sectionHeight: number,
+  texMapping: TextureIndexMapping,
+): boolean {
+  if (sectionHeight !== 16) return false
+  if (!cached.isCube) return false
+  if (!texMapping.isValid()) return false
+
+  for (const axis of ['x', 'y', 'z'] as const) {
+    if (model[axis]) return false
+  }
+
+  const elements = model.elements ?? []
+  if (elements.length !== 1) return false
+  const element = elements[0]
+  if (element.rotation) return false
+
+  const faces = element.faces
+  if (!faces) return false
+
+  for (const faceName of CARDINAL_FACE_NAMES) {
+    const eFace = faces[faceName]
+    if (!eFace) return false
+    // Shader UV table is hardcoded per-face; arbitrary per-face UV rotation forces legacy.
+    if ((eFace as { rotation?: number }).rotation) return false
+    const tex = eFace.texture
+    if (!tex) return false
+    if (resolveFaceTileIndex(tex as FaceTextureRef, texMapping) < 0) {
+      return false
+    }
+  }
+
+  return true
+}
+
+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
+  w |= (lz & 0xf) << WORD0.LZ_SHIFT
+  w |= (faceId & 7) << WORD0.FACE_SHIFT
+  w |= (tintIndex & 0xff) << WORD0.TINT_SHIFT
+  for (let i = 0; i < WORD0.NUM_CORNERS; i++) {
+    w |= ((ao[i] ?? 3) & 3) << (WORD0.AO_SHIFT + i * WORD0.AO_BITS_PER_CORNER)
+  }
+  return w >>> 0
+}
+
+function packWord1(lightCombined: number[]): number {
+  let w = 0
+  for (let i = 0; i < WORD1.NUM_CORNERS; i++) {
+    w |= ((lightCombined[i] ?? 255) & 0xff) << (i * WORD1.LIGHT_BITS_PER_CORNER)
+  }
+  return w >>> 0
+}
+
+export function packWord2(texIndex: number, aoDiagonalFlip: boolean, sectionBaseY: number): number {
+  let w = texIndex & ((1 << WORD2.TEX_INDEX_BITS) - 1)
+  if (aoDiagonalFlip) {
+    w |= 1 << WORD2.DIAGONAL_FLAG_SHIFT
+  }
+  const sectionY = ((Math.floor(sectionBaseY / 16) + 4) & 0x1f) << WORD2.SECTION_Y_SHIFT
+  w |= sectionY
+  return w >>> 0
+}
+
+export function packWord3(sectionBaseX: number, sectionBaseZ: number): number {
+  const sx = (Math.floor(sectionBaseX / 16) + WORD3.SECTION_BIAS) & 0xffff
+  const sz = (Math.floor(sectionBaseZ / 16) + WORD3.SECTION_BIAS) & 0xffff
+  return (sx | (sz << 16)) >>> 0
+}
+
+/** 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 } {
+  const sX = (word3 & 0xffff) - WORD3.SECTION_BIAS
+  const sZ = ((word3 >>> 16) & 0xffff) - WORD3.SECTION_BIAS
+  const sY = ((word2 >>> WORD2.SECTION_Y_SHIFT) & ((1 << WORD2.SECTION_Y_BITS) - 1)) - 4
+  return { x: sX * 16, y: sY * 16, z: sZ * 16 }
+}
+
+/** EMPTY sentinel for a freed global-buffer instance slot. */
+export function packWord2Empty(): number {
+  return (1 << WORD2.EMPTY_SHIFT) >>> 0
+}
+
+/** 12-bit texture tile index from packed word2. */
+export function unpackTexIndexFromWord2(word2: number): number {
+  return word2 & ((1 << WORD2.TEX_INDEX_BITS) - 1)
+}
+
+function lightCombinedForFace(
+  block: ShaderCubeBlockInput,
+  faceDataIndex: number,
+): number[] {
+  const packed = block.light_combined?.[faceDataIndex]
+  if (packed && packed.length === 4) {
+    return packed
+  }
+  const floats = block.light_data[faceDataIndex] ?? [1, 1, 1, 1]
+  return floats.map((f) => {
+    if (f >= 1) return 255
+    return Math.min(255, Math.round(f * 255))
+  })
+}
+
+function buildWasmFaceToDataIndex(visibleFaces: number): Record<number, number> {
+  const map: Record<number, number> = {}
+  let dataIndex = 0
+  for (const faceName of WASM_FACE_ORDER) {
+    const faceIdx = FACE_NAME_TO_INDEX[faceName]
+    if ((visibleFaces & (1 << faceIdx)) !== 0) {
+      map[faceIdx] = dataIndex++
+    }
+  }
+  return map
+}
+
+export type BuildShaderCubeInstancesOpts = {
+  sectionOrigin: { x: number, y: number, z: number }
+  sectionHeight: number
+  biome?: string
+  tintPalette: TintPalette
+  textureIndexMapping: TextureIndexMapping
+  /**
+   * When false (blocks with model.ao === false), emit full-bright faces without AO
+   * diagonal flip — matches legacy render-from-wasm path.
+   */
+  doAO?: boolean
+}
+
+/**
+ * Pack all visible faces of one block into `words` (4 uints per face).
+ * Returns false if the block must use the legacy vertex path.
+ */
+export function tryBuildShaderCubeInstances(
+  block: ShaderCubeBlockInput,
+  cached: ShaderCubeModelInput & { isCube: boolean },
+  model: ShaderCubeModelInput['model'],
+  opts: BuildShaderCubeInstancesOpts,
+  words: number[],
+): boolean {
+  const { sectionOrigin, sectionHeight, biome, tintPalette, textureIndexMapping, doAO = true } = opts
+
+  if (!isShaderCubeBlock(cached, model, sectionHeight, textureIndexMapping)) {
+    return false
+  }
+
+  const element = model.elements![0]
+  const faces = element.faces!
+  const wasmFaceToDataIndex = buildWasmFaceToDataIndex(block.visible_faces)
+  const [bx, by, bz] = block.position
+  const lx = bx & 15
+  const ly = (by - sectionOrigin.y) & 15
+  const lz = bz & 15
+
+  const wordsStart = words.length
+
+  for (const faceName of WASM_FACE_ORDER) {
+    const faceIdx = FACE_NAME_TO_INDEX[faceName]
+    if ((block.visible_faces & (1 << faceIdx)) === 0) continue
+
+    const faceDataIndex = wasmFaceToDataIndex[faceIdx]
+    if (faceDataIndex === undefined) continue
+
+    const eFace = faces[faceName]
+    const tex = eFace.texture! as FaceTextureRef
+    const texIndex = resolveFaceTileIndex(tex, textureIndexMapping)
+    if (texIndex < 0) {
+      words.length = wordsStart
+      return false
+    }
+
+    const rawAo = block.ao_data[faceDataIndex] ?? [3, 3, 3, 3]
+    const rawLight = lightCombinedForFace(block, faceDataIndex)
+
+    let ao: number[]
+    let lightCombined: number[]
+    let aoDiagonalFlip: boolean
+
+    if (doAO) {
+      ao = remapCornersForShaderFace(faceIdx, rawAo, 3)
+      lightCombined = remapCornersForShaderFace(faceIdx, rawLight, 255)
+      aoDiagonalFlip = ao[0] + ao[3] >= ao[1] + ao[2]
+    } else {
+      ao = [3, 3, 3, 3]
+      lightCombined = [255, 255, 255, 255]
+      aoDiagonalFlip = false
+    }
+
+    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.y),
+      packWord3(sectionOrigin.x, sectionOrigin.z),
+    )
+  }
+
+  return true
+}
+
+export function buildShaderCubesFromWords(wordQuads: number[]): ShaderCubesOutput | undefined {
+  const faceCount = Math.floor(wordQuads.length / SHADER_CUBES_WORDS_PER_FACE)
+  if (faceCount === 0) return undefined
+  return {
+    words: new Uint32Array(wordQuads),
+    count: faceCount,
+    formatVersion: SHADER_CUBES_FORMAT_VERSION,
+  }
+}
+
+/** Visible face count from WASM bitmask */
+export function countVisibleFaces(visibleFaces: number): number {
+  let n = 0
+  for (let i = 0; i < 6; i++) {
+    if (visibleFaces & (1 << i)) n++
+  }
+  return n
+}

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

@@ -0,0 +1,58 @@
+//@ts-nocheck
+import { test, expect } from 'vitest'
+import {
+  computeShaderSectionRaycastAabb,
+  raycastAabb,
+  raycastSectionAabb,
+} from '../../three/sectionRaycastAabb'
+import { SHADER_CUBES_WORDS_PER_FACE } from '../bridge/shaderCubeBridge'
+import { WORD0 } from '../../three/shaders/cubeBlockShader'
+
+test('raycastSectionAabb: hit along +X (full 16³)', () => {
+  const t = raycastSectionAabb(0, 0, 0, 1, 0, 0, 16, 0, 0, 100)
+  expect(t).toBeDefined()
+  expect(t!).toBeGreaterThanOrEqual(8)
+  expect(t!).toBeLessThanOrEqual(24)
+})
+
+test('raycastSectionAabb: miss behind ray', () => {
+  expect(raycastSectionAabb(0, 0, 0, 1, 0, 0, -32, 0, 0, 100)).toBeUndefined()
+})
+
+test('raycastAabb: respects maxDist', () => {
+  expect(raycastAabb(0, 0, 0, 1, 0, 0, 100, 0, 0, 108, 0, 8, 10)).toBeUndefined()
+})
+
+test('computeShaderSectionRaycastAabb: tight box from one block at local (5,3,7)', () => {
+  const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE)
+  const lx = 5
+  const ly = 3
+  const lz = 7
+  words[0] = lx | (ly << WORD0.LY_SHIFT) | (lz << WORD0.LZ_SHIFT)
+  const box = computeShaderSectionRaycastAabb(words, 1, 8, 8, 8)!
+  expect(box.minX).toBe(lx)
+  expect(box.maxX).toBe(lx + 1)
+  expect(box.minY).toBe(ly)
+  expect(box.maxY).toBe(ly + 1)
+  expect(box.minZ).toBe(lz)
+  expect(box.maxZ).toBe(lz + 1)
+
+  const t = raycastAabb(-1, 3.5, 7.5, 1, 0, 0, box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ, 100)
+  expect(t).toBe(6)
+})
+
+test('raycastAabb: origin inside box is ignored', () => {
+  const t = raycastAabb(5.5, 3.5, 7.5, 0, 0, 1, 5, 3, 7, 6, 4, 8, 100)
+  expect(t).toBeUndefined()
+})
+
+test('raycastAabb: narrow floor slab blocks downward ray', () => {
+  const words = new Uint32Array(SHADER_CUBES_WORDS_PER_FACE * 2)
+  words[0] = 4 | (0 << WORD0.LY_SHIFT) | (4 << WORD0.LZ_SHIFT)
+  words[4] = 5 | (0 << WORD0.LY_SHIFT) | (4 << WORD0.LZ_SHIFT)
+  const box = computeShaderSectionRaycastAabb(words, 2, 8, 8, 8)!
+  const t = raycastAabb(4.5, 10, 4.5, 0, -1, 0, box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ, 20)
+  expect(t).toBeDefined()
+  expect(t!).toBeGreaterThan(0)
+  expect(t!).toBeLessThan(10)
+})