Upload src/engine/voxel/meshBuilder.ts with huggingface_hub

src/engine/voxel/meshBuilder.ts

@@ -0,0 +1,198 @@
+/**
+ * Chunk Mesh Builder with Texture Atlas support
+ * Converts chunk block data into Three.js renderable geometry with real MC textures
+ */
+
+import {
+  CHUNK_WIDTH, CHUNK_HEIGHT, CHUNK_DEPTH, MIN_BUILD_HEIGHT,
+  BLOCK_AIR, BLOCK_DEFS, BLOCK_FACES, ATLAS_SIZE, TILES_PER_ROW, TEXTURE_SIZE,
+} from '../constants'
+import type { ChunkData, ChunkMeshData } from '@/types'
+
+const FACE_INDICES = [0, 1, 2, 0, 2, 3]
+
+// UV coordinates for a single tile in the atlas
+const TILE_UV = 1 / TILES_PER_ROW
+
+// Cache for atlas mapping
+let atlasMap: Record<string, { u: number; v: number }> | null = null
+
+function getAtlasMap(): Record<string, { u: number; v: number }> {
+  if (atlasMap) return atlasMap
+  // Will be loaded asynchronously; for now use fallback
+  return {}
+}
+
+export function setAtlasMap(map: Record<string, { u: number; v: number }>) {
+  atlasMap = map
+}
+
+/**
+ * Get UV coordinates for a texture name in the atlas
+ */
+function getTextureUV(texName: string): [number, number] | null {
+  if (!texName) return null
+  const map = getAtlasMap()
+  const entry = map[texName]
+  if (!entry) return null
+  // Convert pixel coords to UV coords
+  const u = entry.u / ATLAS_SIZE
+  const v = 1 - (entry.v + TEXTURE_SIZE) / ATLAS_SIZE // Flip V for WebGL
+  return [u, v]
+}
+
+/**
+ * Build mesh geometry for a chunk with texture atlas UVs
+ */
+export function buildChunkMesh(chunk: ChunkData, adjacentChunks?: Map<string, ChunkData>): ChunkMeshData | null {
+  const positions: number[] = []
+  const normals: number[] = []
+  const uvs: number[] = []
+  const colors: number[] = []
+  const indices: number[] = []
+  let vertexCount = 0
+
+  for (let ly = 0; ly < CHUNK_HEIGHT; ly++) {
+    for (let lz = 0; lz < CHUNK_DEPTH; lz++) {
+      for (let lx = 0; lx < CHUNK_WIDTH; lx++) {
+        const blockIdx = lx + lz * CHUNK_WIDTH + ly * CHUNK_WIDTH * CHUNK_DEPTH
+        const blockId = chunk.blocks[blockIdx]
+
+        if (blockId === BLOCK_AIR) continue
+
+        const def = BLOCK_DEFS[blockId]
+        if (!def) continue
+
+        const wx = chunk.position.x * CHUNK_WIDTH + lx
+        const wy = ly + MIN_BUILD_HEIGHT
+        const wz = chunk.position.z * CHUNK_DEPTH + lz
+
+        const color = hexToRgb(def.color)
+
+        for (const [faceName, face] of Object.entries(BLOCK_FACES)) {
+          const nx = wx + face.dir[0]
+          const ny = wy + face.dir[1]
+          const nz = wz + face.dir[2]
+
+          const neighborId = getNeighborBlock(chunk, nx, ny, nz, adjacentChunks)
+          const neighborDef = BLOCK_DEFS[neighborId]
+
+          // Skip face if neighbor is solid and opaque
+          if (neighborDef && neighborDef.solid && !neighborDef.transparent) continue
+          // Skip if same transparent block (e.g., water next to water)
+          if (neighborId === blockId && def.transparent) continue
+
+          // Determine which texture to use for this face
+          let texName = def.texSide
+          if (faceName === 'top') texName = def.texTop
+          else if (faceName === 'bottom') texName = def.texBottom
+
+          const uvOffset = getTextureUV(texName)
+
+          // Add 4 vertices
+          for (let ci = 0; ci < 4; ci++) {
+            const corner = face.corners[ci]
+            positions.push(
+              lx + corner[0],
+              ly + (corner[1] === 1 ? 1 : 0),
+              lz + corner[2]
+            )
+            normals.push(face.dir[0], face.dir[1], face.dir[2])
+
+            // UV coordinates
+            if (uvOffset) {
+              const cu = ci === 0 || ci === 3 ? 0 : 1
+              const cv = ci < 2 ? 1 : 0
+              uvs.push(uvOffset[0] + cu * TILE_UV, uvOffset[1] + cv * TILE_UV)
+            } else {
+              // Fallback: simple UV
+              const cu = ci === 0 || ci === 3 ? 0 : 1
+              const cv = ci < 2 ? 1 : 0
+              uvs.push(cu, cv)
+            }
+
+            // Color with face shading
+            const shade = getFaceShade(faceName)
+            if (def.transparent && blockId !== BLOCK_LEAVES) {
+              colors.push(
+                (color.r / 255) * shade * 0.7,
+                (color.g / 255) * shade * 0.7,
+                (color.b / 255) * shade * 0.7
+              )
+            } else {
+              colors.push(
+                (color.r / 255) * shade,
+                (color.g / 255) * shade,
+                (color.b / 255) * shade
+              )
+            }
+          }
+
+          for (const i of FACE_INDICES) {
+            indices.push(vertexCount + i)
+          }
+          vertexCount += 4
+        }
+      }
+    }
+  }
+
+  if (positions.length === 0) return null
+
+  return {
+    vertices: new Float32Array(positions),
+    indices: new Uint32Array(indices),
+    normals: new Float32Array(normals),
+    uvs: new Float32Array(uvs),
+    colors: new Float32Array(colors),
+    ao: new Float32Array(0),
+  }
+}
+
+function getNeighborBlock(chunk: ChunkData, wx: number, wy: number, wz: number, adjacentChunks?: Map<string, ChunkData>): number {
+  if (wy < MIN_BUILD_HEIGHT || wy > 319) return BLOCK_AIR
+
+  const lx = wx - chunk.position.x * CHUNK_WIDTH
+  const lz = wz - chunk.position.z * CHUNK_DEPTH
+
+  if (lx >= 0 && lx < CHUNK_WIDTH && lz >= 0 && lz < CHUNK_DEPTH) {
+    const ly = wy - MIN_BUILD_HEIGHT
+    if (ly < 0 || ly >= CHUNK_HEIGHT) return BLOCK_AIR
+    return chunk.blocks[lx + lz * CHUNK_WIDTH + ly * CHUNK_WIDTH * CHUNK_DEPTH] || BLOCK_AIR
+  }
+
+  // Cross-chunk lookup
+  if (adjacentChunks) {
+    const ncx = Math.floor(wx / CHUNK_WIDTH)
+    const ncz = Math.floor(wz / CHUNK_DEPTH)
+    const nChunk = adjacentChunks.get(`${ncx},${ncz}`)
+    if (nChunk) {
+      const nlx = ((wx % CHUNK_WIDTH) + CHUNK_WIDTH) % CHUNK_WIDTH
+      const nlz = ((wz % CHUNK_DEPTH) + CHUNK_DEPTH) % CHUNK_DEPTH
+      const nly = wy - MIN_BUILD_HEIGHT
+      if (nly < 0 || nly >= CHUNK_HEIGHT) return BLOCK_AIR
+      return nChunk.blocks[nlx + nlz * CHUNK_WIDTH + nly * CHUNK_WIDTH * CHUNK_DEPTH] || BLOCK_AIR
+    }
+  }
+
+  return BLOCK_AIR
+}
+
+function getFaceShade(faceName: string): number {
+  switch (faceName) {
+    case 'top': return 1.0
+    case 'bottom': return 0.5
+    case 'north': return 0.8
+    case 'south': return 0.8
+    case 'east': return 0.6
+    case 'west': return 0.6
+    default: return 0.8
+  }
+}
+
+function hexToRgb(hex: string): { r: number; g: number; b: number } {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
+  return result
+    ? { r: parseInt(result[1], 16), g: parseInt(result[2], 16), b: parseInt(result[3], 16) }
+    : { r: 128, g: 128, b: 128 }
+}