minecraft-renderer 0.1.95 → 0.1.97

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

@@ -0,0 +1,226 @@
+//@ts-nocheck
+import { test, expect, beforeEach, vi } from 'vitest'
+import * as THREE from 'three'
+import { elemFaces } from '../../mesher-shared/modelsGeometryCommon'
+import { SHADER_CUBES_FORMAT_VERSION } from '../../mesher-shared/shaderCubeFormat'
+import { FACE_UV_TERMS, buildFaceUvGlsl, shaderCubeFaceUv, cubeBlockVertexShader, WORD0, WORD2 } from '../../three/shaders/cubeBlockShader'
+import {
+  AO_LIGHT_REMAP,
+  resetShaderCubeResources,
+  getShaderCubeResources,
+  resolveFaceUv,
+  isShaderCubeBlock,
+  tryBuildShaderCubeInstances,
+  SHADER_CUBES_WORDS_PER_FACE
+} from '../bridge/shaderCubeBridge'
+import { createMeshesFromExport } from '../../three/worldGeometryExport'
+
+const FACE_NAMES = ['up', 'down', 'east', 'west', 'south', 'north'] as const
+const SIGN_COMBOS: Array<[boolean, boolean]> = [
+  [false, false],
+  [true, false],
+  [false, true],
+  [true, true]
+]
+
+function requireShaderCubeResources() {
+  const resources = getShaderCubeResources()
+  if (!resources) throw new Error('shader cube resources unavailable in test')
+  return resources
+}
+
+/** Legacy tile-local UV (render-from-wasm.ts elemFaces + down +180°). */
+function legacyTileLocalUv(faceName: string, cornerIdx: number, suSign: number, svSign: number): [number, number] {
+  const [, , , cu, cv] = (elemFaces as Record<string, { corners: number[][] }>)[faceName]!.corners[cornerIdx]!
+  const r = faceName === 'down' ? 180 : 0
+  const uvcs = Math.cos((r * Math.PI) / 180)
+  const uvsn = -Math.sin((r * Math.PI) / 180)
+  const baseu = (cu - 0.5) * uvcs - (cv - 0.5) * uvsn + 0.5
+  const basev = (cu - 0.5) * uvsn + (cv - 0.5) * uvcs + 0.5
+  return [suSign < 0 ? 1 - baseu : baseu, svSign < 0 ? 1 - basev : basev]
+}
+
+beforeEach(() => {
+  resetShaderCubeResources()
+})
+
+test('shaderCubeFaceUv: 6 faces × 4 corners × 4 sign combos match legacy (96 cases)', () => {
+  for (let faceIdx = 0; faceIdx < 6; faceIdx++) {
+    const faceName = FACE_NAMES[faceIdx]!
+    for (let vi = 0; vi < 4; vi++) {
+      for (const [flipU, flipV] of SIGN_COMBOS) {
+        const suSign = flipU ? -1 : 1
+        const svSign = flipV ? -1 : 1
+        const elemCorner = AO_LIGHT_REMAP[faceIdx]![vi]!
+        const legacy = legacyTileLocalUv(faceName, elemCorner, suSign, svSign)
+        const shader = shaderCubeFaceUv(faceIdx, vi, flipU, flipV)
+        expect(shader[0]).toBeCloseTo(legacy[0], 9)
+        expect(shader[1]).toBeCloseTo(legacy[1], 9)
+      }
+    }
+  }
+})
+
+test('buildFaceUvGlsl: 6 branches match FACE_UV_TERMS and vertex shader embeds generated table', () => {
+  const glsl = buildFaceUvGlsl()
+  for (let i = 0; i < 6; i++) {
+    expect(glsl).toContain(`faceId == ${i}u`)
+    const [ut, vt] = FACE_UV_TERMS[i]!
+    const glslU = ut === 'u' ? 'u' : ut === 'v' ? 'v' : ut === '1-u' ? '1.0 - u' : '1.0 - v'
+    const glslV = vt === 'u' ? 'u' : vt === 'v' ? 'v' : vt === '1-u' ? '1.0 - u' : '1.0 - v'
+    expect(glsl).toContain(`vec2(${glslU}, ${glslV})`)
+  }
+  expect(cubeBlockVertexShader).toContain(glsl)
+  expect(cubeBlockVertexShader).toContain('a_w2 >> 31u')
+  expect(cubeBlockVertexShader).toContain('a_w0 >> 31u')
+})
+
+test('resolveFaceUv: crafting_table north/west regression', () => {
+  const { textureIndexMapping } = requireShaderCubeResources()
+
+  const north = resolveFaceUv({ u: 0.53125, v: 0, su: -0.015625, sv: 0.015625, tileIndex: 33 }, textureIndexMapping)
+  expect(north).toEqual({ tileIndex: 33, flipU: true, flipV: false })
+
+  const west = resolveFaceUv({ u: 0.515625, v: 0, su: 0.015625, sv: 0.015625, tileIndex: 33 }, textureIndexMapping)
+  expect(west).toEqual({ tileIndex: 33, flipU: false, flipV: false })
+})
+
+test('tryBuildShaderCubeInstances: crafting_table north sets FLIP_U_SHIFT', () => {
+  const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
+  const craftingFaces = {
+    up: { texture: { u: 0.515625, v: 0, su: 0.015625, sv: 0.015625, tileIndex: 33 } },
+    down: { texture: { u: 0.53125, v: 0, su: -0.015625, sv: 0.015625, tileIndex: 33 } },
+    east: { texture: { u: 0.515625, v: 0, su: 0.015625, sv: 0.015625, tileIndex: 33 } },
+    west: { texture: { u: 0.515625, v: 0, su: 0.015625, sv: 0.015625, tileIndex: 33 } },
+    south: { texture: { u: 0.515625, v: 0, su: 0.015625, sv: 0.015625, tileIndex: 33 } },
+    north: { texture: { u: 0.53125, v: 0, su: -0.015625, sv: 0.015625, tileIndex: 33 } }
+  }
+  const model = { elements: [{ faces: craftingFaces }] }
+  const block = {
+    position: [0, 0, 0] as [number, number, number],
+    visible_faces: 1 << 5,
+    ao_data: [[3, 3, 3, 3]],
+    light_combined: [[255, 255, 255, 255]]
+  }
+  const words: number[] = []
+  const ok = tryBuildShaderCubeInstances(
+    block,
+    { blockName: 'crafting_table', blockProps: {}, isCube: true, model },
+    model,
+    { sectionOrigin: { x: 0, y: 0, z: 0 }, sectionHeight: 16, tintPalette, textureIndexMapping },
+    words
+  )
+  expect(ok).toBe(true)
+  expect(words.length).toBe(SHADER_CUBES_WORDS_PER_FACE)
+  expect(words[2]! & (1 << WORD2.FLIP_U_SHIFT)).not.toBe(0)
+})
+
+test('tryBuildShaderCubeInstances: sv<0 up face sets FLIP_V_SHIFT', () => {
+  const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
+  const stdFace = { u: 0, v: 0, su: 16, sv: 16 }
+  const upSvNeg = { u: 0.515625, v: 0.015625, su: 0.015625, sv: -0.015625, tileIndex: 33 }
+  expect(resolveFaceUv(upSvNeg, textureIndexMapping)).toEqual({ tileIndex: 33, flipU: false, flipV: true })
+
+  const model = {
+    elements: [
+      {
+        faces: {
+          up: { texture: upSvNeg },
+          down: { texture: stdFace },
+          east: { texture: stdFace },
+          west: { texture: stdFace },
+          south: { texture: stdFace },
+          north: { texture: stdFace }
+        }
+      }
+    ]
+  }
+  const block = {
+    position: [0, 0, 0] as [number, number, number],
+    visible_faces: 1 << 0,
+    ao_data: [[3, 3, 3, 3]],
+    light_combined: [[255, 255, 255, 255]]
+  }
+  const words: number[] = []
+  const ok = tryBuildShaderCubeInstances(
+    block,
+    { blockName: 'observer', blockProps: { facing: 'north' }, isCube: true, model },
+    model,
+    { sectionOrigin: { x: 0, y: 0, z: 0 }, sectionHeight: 16, tintPalette, textureIndexMapping },
+    words
+  )
+  expect(ok).toBe(true)
+  expect(words.length).toBe(SHADER_CUBES_WORDS_PER_FACE)
+  expect(words[0]! & (1 << WORD0.FLIP_V_SHIFT)).not.toBe(0)
+  expect(words[2]! & (1 << WORD2.FLIP_U_SHIFT)).toBe(0)
+})
+
+test('resolveFaceUv gate: rejects crop, non-integer scale, misaligned tile, tileIndex mismatch, NaN', () => {
+  const { textureIndexMapping } = requireShaderCubeResources()
+
+  expect(resolveFaceUv({ u: 0, v: 0, su: 8, sv: 16 }, textureIndexMapping)).toBeNull()
+  expect(resolveFaceUv({ u: 0, v: 0, su: 15.6, sv: 16 }, textureIndexMapping)).toBeNull()
+  expect(resolveFaceUv({ u: 529, v: 0, su: 16, sv: 16 }, textureIndexMapping)).toBeNull()
+  expect(resolveFaceUv({ u: 0, v: 0, su: 16, sv: 16, tileIndex: 999 }, textureIndexMapping)).toBeNull()
+  expect(resolveFaceUv({ u: 0, v: 0, su: Number.NaN, sv: 16 }, textureIndexMapping)).toBeNull()
+})
+
+test('isShaderCubeBlock: rejects faces that fail resolveFaceUv gate', () => {
+  const { textureIndexMapping } = requireShaderCubeResources()
+  const baseFaces = {
+    up: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+    down: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+    east: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+    west: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+    south: { texture: { u: 0, v: 0, su: 16, sv: 16 } },
+    north: { texture: { u: 0, v: 0, su: 16, sv: 16 } }
+  }
+  const model = { elements: [{ faces: baseFaces }] }
+  expect(isShaderCubeBlock({ blockName: 'stone', blockProps: {}, isCube: true, model }, model, 16, textureIndexMapping)).toBe(true)
+
+  const cropped = {
+    elements: [{ faces: { ...baseFaces, up: { texture: { u: 0, v: 0, su: 8, sv: 16 } } } }]
+  }
+  expect(isShaderCubeBlock({ blockName: 'stone', blockProps: {}, isCube: true, model: cropped }, cropped, 16, textureIndexMapping)).toBe(false)
+})
+
+test('createMeshesFromExport: skips shader-cube sections with old formatVersion', () => {
+  const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+  const material = new THREE.MeshBasicMaterial()
+  const v3Words = new Uint32Array([1, 2, 3, 4])
+  const v4Words = new Uint32Array([5, 6, 7, 8])
+
+  const groups = createMeshesFromExport(
+    {
+      version: 'test',
+      exportedAt: '',
+      camera: { position: { x: 0, y: 0, z: 0 }, rotation: { pitch: 0, yaw: 0 } },
+      sections: [
+        {
+          key: 'old',
+          position: { x: 0, y: 0, z: 0 },
+          geometry: { positions: [], normals: [], colors: [], skyLights: [], blockLights: [], uvs: [], indices: [] },
+          shaderCubes: { words: v3Words, count: 1, formatVersion: 3 as unknown as typeof SHADER_CUBES_FORMAT_VERSION }
+        },
+        {
+          key: 'new',
+          position: { x: 16, y: 0, z: 0 },
+          geometry: { positions: [], normals: [], colors: [], skyLights: [], blockLights: [], uvs: [], indices: [] },
+          shaderCubes: { words: v4Words, count: 1, formatVersion: SHADER_CUBES_FORMAT_VERSION }
+        }
+      ]
+    },
+    material,
+    new THREE.ShaderMaterial({ vertexShader: 'void main() {}', fragmentShader: 'void main() {}' })
+  )
+
+  expect(groups).toHaveLength(1)
+  expect(groups[0]!.children).toHaveLength(1)
+  expect(warn).toHaveBeenCalledOnce()
+  expect(warn.mock.calls[0]![0]).toContain('Skipped 1 shader-cube section')
+  expect(warn.mock.calls[0]![0]).toContain('3')
+  expect(warn.mock.calls[0]![0]).toContain(String(SHADER_CUBES_FORMAT_VERSION))
+
+  warn.mockRestore()
+  material.dispose()
+})

package/src/wasm-mesher/worker/mesherWasm.ts

@@ -4,6 +4,7 @@ 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 { SHADER_CUBES_FORMAT_VERSION } from '../../mesher-shared/shaderCubeFormat'
 import { packVisibilitySet, VISIBILITY_SET_ALL_TRUE } from '../../mesher-shared/visibilitySet'
 import { VisGraph } from '../../mesher-shared/visGraph'
 import { worldColumnKey, World } from '../../mesher-shared/world'
@@ -1532,7 +1533,7 @@ function processColumnTick() {
             geometry.shaderCubes = {
               words: new Uint32Array(exported.shaderCubes.words),
               count: exported.shaderCubes.count,
-              formatVersion: 3
+              formatVersion: SHADER_CUBES_FORMAT_VERSION
             }
           }
           if (exported.blendGeometry && hasBlendMesh) {