minecraft-renderer 0.1.21 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",
@@ -74,6 +74,7 @@
     "@types/three": "0.154.0",
     "@zardoy/react-util": "^0.2.7",
     "@zardoy/tsconfig": "^1.5.1",
+    "contro-max": "*",
     "esbuild": "^0.19.3",
     "esbuild-plugin-polyfill-node": "^0.3.0",
     "fs-extra": "^11.0.0",
@@ -92,11 +93,15 @@
     "vitest": "^4.0.14"
   },
   "peerDependencies": {
+    "contro-max": "*",
     "mc-assets": ">=0.2.0",
     "minecraft-data": ">=3.0.0",
     "three": ">=0.150.0"
   },
   "peerDependenciesMeta": {
+    "contro-max": {
+      "optional": true
+    },
     "mc-assets": {
       "optional": true
     },

package/src/graphicsBackend/config.ts

@@ -20,7 +20,7 @@ export const defaultWorldRendererConfig = {
   // Debug settings
   showChunkBorders: false,
   enableDebugOverlay: false,
-  debugModelVariant: undefined,
+  debugModelVariant: undefined as undefined | number[],
   futuristicReveal: false,
 
   // Performance settings
@@ -46,7 +46,7 @@ export const defaultWorldRendererConfig = {
   showHand: false,
   viewBobbing: false,
   renderEars: true,
-  highlightBlockColor: 'blue' as 'blue' | 'classic' | undefined,
+  highlightBlockColor: 'blue' as 'blue' | 'classic' | 'auto' | undefined,
 
   // Player models
   fetchPlayerSkins: true,
@@ -95,7 +95,7 @@ export const getDefaultRendererState = (): {
     reactive: proxy({
       world: {
         chunksLoaded: new Set<string>(),
-        heightmaps: new Map<string, Uint8Array>(),
+        heightmaps: new Map<string, Int16Array>(),
         allChunksLoaded: false,
         mesherWork: false,
         intersectMedia: null

package/src/graphicsBackend/types.ts

@@ -5,11 +5,11 @@
  * Core types for the graphics backend system.
  */
 
-import { WorldRendererConfig } from '../lib/worldrendererCommon'
 import { PlayerStateReactive } from '../playerState/playerState'
 import { ResourcesManagerTransferred } from '../resourcesManager'
 import { WorldViewWorker } from '../worldView'
 import { Vec3 } from 'vec3'
+import { WorldRendererConfig } from './config'
 
 // ============================================================================
 // Graphics Backend Configuration
@@ -69,7 +69,7 @@ export interface NonReactiveState {
 export interface RendererReactiveState {
   world: {
     chunksLoaded: Set<string>
-    heightmaps: Map<string, Uint8Array>
+    heightmaps: Map<string, Int16Array>
     allChunksLoaded: boolean
     mesherWork: boolean
     intersectMedia: any | null

package/src/lib/worldrendererCommon.ts

@@ -64,7 +64,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     dirty(pos: Vec3, value: boolean): void
     update(/* pos: Vec3, value: boolean */): void
     chunkFinished(key: string): void
-    heightmap(key: string, heightmap: Uint8Array): void
+    heightmap(key: string, heightmap: Int16Array): void
   }>
   customTexturesDataUrl = undefined as string | undefined
   workers: any[] = []
@@ -428,7 +428,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     }
 
     if (data.type === 'heightmap') {
-      this.reactiveState.world.heightmaps.set(data.key, new Uint8Array(data.heightmap))
+      this.reactiveState.world.heightmaps.set(data.key, new Int16Array(data.heightmap))
     }
   }
 
@@ -622,11 +622,11 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
         customBlockModels: customBlockModels || undefined
       })
     }
-    // this.workers[0].postMessage({
-    //   type: 'getHeightmap',
-    //   x,
-    //   z,
-    // })
+    this.workers[0].postMessage({
+      type: 'getHeightmap',
+      x,
+      z,
+    })
     this.logWorkerWork(() => `-> chunk ${JSON.stringify({ x, z, chunkLength: chunk.length, customBlockModelsLength: customBlockModels ? Object.keys(customBlockModels).length : 0 })}`)
     this.mesherLogReader?.chunkReceived(x, z, chunk.length)
     const sectionHeight = this.getSectionHeight()
@@ -687,6 +687,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
       }
     }
     this.highestBlocksByChunks.delete(`${x},${z}`)
+    this.reactiveState.world.heightmaps.delete(`${Math.floor(x / 16)},${Math.floor(z / 16)}`)
 
     this.updateChunksStats()
 
@@ -848,6 +849,10 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
         customBlockModels
       })
     }
