minecraft-renderer 0.1.72 → 0.1.74

package/src/three/graphicsBackendBase.ts

@@ -69,7 +69,7 @@ export const getBackendMethods = (worldRenderer: WorldRendererThree): any => {
     // New method for updating skybox
     setSkyboxImage: worldRenderer.skyboxRenderer.setSkyboxImage.bind(worldRenderer.skyboxRenderer),
     // Rain methods
-    setRain: (newState: boolean) => worldRenderer.toggleModule('rain', newState),
+    setRain: worldRenderer.setRain.bind(worldRenderer),
     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)
@@ -145,6 +145,10 @@ export const createGraphicsBackendBase = () => {
   let frameTimingCollector: FrameTimingCollector | null = null
 
   const init = (initOptionsArg: GraphicsInitOptions, mainData?: ThreeRendererMainData) => {
+    if (initOptionsArg.hello) {
+      console.log('Thanks for using minecraft-renderer project: one of the most performant Minecraft world renderers for the web!')
+    }
+
     if (isWebWorker) {
       initOptions = restoreTransferred(initOptionsArg, initOptionsRestorers, globalThis as unknown as Worker)
     } else {
@@ -166,8 +170,8 @@ export const createGraphicsBackendBase = () => {
       worldRenderer.destroy()
       worldRenderer = null
       frameTimingCollector = null
-      ;(globalThis as any).world = undefined
-      ;(globalThis as any).frameTimingCollector = undefined
+        ; (globalThis as any).world = undefined
+        ; (globalThis as any).frameTimingCollector = undefined
     }
 
     if (menuBackgroundRenderer) {
@@ -202,8 +206,8 @@ export const createGraphicsBackendBase = () => {
       worldRenderer.destroy()
       worldRenderer = null
       frameTimingCollector = null
-      ;(globalThis as any).world = undefined
-      ;(globalThis as any).frameTimingCollector = undefined
+        ; (globalThis as any).world = undefined
+        ; (globalThis as any).frameTimingCollector = undefined
     }
 
     const displayOptionsRestorers = [ResourcesManager, WorldViewWorker]

package/src/three/itemMesh.ts

@@ -40,7 +40,7 @@ export function create3DItemMesh (
     throw new Error(`Invalid canvas dimensions: ${canvas.width}x${canvas.height}`)
   }
 
-  const ctx = canvas.getContext('2d')!
+  const ctx = canvas.getContext('2d') as CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D
   const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height)
   const { data } = imageData
 
@@ -257,7 +257,7 @@ export interface ItemMeshResult {
  * Extracts item texture region to a canvas
  */
 export function extractItemTextureToCanvas (
-  sourceTexture: THREE.Texture,
+  sourceTexture: THREE.Texture<HTMLImageElement | ImageBitmap>,
   textureInfo: ItemTextureInfo
 ): ItemTextureCanvas {
   const { u, v, sizeX, sizeY } = textureInfo
@@ -333,7 +333,10 @@ export function createItemMesh (
   if (use3D) {
     // Try to create 3D mesh
     try {
-      const canvas = extractItemTextureToCanvas(sourceTexture, textureInfo)
+      const canvas = extractItemTextureToCanvas(
+        sourceTexture as THREE.Texture<HTMLImageElement | ImageBitmap>,
+        textureInfo
+      )
       const { geometry } = create3DItemMesh(canvas, { depth })
 
       // Create texture from canvas for the 3D mesh

package/src/three/legacySectionCull.ts

@@ -0,0 +1,85 @@
+//@ts-nocheck
+import * as THREE from 'three'
+import type { RenderOrigin } from './shaders/legacyBlockShader'
+
+/** Half-extent of a section mesh AABB in section-local space. */
+export const LEGACY_SECTION_HALF_EXTENT = 8
+
+/** Small pad on camera-relative section AABBs for frustum tests. */
+const CULL_BOX_EPSILON = 0.01
+
+/**
+ * Set a legacy section mesh world translation once at build time.
+ * Position proxy is not used — camera-relative math lives in the shader.
+ */
+export function setupLegacySectionMatrix (
+  mesh: THREE.Mesh,
+  sx: number,
+  sy: number,
+  sz: number,
+  renderOrigin: RenderOrigin,
+): void {
+  mesh.matrix.makeTranslation(sx - renderOrigin.x, sy - renderOrigin.y, sz - renderOrigin.z)
+  mesh.matrixWorldNeedsUpdate = true
+  mesh.frustumCulled = false
+}
+
+export function sectionIntersectsFrustum (
+  sectionWorldX: number,
+  sectionWorldY: number,
+  sectionWorldZ: number,
+  cameraWorldX: number,
+  cameraWorldY: number,
+  cameraWorldZ: number,
+  frustum: THREE.Frustum,
+  box: THREE.Box3,
+  boxMin: THREE.Vector3,
+  boxMax: THREE.Vector3,
+): { visible: boolean, distSq: number } {
+  const dx = sectionWorldX - cameraWorldX
+  const dy = sectionWorldY - cameraWorldY
+  const dz = sectionWorldZ - cameraWorldZ
+
+  const half = LEGACY_SECTION_HALF_EXTENT + CULL_BOX_EPSILON
+  boxMin.set(dx - half, dy - half, dz - half)
+  boxMax.set(dx + half, dy + half, dz + half)
+  box.set(boxMin, boxMax)
+
+  return {
+    visible: frustum.intersectsBox(box),
+    distSq: dx * dx + dy * dy + dz * dz,
+  }
+}
+
+/**
+ * Per-frame frustum cull + back-to-front renderOrder for one legacy section.
+ * Used for pooled per-section meshes (reveal defer + invariant fallback).
+ */
+export function updateLegacySectionCullState (
+  mesh: THREE.Mesh,
+  sectionWorldX: number,
+  sectionWorldY: number,
+  sectionWorldZ: number,
+  cameraWorldX: number,
+  cameraWorldY: number,
+  cameraWorldZ: number,
+  frustum: THREE.Frustum,
+  box: THREE.Box3,
+  boxMin: THREE.Vector3,
+  boxMax: THREE.Vector3,
+): void {
+  const { visible, distSq } = sectionIntersectsFrustum(
+    sectionWorldX,
+    sectionWorldY,
+    sectionWorldZ,
+    cameraWorldX,
+    cameraWorldY,
+    cameraWorldZ,
+    frustum,
+    box,
+    boxMin,
+    boxMax,
+  )
+  mesh.visible = visible
+  mesh.renderOrder = -distSq
+}

package/src/three/modules/rain.ts

@@ -17,11 +17,6 @@ const FALL_SPEED_MAX = 24
 const HORIZONTAL_DRIFT = 1.2
 const RESPAWN_BELOW = -5
 
-const moduleOptions = {
-  particleCount: 2000,
-  speedFactor: 1,
-}
-
 export class RainModule implements RendererModuleController {
   private instancedMesh?: THREE.InstancedMesh
   private geometry?: THREE.BoxGeometry
@@ -32,8 +27,14 @@ export class RainModule implements RendererModuleController {
   private readonly tempPosition = new THREE.Vector3()
   private readonly tempQuaternion = new THREE.Quaternion()
   private readonly tempScale = new THREE.Vector3()
+  private readonly configUnsubs: Array<() => void> = []
 
-  constructor(private readonly worldRenderer: WorldRendererThree) { }
+  constructor(private readonly worldRenderer: WorldRendererThree) {
+    this.configUnsubs.push(
+      this.worldRenderer.onReactiveConfigUpdated('rainColor', () => this.syncRainAppearance()),
+      this.worldRenderer.onReactiveConfigUpdated('rainOpacity', () => this.syncRainAppearance()),
+    )
+  }
 
   enable(): void {
     if (this.enabled) return
@@ -42,6 +43,7 @@ export class RainModule implements RendererModuleController {
       this.createRain()
     } else {
       this.instancedMesh.visible = true
+      this.syncRainAppearance()
     }
   }
 
@@ -60,8 +62,6 @@ export class RainModule implements RendererModuleController {
   render?: (deltaTime: number) => void = (deltaTime) => {
     if (!this.enabled || !this.instancedMesh || !this.material) return
 
-    this.syncMaterialToSceneFog()
-
     const cameraPos = this.worldRenderer.getCameraPosition()
     this.instancedMesh.position.set(0, 0, 0)
 
@@ -126,6 +126,9 @@ export class RainModule implements RendererModuleController {
   }
 
   dispose(): void {
+    for (const unsub of this.configUnsubs) unsub()
+    this.configUnsubs.length = 0
+
     if (this.instancedMesh) {
       this.worldRenderer.scene.remove(this.instancedMesh)
     }
@@ -137,33 +140,31 @@ export class RainModule implements RendererModuleController {
     this.particles = []
   }
 
-  /** Match scene fog so rain fades with distance instead of a flat blue sheet. */
-  private syncMaterialToSceneFog(): void {
+  private syncRainAppearance(): void {
     if (!this.material) return
-    const fog = this.worldRenderer.scene.fog
-    if (fog instanceof THREE.Fog || fog instanceof THREE.FogExp2) {
-      this.material.color.copy(fog.color)
-    } else {
-      this.material.color.set(0xcc_dd_ee)
-    }
-    this.material.fog = true
+
+    const { rainColor, rainOpacity } = this.worldRenderer.worldRendererConfig
+    this.material.color.set(rainColor)
+    this.material.opacity = Math.max(0, Math.min(1, rainOpacity))
+    this.material.needsUpdate = true
   }
 
   private createRain(): void {
+    const { rainColor, rainOpacity } = this.worldRenderer.worldRendererConfig
+
     this.geometry = new THREE.BoxGeometry(0.03, 0.3, 0.03)
     this.material = new THREE.MeshBasicMaterial({
-      color: 0xcc_dd_ee,
+      color: rainColor,
       transparent: true,
-      opacity: 0.35,
+      opacity: Math.max(0, Math.min(1, rainOpacity)),
       // Must write depth so log-depth blocks occlude rain correctly (see cubeBlockShader).
       depthWrite: true,
-      fog: true,
+      fog: false,
     })
 
     this.instancedMesh = new THREE.InstancedMesh(this.geometry, this.material, PARTICLE_COUNT)
     this.instancedMesh.name = 'rain-particles'
     this.instancedMesh.frustumCulled = false
-    this.syncMaterialToSceneFog()
 
     const dummy = new THREE.Matrix4()
     const position = new THREE.Vector3()