minecraft-renderer 0.1.32 → 0.1.34

package/package.json

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

package/src/three/graphicsBackendBase.ts

@@ -68,6 +68,14 @@ export const getBackendMethods = (worldRenderer: WorldRendererThree): any => {
     setSkyboxImage: worldRenderer.skyboxRenderer.setSkyboxImage.bind(worldRenderer.skyboxRenderer),
     // Rain methods
     setRain: (newState: boolean) => worldRenderer.toggleModule('rain', newState),
+    spawnBlockBreakParticles(x: number, y: number, z: number, blockName: string, floorMap: number[], biomeName?: string) {
+      const module = worldRenderer.getModule<import('./modules/blockBreakParticles').BlockBreakParticlesModule>('blockBreakParticles')
+      module?.spawnBlockBreakParticles(x, y, z, blockName, floorMap, biomeName)
+    },
+    spawnBlockCrackParticle(x: number, y: number, z: number, face: number, blockName: string, floorMap: number[], biomeName?: string) {
+      const module = worldRenderer.getModule<import('./modules/blockBreakParticles').BlockBreakParticlesModule>('blockBreakParticles')
+      module?.spawnCrackParticle(x, y, z, face, blockName, floorMap, biomeName)
+    },
     async loadGeometryExport(exportData: any) {
       // Import dynamically to avoid circular dependencies
       const { applyWorldGeometryExport } = await import('./worldGeometryExport')

package/src/three/holdingBlock.ts

@@ -386,9 +386,10 @@ export default class HoldingBlock implements IHoldingBlock {
       }
       const partialTick = Math.min((now - this.lastBobTickTime) / 50, 1)
 
+      const handBobSpeedMultiplier = 1.8
       const bob = computeCameraBob({
-        walkDist: ps.walkDist,
-        prevWalkDist: ps.prevWalkDist,
+        walkDist: ps.walkDist * handBobSpeedMultiplier,
+        prevWalkDist: ps.prevWalkDist * handBobSpeedMultiplier,
         bob: ps.bob,
         prevBob: ps.prevBob,
         partialTick

package/src/three/modules/blockBreakParticles.ts

@@ -0,0 +1,438 @@
+//@ts-nocheck
+import * as THREE from 'three'
+import type { WorldRendererThree } from '../worldRendererThree'
+import type { RendererModuleController, RendererModuleManifest } from '../rendererModuleSystem'
+
+// --- Tint data (lazy-loaded from globalThis.loadedData.tints at runtime) ---
+const tints: Record<string, Record<string, [number, number, number]>> = {}
+let tintsInitialized = false
+
+function ensureTintsLoaded(): void {
+  if (tintsInitialized) return
+  const tintsData = (globalThis as any).loadedData?.tints
+  if (!tintsData) return
+  for (const key of Object.keys(tintsData)) {
+    tints[key] = prepareTints(tintsData[key])
+  }
+  tintsInitialized = true
+}
+
+function prepareTints(data: any): Record<string, [number, number, number]> {
+  const result: Record<string, [number, number, number]> = {}
+  const defaultColor = tintToGl(data.default ?? 0xFFFFFF)
+  if (data.data) {
+    for (const entry of data.data) {
+      const color = tintToGl(entry.color)
+      for (const key of entry.keys) {
+        result[key] = color
+      }
+    }
+  }
+  return new Proxy(result, {
+    get(target, prop: string) {
+      return target[prop] ?? defaultColor
+    }
+  })
+}
+
+function tintToGl(tint: number): [number, number, number] {
+  return [
+    ((tint >> 16) & 0xFF) / 255,
+    ((tint >> 8) & 0xFF) / 255,
+    (tint & 0xFF) / 255,
+  ]
+}
+
+function resolveTintColor(blockName: string, biomeName: string): [number, number, number] {
+  ensureTintsLoaded()
+  if (blockName === 'grass_block') return [1, 1, 1]
+  if (blockName === 'redstone_wire') return [1, 1, 1]
+  if (blockName === 'birch_leaves' || blockName === 'spruce_leaves' || blockName === 'lily_pad') {
+    return tints.constant?.[blockName] ?? [1, 1, 1]
+  }
+  if (blockName.includes('leaves') || blockName === 'vine') {
+    return tints.foliage?.[biomeName] ?? [1, 1, 1]
+  }
+  const grassTintedBlocks = ['short_grass', 'tall_grass', 'fern', 'large_fern', 'sugar_cane', 'grass']
+  if (grassTintedBlocks.includes(blockName)) {
+    return tints.grass?.[biomeName] ?? [1, 1, 1]
+  }
+  return [1, 1, 1]
+}
+
+interface BreakParticle {
+  mesh: THREE.Mesh
+  active: boolean
+  x: number; y: number; z: number
+  prevX: number; prevY: number; prevZ: number
+  xd: number; yd: number; zd: number
+  age: number
+  maxAge: number
+  onGround: boolean
+  floorMap: number[]
+  blockX: number
+  blockZ: number
+}
+
+const MAX_PARTICLES = 512
+const TICK_RATE = 1 / 20
+
+export class BlockBreakParticlesModule implements RendererModuleController {
+  private particles: BreakParticle[] = []
+  private sharedMaterial?: THREE.MeshBasicMaterial
+  private enabled = false
+  private tickAccumulator = 0
+  private nextParticleIndex = 0
+
+  constructor(private readonly worldRenderer: WorldRendererThree) {}
+
+  enable(): void {
+    if (this.enabled) return
+    this.enabled = true
+    this.ensureMaterial()
+  }
+
+  disable(): void {
+    if (!this.enabled) return
+    this.enabled = false
+  }
+
+  dispose(): void {
+    for (const p of this.particles) {
+      if (p.active) {
+        this.worldRenderer.sceneOrigin.removeAndUntrack(p.mesh)
+      }
+      p.mesh.geometry.dispose()
+    }
+    this.particles = []
+    this.sharedMaterial?.dispose()
+    this.sharedMaterial = undefined
+    this.nextParticleIndex = 0
+  }
+
+  render = (deltaTime: number): void => {
+    if (!this.enabled) return
+
+    this.tickAccumulator += deltaTime
+    while (this.tickAccumulator >= TICK_RATE) {
+      this.tickAccumulator -= TICK_RATE
+      this.tickPhysics()
+    }
+
+    const alpha = this.tickAccumulator / TICK_RATE
+    this.updateVisuals(alpha)
+  }
+
+  spawnBlockBreakParticles(worldX: number, worldY: number, worldZ: number, blockName: string, floorMap: number[], biomeName = 'plains'): void {
+    if (!this.enabled) return
+
+    const texInfo = this.resolveBlockTexture(blockName)
+    if (!texInfo) return
+
+    const tintColor = resolveTintColor(blockName, biomeName)
+
+    for (let ox = 0; ox < 4; ox++) {
+      for (let oy = 0; oy < 4; oy++) {
+        for (let oz = 0; oz < 4; oz++) {
+          const px = worldX + (ox + 0.5) / 4
+          const py = worldY + (oy + 0.5) / 4
+          const pz = worldZ + (oz + 0.5) / 4
+
+          let motionX = px - worldX - 0.5
+          let motionY = py - worldY - 0.5
+          let motionZ = pz - worldZ - 0.5
+
+          motionX += (Math.random() * 2 - 1) * 0.4
+          motionY += (Math.random() * 2 - 1) * 0.4
+          motionZ += (Math.random() * 2 - 1) * 0.4
+
+          const strength = (Math.random() + Math.random() + 1) * 0.15
+          const len = Math.sqrt(motionX * motionX + motionY * motionY + motionZ * motionZ)
+          const xd = (motionX / len) * strength * 0.4
+          const yd = (motionY / len) * strength * 0.4 + 0.1
+          const zd = (motionZ / len) * strength * 0.4
+
+          const maxAge = Math.floor(4 / (Math.random() * 0.9 + 0.1))
+
+          this.createParticle(px, py, pz, xd, yd, zd, maxAge, texInfo, floorMap, worldX, worldZ, 1.0, tintColor)
+        }
+      }
+    }
+  }
+
+  private tickPhysics(): void {
+    for (const p of this.particles) {
+      if (!p.active) continue
+
+      p.prevX = p.x
+      p.prevY = p.y
+      p.prevZ = p.z
+
+      p.age++
+      if (p.age >= p.maxAge) {
+        this.deactivateParticle(p)
+        continue
+      }
+
+      p.yd -= 0.04
+      p.x += p.xd
+      p.y += p.yd
+      p.z += p.zd
+
+      // Recalculate onGround each tick (particle may move to a different column)
+      const floorY = this.getFloorY(p)
+      if (p.y <= floorY) {
+        p.y = floorY
+        p.yd = 0
+        p.onGround = true
+      } else {
+        p.onGround = false
+      }
+
+      p.xd *= 0.98
+      p.yd *= 0.98
+      p.zd *= 0.98
+
+      if (p.onGround) {
+        p.xd *= 0.7
+        p.zd *= 0.7
+      }
+    }
+  }
+
+  private updateVisuals(alpha: number): void {
+    // Camera is at ~(0,0,0) in scene space (sceneOrigin tracks camera)
+    const cameraPosScene = this.worldRenderer.camera.position
+
+    for (const p of this.particles) {
+      if (!p.active) continue
+
+      const displayX = p.prevX + (p.x - p.prevX) * alpha
+      const displayY = p.prevY + (p.y - p.prevY) * alpha
+      const displayZ = p.prevZ + (p.z - p.prevZ) * alpha
+
+      p.mesh.position.set(displayX, displayY, displayZ)
+      // lookAt operates in parent (scene) coords — use scene-local camera pos
+      p.mesh.lookAt(cameraPosScene.x, cameraPosScene.y, cameraPosScene.z)
+    }
+  }
+
+  spawnCrackParticle(worldX: number, worldY: number, worldZ: number, face: number, blockName: string, floorMap: number[], biomeName = 'plains'): void {
+    if (!this.enabled) return
+
+    const texInfo = this.resolveBlockTexture(blockName)
+    if (!texInfo) return
+
+    const tintColor = resolveTintColor(blockName, biomeName)
+
+    // Random position within block, inset 0.1 on each axis
+    let px = worldX + Math.random() * 0.8 + 0.1
+    let py = worldY + Math.random() * 0.8 + 0.1
+    let pz = worldZ + Math.random() * 0.8 + 0.1
+
+    // Override position on the hit face axis to be at face + 0.1 offset outward
+    switch (face) {
+      case 0: py = worldY - 0.1; break
+      case 1: py = worldY + 1.0 + 0.1; break
+      case 2: pz = worldZ - 0.1; break
+      case 3: pz = worldZ + 1.0 + 0.1; break
+      case 4: px = worldX - 0.1; break
+      case 5: px = worldX + 1.0 + 0.1; break
+    }
+
+    // Small random velocity, heavily damped
+    const xd = (Math.random() * 2 - 1) * 0.4 * 0.2
+    const yd = (Math.random() * 2 - 1) * 0.4 * 0.2 + 0.1 * 0.2
+    const zd = (Math.random() * 2 - 1) * 0.4 * 0.2
+
+    const maxAge = Math.floor(4 / (Math.random() * 0.9 + 0.1))
+
+    this.createParticle(px, py, pz, xd, yd, zd, maxAge, texInfo, floorMap, worldX, worldZ, 0.6, tintColor)
+  }
+
+  private createParticle(
+    px: number, py: number, pz: number,
+    xd: number, yd: number, zd: number,
+    maxAge: number,
+    texInfo: { u: number; v: number; su: number; sv: number },
+    floorMap: number[],
+    blockX: number, blockZ: number,
+    scaleFactor = 1.0,
+    tintColor: [number, number, number] = [1, 1, 1]
+  ): void {
+    this.ensureMaterial()
+
+    let particle = this.findInactiveParticle()
+
+    if (!particle) {
+      if (this.particles.length < MAX_PARTICLES) {
+        particle = this.allocateParticle()
+      } else {
+        particle = this.recycleOldest()
+      }
+    }
+
+    const randomU = Math.floor(Math.random() * 4)
+    const randomV = Math.floor(Math.random() * 4)
+    const particleU = texInfo.u + (randomU / 4) * texInfo.su
+    const particleV = texInfo.v + (randomV / 4) * texInfo.sv
+    const particleSU = texInfo.su / 4
+    const particleSV = texInfo.sv / 4
+
+    this.setGeometryUVs(particle.mesh.geometry as THREE.PlaneGeometry, particleU, particleV, particleSU, particleSV)
+
+    particle.active = true
+    particle.x = px; particle.y = py; particle.z = pz
+    particle.prevX = px; particle.prevY = py; particle.prevZ = pz
+    particle.xd = xd; particle.yd = yd; particle.zd = zd
+    particle.age = 0
+    particle.maxAge = maxAge
+    particle.onGround = false
+    particle.floorMap = floorMap
+    particle.blockX = Math.floor(blockX)
+    particle.blockZ = Math.floor(blockZ)
+
+    const scale = 0.1 * (0.5 + Math.random() * 0.5) * 2 * scaleFactor
+    particle.mesh.scale.set(scale, scale, scale)
+    particle.mesh.position.set(px, py, pz)
+    particle.mesh.visible = true
+
+    // Apply tint: base darkening 0.6 × tint color
+    const r = 0.6 * tintColor[0]
+    const g = 0.6 * tintColor[1]
+    const b = 0.6 * tintColor[2]
+    const colorArray = new Float32Array([r, g, b, r, g, b, r, g, b, r, g, b])
+    const colorAttr = particle.mesh.geometry.getAttribute('color') as THREE.BufferAttribute
+    if (colorAttr) {
+      colorAttr.set(colorArray)
+      colorAttr.needsUpdate = true
+    } else {
+      particle.mesh.geometry.setAttribute('color', new THREE.Float32BufferAttribute(colorArray, 3))
+    }
+
+    this.worldRenderer.sceneOrigin.addAndTrack(particle.mesh)
+  }
+
+  private allocateParticle(): BreakParticle {
+    const geometry = new THREE.PlaneGeometry(1, 1)
+    const mesh = new THREE.Mesh(geometry, this.sharedMaterial!)
+    mesh.visible = false
+
+    const particle: BreakParticle = {
+      mesh,
+      active: false,
+      x: 0, y: 0, z: 0,
+      prevX: 0, prevY: 0, prevZ: 0,
+      xd: 0, yd: 0, zd: 0,
+      age: 0,
+      maxAge: 0,
+      onGround: false,
+      floorMap: [],
+      blockX: 0,
+      blockZ: 0,
+    }
+
+    this.particles.push(particle)
+    return particle
+  }
+
+  private findInactiveParticle(): BreakParticle | undefined {
+    for (let i = 0; i < this.particles.length; i++) {
+      const idx = (this.nextParticleIndex + i) % this.particles.length
+      if (!this.particles[idx].active) {
+        this.nextParticleIndex = (idx + 1) % this.particles.length
+        return this.particles[idx]
+      }
+    }
+    return undefined
+  }
+
+  private recycleOldest(): BreakParticle {
+    let oldest: BreakParticle = this.particles[0]
+    for (const p of this.particles) {
+      if (p.age > oldest.age) {
+        oldest = p
+      }
+    }
+    this.deactivateParticle(oldest)
+    return oldest
+  }
+
+  private deactivateParticle(p: BreakParticle): void {
+    if (!p.active) return
+    p.active = false
+    p.mesh.visible = false
+    this.worldRenderer.sceneOrigin.removeAndUntrack(p.mesh)
+  }
+
+  private getFloorY(particle: BreakParticle): number {
+    let dx = Math.floor(particle.x) - particle.blockX
+    let dz = Math.floor(particle.z) - particle.blockZ
+    dx = Math.max(-2, Math.min(2, dx))
+    dz = Math.max(-2, Math.min(2, dz))
+    return particle.floorMap[(dz + 2) * 5 + (dx + 2)]
+  }
+
+  private resolveBlockTexture(blockName: string): { u: number; v: number; su: number; sv: number } | null {
+    const resources = this.worldRenderer.resourcesManager.currentResources
+    if (!resources) return null
+
+    const atlasJson = resources.blocksAtlasJson
+    const textures = atlasJson.textures
+
+    if (textures[blockName]) return this.extractUV(textures[blockName], atlasJson)
+
+    for (const suffix of ['_side', '_top', '_front', '_0', '']) {
+      const key = blockName + suffix
+      if (textures[key]) return this.extractUV(textures[key], atlasJson)
+    }
+
+    for (const key of Object.keys(textures)) {
+      if (key.startsWith(blockName)) return this.extractUV(textures[key], atlasJson)
+    }
+
+    return null
+  }
+
+  private extractUV(
+    texInfo: { u: number; v: number; su?: number; sv?: number },
+    atlasJson: { suSv: number }
+  ): { u: number; v: number; su: number; sv: number } {
+    return {
+      u: texInfo.u,
+      v: texInfo.v,
+      su: texInfo.su ?? atlasJson.suSv,
+      sv: texInfo.sv ?? atlasJson.suSv,
+    }
+  }
+
+  private setGeometryUVs(geometry: THREE.PlaneGeometry, u: number, v: number, su: number, sv: number): void {
+    const uvAttr = geometry.getAttribute('uv') as THREE.BufferAttribute
+    // PlaneGeometry UV layout: (0,1) (1,1) (0,0) (1,0)
+    uvAttr.setXY(0, u, v)
+    uvAttr.setXY(1, u + su, v)
+    uvAttr.setXY(2, u, v + sv)
+    uvAttr.setXY(3, u + su, v + sv)
+    uvAttr.needsUpdate = true
+  }
+
+  private ensureMaterial(): void {
+    if (this.sharedMaterial) return
+    const atlasTexture = this.worldRenderer.material.map
+    if (!atlasTexture) return
+    this.sharedMaterial = new THREE.MeshBasicMaterial({
+      map: atlasTexture,
+      vertexColors: true,
+      transparent: true,
+      alphaTest: 0.1,
+    })
+  }
+}
+
+export const blockBreakParticlesManifest: RendererModuleManifest = {
+  id: 'blockBreakParticles',
+  controller: BlockBreakParticlesModule,
+  enabledDefault: true,
+  cannotBeDisabled: true,
+  requiresHeightmap: false,
+}

package/src/three/modules/index.ts

@@ -1,4 +1,5 @@
 //@ts-nocheck
+import { blockBreakParticlesManifest } from './blockBreakParticles'
 import { cameraBobbingManifest } from './cameraBobbing'
 import { rainManifest } from './rain'
 import { sciFiWorldRevealManifest } from './sciFiWorldReveal'
@@ -9,4 +10,5 @@ export const BUILTIN_MODULES = {
   futuristicReveal: sciFiWorldRevealManifest,
   rain: rainManifest,
   cameraBobbing: cameraBobbingManifest,
+  blockBreakParticles: blockBreakParticlesManifest,
 }