+    // Re-request heightmap for the affected chunk after block change
+    const chunkCornerX = Math.floor(pos.x / CHUNK_SIZE) * CHUNK_SIZE
+    const chunkCornerZ = Math.floor(pos.z / CHUNK_SIZE) * CHUNK_SIZE
+    this.workers[0].postMessage({ type: 'getHeightmap', x: chunkCornerX, z: chunkCornerZ })
     this.logWorkerWork(`-> blockUpdate ${JSON.stringify({ pos, stateId, customBlockModels })}`)
     this.setSectionDirty(pos, true, true)
     if (this.neighborChunkUpdates) {

package/src/mesher/mesher.ts

@@ -153,7 +153,7 @@ const handleMessage = data => {
       break
     }
     case 'getHeightmap': {
-      const heightmap = new Uint8Array(256)
+      const heightmap = new Int16Array(256)
 
       const blockPos = new Vec3(0, 0, 0)
       for (let z = 0; z < 16; z++) {
@@ -169,7 +169,7 @@ const handleMessage = data => {
             block = world.getBlock(blockPos)
           }
           const index = z * 16 + x
-          heightmap[index] = block ? blockPos.y : 0
+          heightmap[index] = block ? blockPos.y : -32768
         }
       }
       postMessage({ type: 'heightmap', key: `${Math.floor(data.x / 16)},${Math.floor(data.z / 16)}`, heightmap })

package/src/mesher/shared.ts

@@ -65,7 +65,7 @@ export interface MesherMainEvents {
   geometry: { type: 'geometry'; key: string; geometry: MesherGeometryOutput; workerIndex: number };
   sectionFinished: { type: 'sectionFinished'; key: string; workerIndex: number; processTime?: number };
   blockStateModelInfo: { type: 'blockStateModelInfo'; info: Record<string, BlockStateModelInfo> };
-  heightmap: { type: 'heightmap'; key: string; heightmap: Uint8Array };
+  heightmap: { type: 'heightmap'; key: string; heightmap: Int16Array };
 }
 
 export type MesherMainEvent = MesherMainEvents[keyof MesherMainEvents]

package/src/playground/allEntitiesDebug.ts

@@ -1,7 +1,10 @@
 //@ts-nocheck
+import { IndexedData } from 'minecraft-data'
 import { EntityMesh, rendererSpecialHandled, EntityDebugFlags } from '../three/entity/EntityMesh'
 
-export const displayEntitiesDebugList = (version: string) => {
+export const displayEntitiesDebugList = (mcData: IndexedData) => {
+  const version = mcData.version.minecraftVersion!
+
   // Create results container
   const container = document.createElement('div')
   container.style.cssText = `
@@ -36,7 +39,6 @@ export const displayEntitiesDebugList = (version: string) => {
     textureMap?: boolean;
     errors?: string[];
   }> = []
-  const { mcData } = window
   const entityNames = Object.keys(mcData.entitiesArray.reduce((acc, entity) => {
     acc[entity.name] = true
     return acc
@@ -64,8 +66,8 @@ export const displayEntitiesDebugList = (version: string) => {
 
       const { mesh: entityMesh } = new EntityMesh(version, entity, undefined, {}, debugFlags)
       // find the most distant pos child
-      window.objects ??= {}
-      window.objects[entity] = entityMesh
+      globalThis.objects ??= {}
+      globalThis.objects[entity] = entityMesh
 
       results.push({
         entity,

package/src/playground/scenes/allEntities.ts

@@ -8,6 +8,6 @@ export default class AllEntities extends BasePlaygroundScene {
 
   async initData() {
     await super.initData()
-    displayEntitiesDebugList(this.version)
+    displayEntitiesDebugList(this.mcData)
   }
 }

package/src/playground/scenes/floorRandom.ts

@@ -27,7 +27,7 @@ export default class RailsCobwebScene extends BasePlaygroundScene {
     for (let x = -squareSize; x <= squareSize; x++) {
       for (let z = -squareSize; z <= squareSize; z++) {
         const i = Math.abs(x + z) * squareSize
-        this.worldView!.world.setBlock(this.targetPos.offset(x, 0, z), this.Block.fromStateId(fullBlocks[i % fullBlocks.length].defaultState, 0))
+        this.worldView!.setBlockStateId(this.targetPos.offset(x, 0, z), this.mcData.blocksByName[fullBlocks[i % fullBlocks.length].name]!.defaultState)
       }
     }
   }

package/src/three/appShared.ts

@@ -25,8 +25,8 @@ export const getItemUv = (item: Record<string, any>, specificProps: ItemSpecific
   try {
     const name =
       blockState
-        ? loadedData.blocksByStateId[blockState]?.name
-        : typeof idOrName === 'number' ? loadedData.items[idOrName]?.name : idOrName
+        ? globalThis.loadedData.blocksByStateId[blockState]?.name
+        : typeof idOrName === 'number' ? globalThis.loadedData.items[idOrName]?.name : idOrName
     if (!name) throw new Error(`Item not found: ${idOrName}`)
 
     const model = getItemModelName({

package/src/three/documentRenderer.ts

@@ -13,8 +13,8 @@ import * as THREE from 'three'
 import Stats from 'stats.js'
 import StatsGl from 'stats-gl'
 import * as tween from '@tweenjs/tween.js'
-import { WorldRendererConfig } from '../lib/worldrendererCommon'
 import type { GraphicsInitOptions } from '../graphicsBackend/types'
+import { WorldRendererConfig } from '../graphicsBackend'
 
 // ============================================================================
 // Types (co-located with implementation)
@@ -208,7 +208,7 @@ export class DocumentRenderer {
 
     try {
       this.renderer = new THREE.WebGLRenderer({
-        canvas: this.canvas,
+        canvas: this.canvas as HTMLCanvasElement,
         preserveDrawingBuffer: true,
         logarithmicDepthBuffer: true,
         powerPreference: this.config.powerPreference

package/src/three/graphicsBackendBase.ts

@@ -66,6 +66,8 @@ export const getBackendMethods = (worldRenderer: WorldRendererThree): any => {
     launchFirework: worldRenderer.fireworks.launchFirework.bind(worldRenderer.fireworks),
     // New method for updating skybox
     setSkyboxImage: worldRenderer.skyboxRenderer.setSkyboxImage.bind(worldRenderer.skyboxRenderer),
+    // Rain methods
+    setRain: (newState: boolean) => worldRenderer.toggleModule('rain', newState),
     async loadGeometryExport(exportData: any) {
       // Import dynamically to avoid circular dependencies
       const { applyWorldGeometryExport } = await import('./worldGeometryExport')

package/src/three/holdingBlock.ts

@@ -7,7 +7,6 @@ import { BlockModel } from 'mc-assets'
 import { DebugGui } from '../lib/DebugGui'
 import { SmoothSwitcher } from '../lib/smoothSwitcher'
 import { watchProperty } from '../lib/utils/proxy'
-import { WorldRendererConfig } from '../lib/worldrendererCommon'
 import { getMyHand } from './hand'
 import { WorldRendererThree } from './worldRendererThree'
 import { disposeObject } from './threeJsUtils'
@@ -16,6 +15,7 @@ import { PlayerStateRenderer } from '../playerState/playerState'
 import { getThreeBlockModelGroup } from '../mesher/standaloneRenderer'
 import { IndexedData } from 'minecraft-data'
 import type { ResourcesManagerTransferred } from '../resourcesManager'
+import { WorldRendererConfig } from '../graphicsBackend'
 
 const rotationPositionData = {
   itemRight: {

package/src/three/modules/index.ts

@@ -1,8 +1,10 @@
 //@ts-nocheck
+import { rainManifest } from './rain'
 import { sciFiWorldRevealManifest } from './sciFiWorldReveal'
 import { starfieldManifest } from './starfield'
 
 export const BUILTIN_MODULES = {
   starfield: starfieldManifest,
   futuristicReveal: sciFiWorldRevealManifest,
+  rain: rainManifest,
 }

package/src/three/modules/rain.ts

@@ -0,0 +1,181 @@
+//@ts-nocheck
+import * as THREE from 'three'
+import type { WorldRendererThree } from '../worldRendererThree'
+import type { RendererModuleController, RendererModuleManifest } from '../rendererModuleSystem'
+
+interface RainParticleData {
+  velocity: THREE.Vector3
+  age: number
+  despawnOffset: number
+}
+
+const PARTICLE_COUNT = 2000
+const RANGE = 32
+const HEIGHT = 32
+const FALL_SPEED_MIN = 0.2
+const FALL_SPEED_MAX = 0.4
+const HORIZONTAL_DRIFT = 0.02
+const RESPAWN_BELOW = -5
+
+export class RainModule implements RendererModuleController {
+  private instancedMesh?: THREE.InstancedMesh
+  private geometry?: THREE.BoxGeometry
+  private material?: THREE.MeshBasicMaterial
+  private particles: RainParticleData[] = []
+  private enabled = false
+  private readonly dummy = new THREE.Matrix4()
+  private readonly tempPosition = new THREE.Vector3()
+  private readonly tempQuaternion = new THREE.Quaternion()
+  private readonly tempScale = new THREE.Vector3()
+
+  constructor(private readonly worldRenderer: WorldRendererThree) { }
+
+  enable(): void {
+    if (this.enabled) return
+    this.enabled = true
+    if (!this.instancedMesh) {
+      this.createRain()
+    } else {
+      this.instancedMesh.visible = true
+    }
+  }
+
+  disable(): void {
+    if (!this.enabled) return
+    this.enabled = false
+    if (this.instancedMesh) {
+      this.instancedMesh.visible = false
+    }
+  }
+
+  render?: () => void = () => {
+    if (!this.enabled || !this.instancedMesh) return
+
+    const cameraPos = this.worldRenderer.getCameraPosition()
+    this.instancedMesh.position.copy(cameraPos)
+
+    const heightmaps = this.worldRenderer.reactiveState.world.heightmaps
+
+    const { dummy, tempPosition: position, tempQuaternion: quaternion, tempScale: scale } = this
+
+    // Cache chunk key lookup to avoid redundant Map.get and string allocation
+    let prevChunkX = NaN
+    let prevChunkZ = NaN
+    let cachedHeightmap: Int16Array | undefined
+
+    for (let i = 0; i < PARTICLE_COUNT; i++) {
+      const particle = this.particles[i]
+      this.instancedMesh.getMatrixAt(i, dummy)
+      dummy.decompose(position, quaternion, scale)
+
+      position.add(particle.velocity)
+
+      const relativeY = position.y
+      const horizontalDist = Math.sqrt(position.x * position.x + position.z * position.z)
+
+      // Convert camera-relative position to world coordinates
+      const worldX = cameraPos.x + position.x
+      const worldY = cameraPos.y + position.y
+      const worldZ = cameraPos.z + position.z
+
+      // Look up heightmap for this world position (cached per chunk)
+      const chunkX = Math.floor(worldX / 16)
+      const chunkZ = Math.floor(worldZ / 16)
+      if (chunkX !== prevChunkX || chunkZ !== prevChunkZ) {
+        cachedHeightmap = heightmaps.get(`${chunkX},${chunkZ}`)
+        prevChunkX = chunkX
+        prevChunkZ = chunkZ
+      }
+
+      const localX = ((Math.floor(worldX) % 16) + 16) % 16
+      const localZ = ((Math.floor(worldZ) % 16) + 16) % 16
+      const heightY = cachedHeightmap?.[localZ * 16 + localX]
+
+      // Respawn when: out of range, hit heightmap surface (heightY + 1 = block top face), or fell too far
+      const shouldRespawn = horizontalDist > RANGE ||
+        (heightY !== undefined && heightY !== -32768 && worldY <= heightY + 1 + particle.despawnOffset) ||
+        relativeY < RESPAWN_BELOW
+
+      if (shouldRespawn) {
+        this.respawnParticle(position)
+        const speed = FALL_SPEED_MIN + Math.random() * (FALL_SPEED_MAX - FALL_SPEED_MIN)
+        particle.velocity.set(
+          (Math.random() - 0.5) * HORIZONTAL_DRIFT,
+          -speed,
+          (Math.random() - 0.5) * HORIZONTAL_DRIFT,
+        )
+        particle.despawnOffset = Math.random() * 0.5
+      }
+
+      dummy.compose(position, quaternion, scale)
+      this.instancedMesh.setMatrixAt(i, dummy)
+    }
+
+    this.instancedMesh.instanceMatrix.needsUpdate = true
+  }
+
+  dispose(): void {
+    if (this.instancedMesh) {
+      this.worldRenderer.scene.remove(this.instancedMesh)
+    }
+    this.geometry?.dispose()
+    this.material?.dispose()
+    this.instancedMesh = undefined
+    this.geometry = undefined
+    this.material = undefined
+    this.particles = []
+  }
+
+  private createRain(): void {
+    this.geometry = new THREE.BoxGeometry(0.03, 0.3, 0.03)
+    this.material = new THREE.MeshBasicMaterial({
+      color: 0x44_66_99,
+      transparent: true,
+      opacity: 0.6,
+    })
+
+    this.instancedMesh = new THREE.InstancedMesh(this.geometry, this.material, PARTICLE_COUNT)
+    this.instancedMesh.name = 'rain-particles'
+
+    const dummy = new THREE.Matrix4()
+    const position = new THREE.Vector3()
+
+    for (let i = 0; i < PARTICLE_COUNT; i++) {
+      this.respawnParticle(position)
+      position.y = Math.random() * HEIGHT
+      dummy.setPosition(position)
+      this.instancedMesh.setMatrixAt(i, dummy)
+
+      const speed = FALL_SPEED_MIN + Math.random() * (FALL_SPEED_MAX - FALL_SPEED_MIN)
+      this.particles.push({
+        velocity: new THREE.Vector3(
+          (Math.random() - 0.5) * HORIZONTAL_DRIFT,
+          -speed,
+          (Math.random() - 0.5) * HORIZONTAL_DRIFT,
+        ),
+        age: 0,
+        despawnOffset: Math.random() * 0.5,
+      })
+    }
+
+    this.instancedMesh.instanceMatrix.needsUpdate = true
+    this.worldRenderer.scene.add(this.instancedMesh)
+  }
+
+  private respawnParticle(position: THREE.Vector3): void {
+    const angle = Math.random() * Math.PI * 2
+    const distance = Math.random() * RANGE
+    position.set(
+      Math.cos(angle) * distance,
+      HEIGHT,
+      Math.sin(angle) * distance,
+    )
+  }
+}
+
+export const rainManifest: RendererModuleManifest = {
+  id: 'rain',
+  controller: RainModule,
+  enabledDefault: false,
+  requiresHeightmap: true,
+}

package/src/three/modules/sciFiWorldReveal.ts

@@ -99,6 +99,15 @@ export class SciFiWorldRevealModule implements RendererModuleController {
     this.reset()
   }
 
+  toggle(): boolean {
+    if (this.enabled) {
+      this.disable()
+    } else {
+      this.enable()
+    }
+    return this.enabled
+  }
+
   render?: () => void = () => {
     if (!this.enabled) return
     this.update(16)

package/src/three/modules/starfield.ts

@@ -56,6 +56,15 @@ export class StarfieldModule implements RendererModuleController {
     this.removeStars()
   }
 
+  toggle(): boolean {
+    if (this.enabled) {
+      this.disable()
+    } else {
+      this.enable()
+    }
+    return this.enabled
+  }
+
   enablementCheck?: () => boolean = () => {
     if (!this.currentTime) return false
     const nightTime = 13_500

package/src/three/renderSlot.ts

@@ -17,10 +17,10 @@ export const renderSlot = (model: ResolvedItemModelRender, resourcesManager: Res
   modelName: string | null,
 } => {
   let itemModelName = model.modelName
-  const isItem = loadedData.itemsByName[itemModelName]
+  const isItem = globalThis.loadedData.itemsByName[itemModelName]
 
   // #region normalize item name
-  if (versionToNumber(bot.version) < versionToNumber('1.13')) itemModelName = getRenamedData(isItem ? 'items' : 'blocks', itemModelName, bot.version, '1.13.1') as string
+  if (versionToNumber(resourcesManager.currentResources!.version) < versionToNumber('1.13')) itemModelName = getRenamedData(isItem ? 'items' : 'blocks', itemModelName, resourcesManager.currentResources!.version, '1.13.1') as string
   // #endregion
 
 
@@ -47,18 +47,18 @@ export const renderSlot = (model: ResolvedItemModelRender, resourcesManager: Res
   const blockToTopTexture = (r) => r.top ?? r
 
   try {
-    if (!appViewer.resourcesManager.currentResources?.itemsRenderer) throw new Error('Items renderer is not available')
+    if (!resourcesManager.currentResources?.itemsRenderer) throw new Error('Items renderer is not available')
     itemTexture =
-      appViewer.resourcesManager.currentResources.itemsRenderer.getItemTexture(itemModelName, {}, false, fullBlockModelSupport)
-      ?? (model.originalItemName ? appViewer.resourcesManager.currentResources.itemsRenderer.getItemTexture(model.originalItemName, {}, false, fullBlockModelSupport) : undefined)
-      ?? appViewer.resourcesManager.currentResources.itemsRenderer.getItemTexture('item/missing_texture')!
+      resourcesManager.currentResources.itemsRenderer.getItemTexture(itemModelName, {}, false, fullBlockModelSupport)
+      ?? (model.originalItemName ? resourcesManager.currentResources.itemsRenderer.getItemTexture(model.originalItemName, {}, false, fullBlockModelSupport) : undefined)
+      ?? resourcesManager.currentResources.itemsRenderer.getItemTexture('item/missing_texture')!
   } catch (err) {
     // get resourcepack from resource manager
-    reportError?.(`Failed to render item ${itemModelName} (original: ${model.originalItemName}) on ${bot.version} (resourcepack: TODO!): ${err.stack}`)
-    itemTexture = blockToTopTexture(appViewer.resourcesManager.currentResources!.itemsRenderer!.getItemTexture('errored')!)
+    reportError?.(`Failed to render item ${itemModelName} (original: ${model.originalItemName}) on ${resourcesManager.currentResources!.version} (resourcepack: TODO!): ${err.stack}`)
+    itemTexture = blockToTopTexture(resourcesManager.currentResources!.itemsRenderer!.getItemTexture('errored')!)
   }
 
-  itemTexture ??= blockToTopTexture(appViewer.resourcesManager.currentResources!.itemsRenderer!.getItemTexture('unknown')!)
+  itemTexture ??= blockToTopTexture(resourcesManager.currentResources!.itemsRenderer!.getItemTexture('unknown')!)
 
 
   if ('type' in itemTexture) {

package/src/three/rendererModuleSystem.ts

@@ -29,10 +29,13 @@ export interface RendererModuleManifest {
   cannotBeDisabled?: boolean
   slowSystemAutoDisable?: boolean
   userSettingsSchema?: Record<string, any>
+
+  requiresHeightmap?: boolean
 }
 
 export interface RegisteredModule {
   manifest: RendererModuleManifest
   controller: RendererModuleController
   enabled: boolean
+  toggle: () => boolean
 }