minecraft-renderer 0.1.23 → 0.1.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",
@@ -120,6 +120,7 @@
     "build:lib:minify": "node scripts/buildLib.mjs --minify",
     "watch:lib": "node scripts/buildLib.mjs -w",
     "build:mesher": "node scripts/buildMesherWorker.mjs",
+    "build:wasm": "cd wasm-mesher && ./build.sh web",
     "watch:mesher": "pnpm build:mesher -w",
     "build:threeworker": "node scripts/buildThreeWorker.mjs",
     "watch:threeworker": "pnpm build:threeworker -w",

package/src/sign-renderer/index.ts

@@ -100,6 +100,7 @@ export const renderComponent = (
   defaultColor: string,
   offset = 0
 ) => {
+  let textRendered = false
   // todo: in pre flatenning it seems the format was not json
   const parsed = typeof text === 'string' && (text?.startsWith('{') || text?.startsWith('"')) ? parseSafe(text ?? '""', 'sign text') : text
   if (!parsed || (typeof parsed !== 'object' && typeof parsed !== 'string')) return
@@ -162,6 +163,9 @@ export const renderComponent = (
   }
 
   const addTextPart = (text: string, formatting: Formatting) => {
+    if (!textRendered) {
+      textRendered = text.trim() !== ''
+    }
     plainText += text
     textWidths[textOffset] = ctx.measureText(plainText).width
     let color = formatting.color ?? defaultColor
@@ -214,4 +218,6 @@ export const renderComponent = (
     }
     renderedWidth += ctx.measureText(text).width
   }
+
+  return textRendered
 }

package/src/three/cameraShake.ts

