minecraft-renderer 0.1.22 → 0.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/graphicsBackend/config.ts

@@ -59,7 +59,11 @@ export const defaultWorldRendererConfig = {
   // World settings
   clipWorldBelowY: undefined as undefined | number,
   isPlayground: false,
-  instantCameraUpdate: false
+  instantCameraUpdate: false,
+  isRaining: false,
+
+  // Module states: 'enabled' = force on, 'disabled' = force off, 'auto' = use autoEnableCheck
+  moduleStates: {} as Record<string, 'enabled' | 'disabled' | 'auto'>
 }
 
 export type WorldRendererConfig = typeof defaultWorldRendererConfig

package/src/lib/worldrendererCommon.ts

@@ -5,7 +5,7 @@ import { Vec3 } from 'vec3'
 import TypedEmitter from 'typed-emitter'
 import { WorldBlockProvider } from 'mc-assets/dist/worldBlockProvider'
 import { subscribeKey } from 'valtio/utils'
-import { proxy } from 'valtio'
+import { proxy, subscribe } from 'valtio'
 import type { ResourcesManagerTransferred } from '../resourcesManager/resourcesManager'
 import { dynamicMcDataFiles } from './buildSharedConfig.mjs'
 import { DisplayWorldOptions, GraphicsInitOptions, RendererReactiveState, SoundSystem } from '../graphicsBackend/types'
@@ -106,6 +106,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   debugStopGeometryUpdate = false
 
   protocolCustomBlocks = new Map<string, CustomBlockModels>()
+  private heightmapDebounceTimers = new Map<string, ReturnType<typeof setTimeout>>()
 
   blockStateModelInfo = new Map<string, BlockStateModelInfo>()
 
@@ -115,6 +116,11 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
   abstract changeBackgroundColor(color: [number, number, number]): void
 
+  /** Override in subclass to check if any enabled module requires heightmap data */
+  protected anyModuleRequiresHeightmap(): boolean {
+    return false
+  }
+
   worldRendererConfig: WorldRendererConfig
   playerStateReactive: PlayerStateReactive
   playerStateUtils: PlayerStateUtils
