minecraft-renderer 0.1.18 → 0.1.20

package/src/mesher/test/snapshotUtils.ts

@@ -0,0 +1,93 @@
+//@ts-nocheck
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+
+/**
+ * Serialize any output object for snapshot comparison
+ * Converts TypedArrays to regular arrays for JSON serialization
+ */
+export function serializeOutput(output: any): any {
+  const serialized: any = {}
+  for (const [key, value] of Object.entries(output)) {
+    if (value instanceof Float32Array || value instanceof Uint32Array || value instanceof Uint16Array || value instanceof Uint8Array) {
+      serialized[key] = Array.from(value as any)
+    } else if (value instanceof ArrayBuffer) {
+      serialized[key] = Array.from(new Uint8Array(value))
+    } else if (typeof value === 'object' && value !== null) {
+      serialized[key] = serializeOutput(value)
+    } else {
+      serialized[key] = value
+    }
+  }
+  return serialized
+}
+
+/**
+ * Deep equality comparison for snapshot testing
+ */
+export function deepEqual(obj1: any, obj2: any): boolean {
+  if (obj1 === obj2) return true
+  if (obj1 == null || obj2 == null) return false
+  if (typeof obj1 !== typeof obj2) return false
+
+  if (Array.isArray(obj1) && Array.isArray(obj2)) {
+    if (obj1.length !== obj2.length) return false
+    for (let i = 0; i < obj1.length; i++) {
+      if (!deepEqual(obj1[i], obj2[i])) return false
+    }
+    return true
+  }
+
+  if (typeof obj1 === 'object') {
+    const keys1 = Object.keys(obj1)
+    const keys2 = Object.keys(obj2)
+    if (keys1.length !== keys2.length) return false
+    for (const key of keys1) {
+      if (!keys2.includes(key)) return false
+      if (!deepEqual(obj1[key], obj2[key])) return false
+    }
+    return true
+  }
+
+  return false
+}
+
+/**
+ * Compare output with snapshot file, or write snapshot if it doesn't exist
+ * @param output - The output object to compare/write
+ * @param snapshotPath - Path to snapshot file (absolute or relative to __dirname)
+ * @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 {
+  // 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 serialized = serializeOutput(output)
+
+  if (!existsSync(fullPath)) {
+    // Write snapshot if file doesn't exist
+    writeFileSync(fullPath, JSON.stringify(serialized, null, 2), 'utf-8')
+    console.log('Snapshot file created:', fullPath)
+    return true
+  } else {
+    // Compare with existing snapshot
+    const snapshotContent = readFileSync(fullPath, 'utf-8')
+    const snapshotData = JSON.parse(snapshotContent)
+
+    if (!deepEqual(serialized, snapshotData)) {
+      console.error('Snapshot mismatch! Current output differs from snapshot.')
+      // console.error('Expected (snapshot):', JSON.stringify(snapshotData, null, 2))
+      // console.error('Actual (current):', JSON.stringify(serialized, null, 2))
+      throw new Error('Snapshot comparison failed - output has changed')
+    }
+
+    console.log('Snapshot comparison passed - no changes detected')
+    return true
+  }
+}

package/src/playground/baseScene.ts

@@ -13,7 +13,7 @@ import { OrbitControls } from 'three/addons/controls/OrbitControls.js'
 // eslint-disable-next-line import/no-named-as-default
 import GUI from 'lil-gui'
 import _ from 'lodash'
-import { defaultWorldRendererConfig, WorldRendererConfig } from '../lib/worldrendererCommon'
+import { WorldRendererConfig } from '../graphicsBackend/config'
 import { getSyncWorld } from './shared'
 import { AppViewer, getInitialPlayerState } from '../graphicsBackend'
 import { WorldView } from '../worldView'
@@ -35,8 +35,8 @@ export interface PlaygroundSceneConfig {
 }
 
 const appGraphicBackends = [
-  // createGraphicsBackendSingleThread,
-  createGraphicsBackendOffThread
+  createGraphicsBackendSingleThread,
+  // createGraphicsBackendOffThread
 ]
 
 const includedVersions = globalThis.includedVersions
@@ -130,6 +130,7 @@ export class BasePlaygroundScene {
       Object.assign(this.appViewer.inWorldRenderingConfig, config.worldConfig)
     }
     this.appViewer.inWorldRenderingConfig.showHand = false
+    this.appViewer.inWorldRenderingConfig.showChunkBorders = true
     this.appViewer.inWorldRenderingConfig.isPlayground = true
     this.appViewer.inWorldRenderingConfig.instantCameraUpdate = this.enableCameraOrbitControl
     this.appViewer.config.statsVisible = 2

package/src/resourcesManager/resourcesManager.ts

@@ -308,8 +308,7 @@ export class ResourcesManager extends (EventEmitter as new () => TypedEmitter<Re
   }
 
   async generateGuiTextures() {
-    // TODO!
-    // await generateGuiAtlas()
+    // todo-low handled now in the client
   }
 
   async downloadDebugAtlas(isItems = false) {

package/src/three/modules/sciFiWorldReveal.ts

@@ -250,9 +250,11 @@ export class SciFiWorldRevealModule implements RendererModuleController {
     // Section keys are in format "x,y,z" where x, y, z are section coordinates
     // Mesh position is at geometry.sx, geometry.sy, geometry.sz
     const pos = mesh.position
-    const sectionX = Math.floor(pos.x / 16) * 16
-    const sectionY = Math.floor(pos.y / 16) * 16
-    const sectionZ = Math.floor(pos.z / 16) * 16
+    const CHUNK_SIZE = 16
+    const sectionHeight = this.worldRenderer.getSectionHeight()
+    const sectionX = Math.floor(pos.x / CHUNK_SIZE) * CHUNK_SIZE
+    const sectionY = Math.floor(pos.y / sectionHeight) * sectionHeight
+    const sectionZ = Math.floor(pos.z / CHUNK_SIZE) * CHUNK_SIZE
     const derivedKey = `${sectionX},${sectionY},${sectionZ}`
 
     // Verify this key exists in sectionObjects

package/src/three/worldBlockGeometry.ts

@@ -2,7 +2,7 @@
 import * as THREE from 'three'
 import { Vec3 } from 'vec3'
 import nbt from 'prismarine-nbt'
-import { MesherGeometryOutput } from '../mesher/shared'
+import { MesherGeometryOutput, IS_FULL_WORLD_SECTION } from '../mesher/shared'
 import { getBannerTexture, createBannerMesh, releaseBannerTexture } from './bannerRenderer'
 import { disposeObject } from './threeJsUtils'
 import type { WorldRendererThree } from './worldRendererThree'
@@ -70,9 +70,11 @@ export class WorldBlockGeometry {
     mesh.name = 'mesh'
     object = new THREE.Group()
     object.add(mesh)
-    // mesh with static dimensions: 16x16x16
+    // mesh with static dimensions: 16x16xsectionHeight
+    const sectionHeight = data.geometry.sectionEndY - data.geometry.sectionStartY
+    const CHUNK_SIZE = 16
     const staticChunkMesh = new THREE.Mesh(
-      new THREE.BoxGeometry(16, 16, 16),
+      new THREE.BoxGeometry(CHUNK_SIZE, sectionHeight, CHUNK_SIZE),
       new THREE.MeshBasicMaterial({ color: 0x00_00_00, transparent: true, opacity: 0 })
     )
     staticChunkMesh.position.set(data.geometry.sx, data.geometry.sy, data.geometry.sz)
@@ -230,7 +232,11 @@ export class WorldBlockGeometry {
   }
 
   removeColumn(x: number, z: number) {
-    for (let y = this.worldRenderer.worldSizeParams.minY; y < this.worldRenderer.worldSizeParams.worldHeight; y += 16) {
+    const sectionHeight = this.worldRenderer.getSectionHeight()
+    const worldMinY = this.worldRenderer.worldMinYRender
+    if (IS_FULL_WORLD_SECTION) {
+      // Only one section per chunk when full world section
+      const y = worldMinY
       this.worldRenderer.setSectionDirty(new Vec3(x, y, z), false)
       const key = `${x},${y},${z}`
       const mesh = this.sectionObjects[key]
@@ -247,6 +253,25 @@ export class WorldBlockGeometry {
         disposeObject(mesh)
       }
       delete this.sectionObjects[key]
+    } else {
+      for (let y = worldMinY; y < this.worldRenderer.worldSizeParams.worldHeight; y += sectionHeight) {
+        this.worldRenderer.setSectionDirty(new Vec3(x, y, z), false)
+        const key = `${x},${y},${z}`
+        const mesh = this.sectionObjects[key]
+        if (mesh) {
+          // Track memory usage removal
+          this.removeSectionMemoryUsage(mesh)
+          // Cleanup banner textures before disposing
+          mesh.traverse((child) => {
+            if ((child as any).bannerTexture) {
+              releaseBannerTexture((child as any).bannerTexture)
+            }
+          })
+          this.scene.remove(mesh)
+          disposeObject(mesh)
+        }
+        delete this.sectionObjects[key]
+      }
     }
   }
 }

package/src/three/worldRendererThree.ts

@@ -796,7 +796,8 @@ export class WorldRendererThree extends WorldRendererCommon {
   debugChunksVisibilityOverride() {
     const { chunksRenderAboveOverride, chunksRenderBelowOverride, chunksRenderDistanceOverride, chunksRenderAboveEnabled, chunksRenderBelowEnabled, chunksRenderDistanceEnabled } = this.reactiveDebugParams
 
-    const baseY = this.cameraSectionPos.y * 16
+    const sectionHeight = this.getSectionHeight()
+    const baseY = this.cameraSectionPos.y * sectionHeight
 
     if (
       this.displayOptions.inWorldRenderingConfig.enableDebugOverlay &&
@@ -1077,9 +1078,11 @@ export class WorldRendererThree extends WorldRendererCommon {
 
   shouldObjectVisible(object: THREE.Object3D) {
     // Get chunk coordinates
-    const chunkX = Math.floor(object.position.x / 16) * 16
-    const chunkZ = Math.floor(object.position.z / 16) * 16
-    const sectionY = Math.floor(object.position.y / 16) * 16
+    const CHUNK_SIZE = 16
+    const sectionHeight = this.getSectionHeight()
+    const chunkX = Math.floor(object.position.x / CHUNK_SIZE) * CHUNK_SIZE
+    const chunkZ = Math.floor(object.position.z / CHUNK_SIZE) * CHUNK_SIZE
+    const sectionY = Math.floor(object.position.y / sectionHeight) * sectionHeight
 
     const chunkKey = `${chunkX},${chunkZ}`
     const sectionKey = `${chunkX},${sectionY},${chunkZ}`

package/src/wasm-lib/convertChunk.ts

@@ -0,0 +1,192 @@
+//@ts-nocheck
+import { Vec3 } from 'vec3'
+import MinecraftData from 'minecraft-data'
+import PrismarineBlockLoader from 'prismarine-block'
+import moreBlockDataGeneratedJson from '../lib/moreBlockDataGenerated.json'
+
+type BlockMeta = {
+  invisibleBlocks: Uint16Array
+  transparentBlocks: Uint16Array
+  noAoBlocks: Uint16Array
+  cullIdenticalBlocks: Uint16Array
+  occludingBlocks: Uint16Array
+}
+
+const metaCache = new Map<string, BlockMeta>()
+
+const blockToIds = (block: { minStateId: number, maxStateId: number }) => {
+  const ids: number[] = []
+  for (let i = block.minStateId; i <= block.maxStateId; i++) {
+    ids.push(i)
+  }
+  return ids
+}
+
+const isCube = (shapes: any) => {
+  if (!shapes || shapes.length !== 1) return false
+  const s = shapes[0]
+  return s[0] === 0 && s[1] === 0 && s[2] === 0 && s[3] === 1 && s[4] === 1 && s[5] === 1
+}
+
+const isLikelyFullCubeBlockName = (name: string) => {
+  if (!name) return false
+  if (name.includes('stairs')) return false
+  if (name.includes('slab')) return false
+  if (name.includes('fence')) return false
+  if (name.includes('gate')) return false
+  if (name.includes('pane')) return false
+  if (name.includes('wall')) return false
+  if (name.includes('door')) return false
+  if (name.includes('trapdoor')) return false
+  if (name.includes('sign')) return false
+  if (name.includes('banner')) return false
+  if (name.includes('rail')) return false
+  if (name.includes('torch')) return false
+  if (name.includes('lantern')) return false
+  if (name.includes('button')) return false
+  if (name.includes('lever')) return false
+  if (name.includes('pressure_plate')) return false
+  if (name.includes('carpet')) return false
+  if (name.includes('flower')) return false
+  if (name.includes('sapling')) return false
+  if (name.includes('tall_grass')) return false
+  if (name === 'grass' || name === 'short_grass' || name === 'tall_grass') return false
+  return true
+}
+
+const getBlockMeta = (version: string): BlockMeta => {
+  const cached = metaCache.get(version)
+  if (cached) return cached
+
+  const mcData = MinecraftData(version)
+
+  const invisibleBlocks = new Uint16Array(mcData.blocksArray.filter(x => moreBlockDataGeneratedJson.invisibleBlocks[x.name]).flatMap(blockToIds))
+  const transparentBlocks = new Uint16Array(mcData.blocksArray.filter(x => x.transparent).flatMap(blockToIds))
+  const noAoBlocks = new Uint16Array(mcData.blocksArray.filter(x => moreBlockDataGeneratedJson.noOcclusions[x.name]).flatMap(blockToIds))
+  const cullIdenticalBlocks = new Uint16Array(mcData.blocksArray.filter(x => x.name.includes('glass') || x.name.includes('ice')).flatMap(blockToIds))
+  const Block = PrismarineBlockLoader(version)
+  const noOcclusionsSet = new Set(Object.keys(moreBlockDataGeneratedJson.noOcclusions))
+
+  const occludingBlockIds: number[] = []
+  for (const idStr of Object.keys((mcData as any).blocksByStateId)) {
+    const id = Number(idStr)
+    if (!id) continue
+    const b = (Block as any).fromStateId(id, 0)
+    if (!b) continue
+    if (b.transparent) continue
+    if (b.boundingBox !== 'block') continue
+    if (noOcclusionsSet.has(b.name)) continue
+    if (!isCube(b.shapes)) continue
+    occludingBlockIds.push(id)
+  }
+
+  const occludingBlocks = new Uint16Array(occludingBlockIds)
+
+  const meta = {
+    invisibleBlocks,
+    transparentBlocks,
+    noAoBlocks,
+    cullIdenticalBlocks,
+    occludingBlocks
+  }
+
+  metaCache.set(version, meta)
+  return meta
+}
+
+export interface ChunkConversionResult {
+  blockStates: Uint16Array
+  blockLight: Uint8Array
+  skyLight: Uint8Array
+  biomesArray: Uint8Array
+  invisibleBlocks: Uint16Array
+  transparentBlocks: Uint16Array
+  noAoBlocks: Uint16Array
+  cullIdenticalBlocks: Uint16Array
+  occludingBlocks: Uint16Array
+  blockCount: number
+}
+
+/**
+ * Convert a prismarine chunk to WASM format
+ */
+export function convertChunkToWasm(
+  chunk: any,
+  version: string,
+  chunkX: number = 0,
+  chunkZ: number = 0,
+  worldMinY: number = 0,
+  worldMaxY: number = 256,
+  sectionY?: number,
+  sectionHeight?: number
+): ChunkConversionResult {
+  const CHUNK_SIZE = 16
+
+  // If sectionY and sectionHeight are provided, only convert that section
+  // Otherwise convert the full chunk
+  const startY = sectionY !== undefined ? sectionY : worldMinY
+  const endY = sectionHeight !== undefined ? startY + sectionHeight : worldMaxY
+  const totalBlocks = CHUNK_SIZE * CHUNK_SIZE * (endY - startY)
+
+  const blockStates = new Uint16Array(totalBlocks)
+  const blockLight = new Uint8Array(totalBlocks)
+  const skyLight = new Uint8Array(totalBlocks)
+  const biomesArray = new Uint8Array(totalBlocks)
+
+  // Traverse chunk and extract data
+  let blockCount = 0
+
+  for (let y = startY; y < endY; y++) {
+    for (let z = 0; z < CHUNK_SIZE; z++) {
+      for (let x = 0; x < CHUNK_SIZE; x++) {
+        const pos = new Vec3(x, y, z)
+        const idx = x + z * CHUNK_SIZE + (y - startY) * CHUNK_SIZE * CHUNK_SIZE
+
+        try {
+          // Get block state ID
+          const stateId = chunk.getBlockStateId(pos)
+          blockStates[idx] = stateId || 0
+
+          // Get light values
+          const bl = chunk.getBlockLight(pos)
+          const sl = chunk.getSkyLight(pos)
+          blockLight[idx] = bl !== undefined ? bl : 0
+          skyLight[idx] = sl !== undefined ? sl : 15
+
+          // Get biome
+          const biome = chunk.getBiome ? chunk.getBiome(pos) : 1
+          biomesArray[idx] = biome || 1
+
+          if (stateId && stateId !== 0) blockCount++
+        } catch (err) {
+          // If position is out of bounds, set to air
+          blockStates[idx] = 0
+          blockLight[idx] = 0
+          skyLight[idx] = 15
+          biomesArray[idx] = 1
+        }
+      }
+    }
+  }
+
+  const {
+    invisibleBlocks,
+    transparentBlocks,
+    noAoBlocks,
+    cullIdenticalBlocks,
+    occludingBlocks
+  } = getBlockMeta(version)
+
+  return {
+    blockStates,
+    blockLight,
+    skyLight,
+    biomesArray,
+    invisibleBlocks,
+    transparentBlocks,
+    noAoBlocks,
+    cullIdenticalBlocks,
+    occludingBlocks,
+    blockCount,
+  }
+}