@@ -10,7 +10,7 @@ export class CameraShake {
   private basePitch = 0
   private baseYaw = 0
 
-  constructor(public worldRenderer: WorldRendererThree, public onRenderCallbacks: Array<() => void>) {
+  constructor(public worldRenderer: WorldRendererThree, public onRenderCallbacks: Array<(deltaTime: number) => void>) {
     onRenderCallbacks.push(() => {
       this.update()
     })

package/src/three/entities.ts

@@ -133,21 +133,25 @@ function getUsernameTexture({
 
   ctx.globalAlpha = nameTagTextOpacity / 255
 
-  renderComponent(username, PrismarineChat, canvas, fontSize, 'white', -padding + fontSize)
+  const textRendered = renderComponent(username, PrismarineChat, canvas, fontSize, 'white', -padding + fontSize)
+  if (!textRendered) return undefined
 
   ctx.globalAlpha = 1
 
   return canvas
 }
 
+globalThis.getUsernameTexture = getUsernameTexture
+
 const addNametag = (entity, options: { fontFamily: string }, mesh, version: string) => {
   for (const c of mesh.children) {
     if (c.name === 'nametag') {
       c.removeFromParent()
     }
   }
-  if (entity.username !== undefined) {
+  if (entity.username !== undefined && !entity.username.startsWith('EMPTY')) {
     const canvas = getUsernameTexture(entity, options, version)
+    if (!canvas) return
     const tex = new THREE.Texture(canvas)
     tex.needsUpdate = true
     let nameTag: THREE.Object3D

package/src/three/entity/EntityMesh.ts

@@ -13,6 +13,7 @@ import { WorldRendererThree } from '../worldRendererThree'
 import entities from './entities.json'
 import { externalModels } from './objModels'
 import externalTexturesJson from './externalTextures.json'
+import { createAnimatedObject } from './gltfAnimationUtils'
 
 interface ElemFace {
   dir: [number, number, number]
@@ -67,6 +68,8 @@ interface EntityOverrides {
       offset?: { x?: number, y?: number, z?: number }
       texture?: string
       textures?: Record<string, string>
+      animation?: string
+      animationLoop?: boolean
     }
   }
 }
@@ -242,23 +245,23 @@ export function getMesh(
   overrides: EntityOverrides = {},
   debugFlags: EntityDebugFlags = {}
 ): THREE.SkinnedMesh {
-  const textureWidth = jsonModel.texturewidth ?? 64
-  const textureHeight = jsonModel.textureheight ?? 64
+  let textureWidth = jsonModel.texturewidth ?? 64
+  let textureHeight = jsonModel.textureheight ?? 64
   let textureOffset: number[] | undefined
   const useBlockTexture = texture.startsWith('block:')
   const blocksTexture = worldRenderer?.material.map
   if (useBlockTexture) {
-    // if (!worldRenderer) throw new Error('worldRenderer is required for block textures')
-    // const blockName = texture.slice(6)
-    // const textureInfo = worldRenderer.resourcesManager.currentResources.blocksAtlasJson.textures[blockName]
-    // if (textureInfo) {
-    //   textureWidth = blocksTexture?.image.width ?? textureWidth
-    //   textureHeight = blocksTexture?.image.height ?? textureHeight
-    //   // todo support su/sv
-    //   textureOffset = [textureInfo.u, textureInfo.v]
-    // } else {
-    //   console.error(`Unknown block ${blockName}`)
-    // }
+    if (!worldRenderer) throw new Error('worldRenderer is required for block textures')
+    const blockName = texture.slice(6)
+    const textureInfo = worldRenderer.resourcesManager.currentResources.blocksAtlasJson.textures[blockName]
+    if (textureInfo) {
+      textureWidth = blocksTexture?.image.width ?? textureWidth
+      textureHeight = blocksTexture?.image.height ?? textureHeight
+      // todo support su/sv
+      textureOffset = [textureInfo.u, textureInfo.v]
+    } else {
+      console.error(`Unknown block ${blockName}`)
+    }
   }
 
   const bones: Record<string, THREE.Bone> = {}
@@ -450,7 +453,9 @@ export type EntityDebugFlags = {
 export class EntityMesh {
   mesh!: THREE.Object3D
   animations?: THREE.AnimationClip[]
-  mixer?: THREE.AnimationMixer
+  private animationController?: ReturnType<typeof createAnimatedObject>
+  private initialAnimation?: string
+  private initialLoop?: boolean
 
   constructor(
     version: string,
@@ -468,17 +473,19 @@ export class EntityMesh {
 
     // Handle custom model override
     if (overrides.customModel) {
+      // empty mesh to allow "handled" entity and not pink box
+      this.mesh = new THREE.Object3D()
+
       const { modelPath, modelType, metadata } = overrides.customModel
 
       switch (modelType) {
         case 'gltf': {
           const loader = new GLTFLoader()
-          const gltfData = loader.parseAsync(modelPath as ArrayBuffer, '')
+          const gltfData = loader.parseAsync(modelPath, '')
 
           gltfData.then(gltf => {
-            this.mesh = gltf.scene
+            this.mesh.add(gltf.scene)
             this.animations = gltf.animations
-            this.mixer = new THREE.AnimationMixer(this.mesh)
 
             // Apply metadata overrides if available
             if (metadata?.scale) {
@@ -505,6 +512,29 @@ export class EntityMesh {
                 }
               })
             }
+
+            // Handle animations: play from config if provided, otherwise play first animation if present
+            if (gltf.animations && gltf.animations.length > 0) {
+              this.animations = gltf.animations
+              const animationName = metadata?.animation
+              const loop = metadata?.animationLoop ?? true
+
+              // Store initial animation settings for later use
+              this.initialAnimation = animationName
+              this.initialLoop = loop
+
+              // Create animation controller with onBeforeRender support
+              this.animationController = createAnimatedObject(this.mesh, gltf.animations)
+
+              if (animationName) {
+                // Play animation from config
+                this.playAnimation(animationName, loop)
+              } else {
+                // Play first animation
+                const clip = gltf.animations[0]
+                this.animationController.playAnimation(clip.name, loop)
+              }
+            }
           }).catch(err => {
             console.error('Failed to load GLTF model:', err)
           })
@@ -666,29 +696,21 @@ export class EntityMesh {
   }
 
   playAnimation(name: string, loop = false) {
-    if (!this.mixer || !this.animations) return
-
-    // Find animation by name
-    const clip = this.animations.find(a => a.name === name)
-    if (!clip) {
-      console.warn(`Animation "${name}" not found`)
+    if (!this.animationController || !this.animations) {
+      console.warn('No animation controller available')
       return
     }
 
-    // Stop any existing animations
-    this.mixer.stopAllAction()
-
-    // Play new animation
-    const action = this.mixer.clipAction(clip)
-    action.setLoop(loop ? THREE.LoopRepeat : THREE.LoopOnce, Infinity)
-    action.clampWhenFinished = !loop
-    action.reset().play()
+    // Play animation using the controller
+    const success = this.animationController.playAnimation(name, loop)
+    if (!success) {
+      console.warn(`Animation "${name}" not found`)
+    }
   }
 
   update(deltaTime: number) {
-    if (this.mixer) {
-      this.mixer.update(deltaTime)
-    }
+    // Animation updates are now handled by onBeforeRender callback
+    // This method is kept for compatibility but no longer needed
   }
 
   static getStaticData(name: string): { boneNames: string[] } {

package/src/three/entity/gltfAnimationUtils.ts

@@ -0,0 +1,141 @@
+//@ts-nocheck
+import * as THREE from 'three'
+
+export interface AnimationState {
+  mixer: THREE.AnimationMixer
+  animations: THREE.AnimationClip[]
+  actions: Map<string, THREE.AnimationAction>
+  speed: number
+  loop: boolean
+}
+
+export class AnimationManager {
+  private readonly clock = new THREE.Clock()
+  private readonly animatedObjects = new Set<THREE.Object3D>()
+  state!: AnimationState
+
+  constructor(
+    public object: THREE.Object3D,
+    public animations: THREE.AnimationClip[]
+  ) {
+    // Private constructor for singleton
+  }
+
+  /**
+   * Creates an animation state for a Three.js object
+   */
+  createAnimationState(): AnimationState {
+    const mixer = new THREE.AnimationMixer(this.object)
+    const actions = new Map<string, THREE.AnimationAction>()
+
+    // Store clips as actions for easy access
+    for (const clip of this.animations) {
+      actions.set(clip.name, mixer.clipAction(clip))
+    }
+
+    this.state = {
+      mixer,
+      animations: this.animations,
+      actions,
+      speed: 1,
+      loop: true
+    }
+
+    // Set up onBeforeRender callback for renderable objects
+    // onBeforeRender only works on renderable objects (Mesh, Line, Points, Sprite)
+    this.object.traverse((child) => {
+      if (child instanceof THREE.Mesh || child instanceof THREE.Line || child instanceof THREE.Points || child instanceof THREE.Sprite) {
+        const originalOnBeforeRender = child.onBeforeRender
+        child.onBeforeRender = (renderer, scene, camera, geometry, material, group) => {
+          const delta = this.clock.getDelta()
+          mixer.update(delta)
+          // Call original onBeforeRender if it existed
+          originalOnBeforeRender?.(renderer, scene, camera, geometry, material, group)
+        }
+      }
+    })
+
+    // Track animated objects
+    this.animatedObjects.add(this.object)
+
+    return this.state
+  }
+
+  /**
+   * Plays an animation by name
+   */
+  playAnimation(name: string, loop?: boolean, speed?: number): boolean {
+    const action = this.state.actions.get(name)
+    if (!action) {
+      console.warn(`Animation "${name}" not found`)
+      return false
+    }
+
+    // Stop any existing animations
+    this.state.mixer.stopAllAction()
+
+    // Configure animation
+    const shouldLoop = loop ?? this.state.loop
+    action.setLoop(shouldLoop ? THREE.LoopRepeat : THREE.LoopOnce, Infinity)
+    action.clampWhenFinished = !shouldLoop
+
+    if (speed === undefined) {
+      action.timeScale = this.state.speed
+    } else {
+      action.timeScale = speed
+    }
+
+    action.reset().fadeIn(0.1).play()
+    return true
+  }
+
+  /**
+   * Updates animation parameters for a state
+   */
+  updateAnimationParams(speed?: number, loop?: boolean): void {
+    if (speed !== undefined) {
+      this.state.speed = speed
+    }
+    if (loop !== undefined) {
+      this.state.loop = loop
+    }
+
+    // Update existing actions
+    for (const action of this.state.actions.values()) {
+      if (speed !== undefined) {
+        action.timeScale = speed
+      }
+      if (loop !== undefined) {
+        action.setLoop(loop ? THREE.LoopRepeat : THREE.LoopOnce, Infinity)
+        action.clampWhenFinished = !loop
+      }
+    }
+  }
+
+  /**
+   * Stops all animations for a state
+   */
+  stopAnimations(): void {
+    this.state.mixer.stopAllAction()
+  }
+
+  /**
+   * Gets the current clock delta (useful for manual updates)
+   */
+  getDelta(): number {
+    return this.clock.getDelta()
+  }
+}
+
+/**
+ * Convenience function to create and manage animations for an object
+ */
+export function createAnimatedObject(
+  object: THREE.Object3D,
+  animations: THREE.AnimationClip[]
+) {
+  const manager = new AnimationManager(object, animations)
+  manager.createAnimationState()
+
+  return manager
+}

package/src/three/modules/rain.ts

@@ -12,9 +12,9 @@ interface RainParticleData {
 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 FALL_SPEED_MIN = 12
+const FALL_SPEED_MAX = 24
+const HORIZONTAL_DRIFT = 1.2
 const RESPAWN_BELOW = -5
 
 export class RainModule implements RendererModuleController {
@@ -52,7 +52,7 @@ export class RainModule implements RendererModuleController {
     return this.worldRenderer.worldRendererConfig.isRaining === true
   }
 
-  render?: () => void = () => {
+  render?: (deltaTime: number) => void = (deltaTime) => {
     if (!this.enabled || !this.instancedMesh) return
 
     const cameraPos = this.worldRenderer.getCameraPosition()
@@ -72,7 +72,7 @@ export class RainModule implements RendererModuleController {
       this.instancedMesh.getMatrixAt(i, dummy)
       dummy.decompose(position, quaternion, scale)
 
-      position.add(particle.velocity)
+      position.addScaledVector(particle.velocity, deltaTime)
 
       const relativeY = position.y
       const horizontalDist = Math.sqrt(position.x * position.x + position.z * position.z)

package/src/three/modules/sciFiWorldReveal.ts

@@ -108,9 +108,9 @@ export class SciFiWorldRevealModule implements RendererModuleController {
     return this.enabled
   }
 
-  render?: () => void = () => {
+  render?: (deltaTime: number) => void = (deltaTime) => {
     if (!this.enabled) return
-    this.update(16)
+    this.update(deltaTime * 1000)
   }
 
   dispose(): void {

package/src/three/modules/starfield.ts

@@ -72,7 +72,7 @@ export class StarfieldModule implements RendererModuleController {
     return this.currentTime > nightTime && this.currentTime < morningStart
   }
 
-  render?: () => void = () => {
+  render?: (deltaTime: number) => void = (_deltaTime) => {
     if (!this.points) return
     this.points.position.copy(this.worldRenderer.getCameraPosition())
       ; (this.points.material as StarfieldMaterial).uniforms.time.value =

package/src/three/rendererModuleSystem.ts

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

package/src/three/worldRendererThree.ts

@@ -57,7 +57,8 @@ export class WorldRendererThree extends WorldRendererCommon {
   material = new THREE.MeshLambertMaterial({ vertexColors: true, transparent: true, alphaTest: 0.1 })
   itemsTexture!: THREE.Texture
   cursorBlock: CursorBlock
-  onRender: Array<() => void> = []
+  onRender: Array<(deltaTime: number) => void> = []
+  private lastRenderTime = 0
   cameraShake: CameraShake
   cameraContainer!: THREE.Object3D
   media: ThreeJsMedia
@@ -928,6 +929,10 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.debugChunksVisibilityOverride()
     const start = performance.now()
     this.lastRendered = performance.now()
+    const deltaTime = this.lastRenderTime > 0
+      ? Math.min(Math.max((start - this.lastRenderTime) / 1000, 0), 0.1)
+      : 1 / 60
+    this.lastRenderTime = start
     this.cursorBlock.render()
     this.updateSectionOffsets()
 
@@ -974,7 +979,7 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.fireworks.update()
 
     for (const onRender of this.onRender) {
-      onRender()
+      onRender(deltaTime)
     }
     const end = performance.now()
     const totalTime = end - start

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, 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(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_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 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 type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 

package/wasm/wasm_mesher.js

@@ -227,7 +227,6 @@ 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
@@ -242,14 +241,13 @@ 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, 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) {
+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) {
     _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);
@@ -271,7 +269,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, 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);
+    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);
     return ret;
 }
 
@@ -298,14 +296,13 @@ 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, 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) {
+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) {
     _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);
@@ -331,7 +328,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, 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);
+    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);
     return ret;
 }