@@ -279,7 +285,11 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
   onReactiveConfigUpdated<T extends keyof typeof this.worldRendererConfig>(key: T, callback: (value: typeof this.worldRendererConfig[T]) => void) {
     callback(this.worldRendererConfig[key])
-    subscribeKey(this.worldRendererConfig, key, callback)
+    if ((key as any) === '*') {
+      subscribe(this.worldRendererConfig, callback as any)
+    } else {
+      subscribeKey(this.worldRendererConfig, key, callback)
+    }
   }
 
   onReactiveDebugUpdated<T extends keyof typeof this.reactiveDebugParams>(key: T, callback: (value: typeof this.reactiveDebugParams[T]) => void) {
@@ -665,6 +675,13 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
   removeColumn(x, z) {
     delete this.loadedChunks[`${x},${z}`]
+    // Cancel any pending heightmap debounce for this chunk
+    const debounceKey = `${x},${z}`
+    const pendingTimer = this.heightmapDebounceTimers.get(debounceKey)
+    if (pendingTimer) {
+      clearTimeout(pendingTimer)
+      this.heightmapDebounceTimers.delete(debounceKey)
+    }
     for (const worker of this.workers) {
       worker.postMessage({ type: 'unloadChunk', x, z })
     }
@@ -849,10 +866,18 @@ 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 })
+    // Re-request heightmap for the affected chunk after block change (debounced)
+    if (this.anyModuleRequiresHeightmap()) {
+      const chunkCornerX = Math.floor(pos.x / CHUNK_SIZE) * CHUNK_SIZE
+      const chunkCornerZ = Math.floor(pos.z / CHUNK_SIZE) * CHUNK_SIZE
+      const chunkKey2 = `${chunkCornerX},${chunkCornerZ}`
+      const existing = this.heightmapDebounceTimers.get(chunkKey2)
+      if (existing) clearTimeout(existing)
+      this.heightmapDebounceTimers.set(chunkKey2, setTimeout(() => {
+        this.heightmapDebounceTimers.delete(chunkKey2)
+        this.workers[0]?.postMessage({ type: 'getHeightmap', x: chunkCornerX, z: chunkCornerZ })
+      }, 100))
+    }
     this.logWorkerWork(`-> blockUpdate ${JSON.stringify({ pos, stateId, customBlockModels })}`)
     this.setSectionDirty(pos, true, true)
     if (this.neighborChunkUpdates) {
@@ -1023,6 +1048,12 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   }
 
   destroy() {
+    // Cancel all pending heightmap debounce timers
+    for (const timer of this.heightmapDebounceTimers.values()) {
+      clearTimeout(timer)
+    }
+    this.heightmapDebounceTimers.clear()
+
     // Stop all workers
     for (const worker of this.workers) {
       worker.terminate()

package/src/three/modules/rain.ts

@@ -48,6 +48,10 @@ export class RainModule implements RendererModuleController {
     }
   }
 
+  autoEnableCheck(): boolean {
+    return this.worldRenderer.worldRendererConfig.isRaining === true
+  }
+
   render?: () => void = () => {
     if (!this.enabled || !this.instancedMesh) return
 

package/src/three/rendererModuleSystem.ts

@@ -10,6 +10,7 @@ export interface RendererModuleController {
   dispose(): void
 
   enablementCheck?: () => boolean
+  autoEnableCheck?: () => boolean // Called when config updates, returns true to enable, false to disable
   render?: () => void
 }
 

package/src/three/worldRendererThree.ts

@@ -297,11 +297,8 @@ export class WorldRendererThree extends WorldRendererCommon {
    * Initialize all registered modules
    */
   private initializeModules(): void {
-    for (const [id, module] of Object.entries(this.modules)) {
-      if (module.manifest.enabledDefault) {
-        this.enableModule(id)
-      }
-    }
+    // Use updateModulesFromConfig to handle initial state correctly (respects force states and auto-enable)
+    this.updateModulesFromConfig()
   }
 
   /**
@@ -311,6 +308,10 @@ export class WorldRendererThree extends WorldRendererCommon {
     return this.modules[moduleId]?.controller as T | undefined
   }
 
+  protected override anyModuleRequiresHeightmap(): boolean {
+    return Object.values(this.modules).some(m => m.enabled && m.manifest.requiresHeightmap)
+  }
+
   get cameraObject() {
     return this.cameraGroupVr ?? this.cameraContainer
   }
@@ -408,6 +409,61 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.onReactiveConfigUpdated('defaultSkybox', (value) => {
       this.skyboxRenderer.updateDefaultSkybox(value)
     })
+
+    // Watch for config changes that affect modules
+    this.onReactiveConfigUpdated('*' as any, () => {
+      this.updateModulesFromConfig()
+    })
+
+    // Initial update
+    this.updateModulesFromConfig()
+  }
+
+  /**
+   * Update module states based on config (force states and auto-enable checks)
+   */
+  private updateModulesFromConfig(): void {
+    const { moduleStates } = this.worldRendererConfig
+
+    for (const [moduleId, module] of Object.entries(this.modules)) {
+      const forceState = moduleStates[moduleId]
+
+      // Check force states first
+      if (forceState === 'enabled') {
+        if (!module.enabled) {
+          this.toggleModule(moduleId, true)
+        }
+        continue
+      }
+
+      if (forceState === 'disabled') {
+        if (module.enabled && !module.manifest.cannotBeDisabled) {
+          this.toggleModule(moduleId, false)
+        }
+        continue
+      }
+
+      // Auto mode: use autoEnableCheck if available, otherwise use enabledDefault
+      if (forceState === 'auto' || forceState === undefined) {
+        if (module.controller.autoEnableCheck) {
+          const shouldEnable = module.controller.autoEnableCheck()
+
+          if (shouldEnable && !module.enabled) {
+            this.toggleModule(moduleId, true)
+          } else if (!shouldEnable && module.enabled && !module.manifest.cannotBeDisabled) {
+            this.toggleModule(moduleId, false)
+          }
+        } else {
+          // No autoEnableCheck: use enabledDefault
+          const shouldEnable = module.manifest.enabledDefault ?? false
+          if (shouldEnable && !module.enabled) {
+            this.toggleModule(moduleId, true)
+          } else if (!shouldEnable && module.enabled && !module.manifest.cannotBeDisabled) {
+            this.toggleModule(moduleId, false)
+          }
+        }
+      }
+    }
   }
 
   changeHandSwingingState(isAnimationPlaying: boolean, isLeft = false) {

package/wasm/wasm_mesher.d.ts

@@ -7,9 +7,9 @@
  * Input: Serialized chunk data as TypedArrays
  * Output: Geometry data (positions, normals, colors, uvs, indices)
  */
-export function generate_geometry(section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, block_states: Uint16Array, block_light: Uint8Array, sky_light: Uint8Array, biomes: Uint8Array, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
+export function generate_geometry(section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, block_states: Uint16Array, block_light: Uint8Array, sky_light: Uint8Array, biomes: Uint8Array, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
 
-export function generate_geometry_multi(section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, chunk_xs: Int32Array, chunk_zs: Int32Array, block_states: Uint16Array, block_light: Uint8Array, sky_light: Uint8Array, biomes: Uint8Array, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
+export function generate_geometry_multi(section_x: number, section_y: number, section_z: number, section_height: number, world_min_y: number, world_max_y: number, section_data_start_y: number, chunk_xs: Int32Array, chunk_zs: Int32Array, block_states: Uint16Array, block_light: Uint8Array, sky_light: Uint8Array, biomes: Uint8Array, invisible_blocks: Uint16Array, transparent_blocks: Uint16Array, no_ao_blocks: Uint16Array, cull_identical_blocks: Uint16Array, occluding_blocks: Uint16Array, enable_lighting: boolean, smooth_lighting: boolean, sky_light_value: number): any;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 

package/wasm/wasm_mesher.js

@@ -227,6 +227,7 @@ let WASM_VECTOR_LEN = 0;
  * @param {number} section_height
  * @param {number} world_min_y
  * @param {number} world_max_y
+ * @param {number} section_data_start_y
  * @param {Uint16Array} block_states
  * @param {Uint8Array} block_light
  * @param {Uint8Array} sky_light
@@ -241,13 +242,14 @@ let WASM_VECTOR_LEN = 0;
  * @param {number} sky_light_value
  * @returns {any}
  */
-export function generate_geometry(section_x, section_y, section_z, section_height, world_min_y, world_max_y, block_states, block_light, sky_light, biomes, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
+export function generate_geometry(section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, block_states, block_light, sky_light, biomes, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
     _assertNum(section_x);
     _assertNum(section_y);
     _assertNum(section_z);
     _assertNum(section_height);
     _assertNum(world_min_y);
     _assertNum(world_max_y);
+    _assertNum(section_data_start_y);
     const ptr0 = passArray16ToWasm0(block_states, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray8ToWasm0(block_light, wasm.__wbindgen_malloc);
@@ -269,7 +271,7 @@ export function generate_geometry(section_x, section_y, section_z, section_heigh
     _assertBoolean(enable_lighting);
     _assertBoolean(smooth_lighting);
     _assertNum(sky_light_value);
-    const ret = wasm.generate_geometry(section_x, section_y, section_z, section_height, world_min_y, world_max_y, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, enable_lighting, smooth_lighting, sky_light_value);
+    const ret = wasm.generate_geometry(section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, enable_lighting, smooth_lighting, sky_light_value);
     return ret;
 }
 
@@ -296,13 +298,14 @@ export function generate_geometry(section_x, section_y, section_z, section_heigh
  * @param {number} sky_light_value
  * @returns {any}
  */
-export function generate_geometry_multi(section_x, section_y, section_z, section_height, world_min_y, world_max_y, chunk_xs, chunk_zs, block_states, block_light, sky_light, biomes, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
+export function generate_geometry_multi(section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, chunk_xs, chunk_zs, block_states, block_light, sky_light, biomes, invisible_blocks, transparent_blocks, no_ao_blocks, cull_identical_blocks, occluding_blocks, enable_lighting, smooth_lighting, sky_light_value) {
     _assertNum(section_x);
     _assertNum(section_y);
     _assertNum(section_z);
     _assertNum(section_height);
     _assertNum(world_min_y);
     _assertNum(world_max_y);
+    _assertNum(section_data_start_y);
     const ptr0 = passArray32ToWasm0(chunk_xs, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray32ToWasm0(chunk_zs, wasm.__wbindgen_malloc);
@@ -328,7 +331,7 @@ export function generate_geometry_multi(section_x, section_y, section_z, section
     _assertBoolean(enable_lighting);
     _assertBoolean(smooth_lighting);
     _assertNum(sky_light_value);
-    const ret = wasm.generate_geometry_multi(section_x, section_y, section_z, section_height, world_min_y, world_max_y, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, ptr10, len10, enable_lighting, smooth_lighting, sky_light_value);
+    const ret = wasm.generate_geometry_multi(section_x, section_y, section_z, section_height, world_min_y, world_max_y, section_data_start_y, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, ptr10, len10, enable_lighting, smooth_lighting, sky_light_value);
     return ret;
 }