minecraft-renderer 0.1.72 → 0.1.73

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.72",
+  "version": "0.1.73",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",
@@ -55,7 +55,7 @@
     "skinview3d": "^3.4.1",
     "stats-gl": "^1.0.5",
     "stats.js": "^0.17.0",
-    "three": "0.154.0",
+    "three": "0.184.0",
     "three-stdlib": "^2.36.1",
     "type-fest": "^5.3.0",
     "typed-emitter": "^2.1.0",
@@ -70,7 +70,7 @@
     "@types/lodash": "^4.17.21",
     "@types/react": "^19.2.7",
     "@types/stats.js": "^0.17.1",
-    "@types/three": "0.154.0",
+    "@types/three": "0.184.0",
     "@zardoy/react-util": "^0.2.7",
     "@zardoy/tsconfig": "^1.5.1",
     "contro-max": "*",

package/src/graphicsBackend/rendererDefaultOptions.ts

@@ -63,7 +63,6 @@ export const RENDERER_DEFAULT_OPTIONS = {
   rendererPerfDebugOverlay: false as boolean,
   disableBlockEntityTextures: false as boolean,
   rendererMesher: 'wasm' as RendererMesherPipeline,
-  rendererShaderCubeBlocks: false as boolean,
   rendererShaderCubeDebugMode: 'off' as RendererShaderCubeDebugMode,
   showChunkBorders: false as boolean,
   renderEntities: true as boolean,
@@ -110,6 +109,7 @@ export function migrateRendererOptions(saved: Record<string, unknown>): void {
   }
   delete saved.wasmExperimentalMesher
   delete saved.rendererWasmMesher
+  delete saved.rendererShaderCubeBlocks
 
   if (saved.menuBackgroundMode === 'futuristic') {
     saved.menuBackgroundMode = 'v2'
@@ -196,11 +196,6 @@ export const RENDERER_OPTIONS_META: Partial<Record<RendererDefaultOptionKey, Ren
     tooltip: 'Browser technology for processing world geometry before render. WASM is the fastest; if you see a dead tab icon, reloads, or other errors, switch to Legacy JS.',
     requiresChunksReload: true,
   },
-  rendererShaderCubeBlocks: {
-    text: '(UNSTABLE) Instanced shader cubes',
-    tooltip: 'Render full blocks through the global GPU instanced path. Requires WASM mesher and WebGL2.',
-    requiresChunksReload: true,
-  },
   rendererShaderCubeDebugMode: {
     text: 'Shader cube debug',
     tooltip: 'Instanced cube path visualization (requires shader cubes enabled).',
@@ -341,7 +336,7 @@ export const RENDERER_RENDER_GUI_SECTIONS: ReadonlyArray<{
     },
     {
       title: 'Mesher',
-      keys: ['rendererMesher', 'rendererShaderCubeBlocks']
+      keys: ['rendererMesher']
     },
     {
       title: 'Renderer debug',

package/src/graphicsBackend/rendererOptionsSync.ts

@@ -163,7 +163,7 @@ export function applyRendererOptions(
   cfg.fetchPlayerSkins = o.loadPlayerSkins
   cfg.highlightBlockColor = o.highlightBlockColor
   cfg.wasmMesher = wasmActive
-  cfg.shaderCubeBlocks = o.rendererShaderCubeBlocks && wasmActive
+  cfg.shaderCubeBlocks = wasmActive
   cfg.disableMesherConversionCache = !!ctx.isSafari
 
   setSkinsConfig({ apiEnabled: o.loadPlayerSkins })

package/src/lib/bakeLegacyLight.ts

@@ -0,0 +1,17 @@
+//@ts-nocheck
+/** Bake tint×AO colors with sky/block channels for static export (no live u_skyLevel uniform). */
+export function bakeLegacyVertexColors (
+  colors: ArrayLike<number>,
+  skyLights: ArrayLike<number>,
+  blockLights: ArrayLike<number>,
+  skyLevel: number,
+): number[] {
+  const vertCount = colors.length / 3
+  const out: number[] = []
+  for (let v = 0; v < vertCount; v++) {
+    const L = Math.max(blockLights[v] ?? 0, Math.min(skyLights[v] ?? 1, skyLevel))
+    const i = v * 3
+    out.push(colors[i]! * L, colors[i + 1]! * L, colors[i + 2]! * L)
+  }
+  return out
+}

package/src/lib/blockEntityLightRegistry.test.ts

@@ -0,0 +1,18 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import * as THREE from 'three'
+import { blockEntityBrightness } from './blockEntityLighting'
+import { BlockEntityLightRegistry } from './blockEntityLightRegistry'
+
+describe('BlockEntityLightRegistry', () => {
+  it('refreshes overlay brightness when sky level changes', () => {
+    const registry = new BlockEntityLightRegistry()
+    const material = new THREE.MeshBasicMaterial()
+    registry.register({ material, blockLightNorm: 0, skyLightNorm: 1 })
+    const nightSky = 4 / 15
+    registry.setSkyLevel(nightSky)
+    expect(material.color.r).toBeCloseTo(blockEntityBrightness(0, 1, nightSky), 5)
+    registry.setSkyLevel(1)
+    expect(material.color.r).toBe(1)
+  })
+})

package/src/lib/blockEntityLightRegistry.ts

@@ -0,0 +1,75 @@
+//@ts-nocheck
+import * as THREE from 'three'
+import {
+  blockEntityBrightness,
+  DEFAULT_LIGHTMAP_PARAMS,
+  type BlockLightmapParams,
+} from './blockEntityLighting'
+
+export type BlockEntityOverlayLight = {
+  material: THREE.MeshBasicMaterial
+  blockLightNorm: number
+  skyLightNorm: number
+}
+
+export class BlockEntityLightRegistry {
+  private readonly entries = new Set<BlockEntityOverlayLight>()
+  private skyLevel = 1
+  private lightmapParams: BlockLightmapParams = { ...DEFAULT_LIGHTMAP_PARAMS }
+
+  register (entry: BlockEntityOverlayLight): void {
+    this.entries.add(entry)
+    this.applyBrightness(entry)
+  }
+
+  unregister (material: THREE.Material): void {
+    for (const entry of this.entries) {
+      if (entry.material === material) {
+        this.entries.delete(entry)
+        break
+      }
+    }
+  }
+
+  setSkyLevel (value: number): void {
+    this.skyLevel = value
+    this.refreshAll()
+  }
+
+  setLightmapParams (params: BlockLightmapParams): void {
+    this.lightmapParams = { ...this.lightmapParams, ...params }
+    this.refreshAll()
+  }
+
+  getSkyLevel (): number {
+    return this.skyLevel
+  }
+
+  private refreshAll (): void {
+    for (const entry of this.entries) {
+      this.applyBrightness(entry)
+    }
+  }
+
+  private applyBrightness (entry: BlockEntityOverlayLight): void {
+    const brightness = blockEntityBrightness(
+      entry.blockLightNorm,
+      entry.skyLightNorm,
+      this.skyLevel,
+      this.lightmapParams,
+    )
+    entry.material.color.setScalar(brightness)
+  }
+}
+
+export function tintBannerMaterial (
+  material: THREE.MeshBasicMaterial,
+  blockLightNorm: number,
+  skyLightNorm: number,
+  skyLevel: number,
+  lightmapParams: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS,
+): number {
+  const brightness = blockEntityBrightness(blockLightNorm, skyLightNorm, skyLevel, lightmapParams)
+  material.color.setScalar(brightness)
+  return brightness
+}

package/src/lib/blockEntityLighting.test.ts

@@ -0,0 +1,30 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import {
+  applyLightmap,
+  blockEntityBrightness,
+  combinedBlockLight,
+  DEFAULT_LIGHTMAP_PARAMS,
+} from './blockEntityLighting'
+
+describe('blockEntityLighting', () => {
+  it('applyLightmap(1) === 1 for default params', () => {
+    expect(applyLightmap(1, DEFAULT_LIGHTMAP_PARAMS)).toBe(1)
+  })
+
+  it('combinedBlockLight caps sky by skyLevel', () => {
+    expect(combinedBlockLight(0, 1, 4 / 15)).toBeCloseTo(4 / 15, 5)
+    expect(combinedBlockLight(0.5, 1, 4 / 15)).toBeCloseTo(0.5, 5)
+  })
+
+  it('night outdoor blockEntityBrightness matches cap + lightmap', () => {
+    const skyLevel = 4 / 15
+    const L = combinedBlockLight(0, 1, skyLevel)
+    expect(blockEntityBrightness(0, 1, skyLevel)).toBeCloseTo(applyLightmap(L), 5)
+  })
+
+  it('linear curve matches raw L at minBrightness 0', () => {
+    const p = { curve: 0, minBrightness: 0, gamma: 1 }
+    expect(applyLightmap(0.5, p)).toBeCloseTo(0.5, 5)
+  })
+})

package/src/lib/blockEntityLighting.ts

@@ -0,0 +1,53 @@
+//@ts-nocheck
+/**
+ * Shared block lighting math — keep in sync with APPLY_LIGHTMAP_GLSL in shaders.
+ */
+
+export type BlockLightmapParams = {
+  curve?: number
+  minBrightness?: number
+  gamma?: number
+}
+
+export const DEFAULT_LIGHTMAP_PARAMS: Required<BlockLightmapParams> = {
+  curve: 0,
+  minBrightness: 0.12,
+  gamma: 1,
+}
+
+/** GLSL body for applyLightmap — requires u_lightCurve, u_minBrightness, u_lightGamma uniforms. */
+export const APPLY_LIGHTMAP_GLSL = /* glsl */ `
+float applyLightmap(float L) {
+    float curved = L / (4.0 - 3.0 * L);
+    float shaped = mix(L, curved, u_lightCurve);
+    shaped = mix(u_minBrightness, 1.0, shaped);
+    return clamp(pow(shaped, u_lightGamma), 0.0, 1.0);
+}
+`
+
+export function applyLightmap (L: number, params: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS): number {
+  const curve = params.curve ?? DEFAULT_LIGHTMAP_PARAMS.curve
+  const minBrightness = params.minBrightness ?? DEFAULT_LIGHTMAP_PARAMS.minBrightness
+  const gamma = params.gamma ?? DEFAULT_LIGHTMAP_PARAMS.gamma
+
+  const curved = L / (4 - 3 * L)
+  let shaped = L * (1 - curve) + curved * curve
+  shaped = minBrightness + shaped * (1 - minBrightness)
+  return Math.min(1, Math.max(0, shaped ** gamma))
+}
+
+/** Same cap as block shaders: max(block, min(sky, skyLevel)). */
+export function combinedBlockLight (block: number, sky: number, skyLevel: number): number {
+  return Math.max(block, Math.min(sky, skyLevel))
+}
+
+/** 0..1 brightness for MeshBasicMaterial.color.setScalar on block-entity overlays. */
+export function blockEntityBrightness (
+  blockNorm: number,
+  skyNorm: number,
+  skyLevel: number,
+  lightmapParams: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS,
+): number {
+  const L = combinedBlockLight(blockNorm, skyNorm, skyLevel)
+  return applyLightmap(L, lightmapParams)
+}

package/src/lib/worldrendererCommon.ts

@@ -33,6 +33,7 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
   worldReadyResolvers = Promise.withResolvers<void>()
   worldReadyPromise = this.worldReadyResolvers.promise
   timeOfTheDay = 0
+  lastMesherSkyLight = 15
   worldSizeParams = { minY: 0, worldHeight: 256 }
   reactiveDebugParams = proxy({
     stopRendering: false,
@@ -695,6 +696,9 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
 
   timeUpdated?(newTime: number): void
 
+  /** Called when day-cycle sky-light bucket changes; Three.js overrides to remesh. */
+  protected onDayCycleSkyLightChanged?(_skyLight: number): void
+
   biomeUpdated?(biome: any): void
 
   biomeReset?(): void
@@ -1064,16 +1068,20 @@ export abstract class WorldRendererCommon<WorkerSend = any, WorkerReceive = any>
     }, signal)
 
     bindAbortableListener(worldEmitter, 'time', (timeOfDay) => {
-      if (!this.worldRendererConfig.dayCycle) return
+      if (!this.worldRendererConfig.dayCycle) {
+        return
+      }
       this.timeUpdated?.(timeOfDay)
 
       this.timeOfTheDay = timeOfDay
 
-      // if (this.worldRendererConfig.skyLight === skyLight) return
-      // this.worldRendererConfig.skyLight = skyLight
-      // if (this instanceof WorldRendererThree) {
-      //   (this).rerenderAllChunks?.()
-      // }
+      const skyLight = (timeOfDay < 0 || timeOfDay > 24_000) ? 15 : calculateSkyLightSimple(timeOfDay)
+      if (this.lastMesherSkyLight === skyLight) return
+      this.lastMesherSkyLight = skyLight
+      if (this.workers.length > 0) {
+        this.sendWorkers({ config: { skyLight } } as WorkerSend)
+      }
+      this.onDayCycleSkyLightChanged?.(skyLight)
     }, signal)
 
     bindAbortableListener(worldEmitter, 'biomeUpdate', ({ biome }) => {

package/src/mesher-shared/blockEntityMetadata.test.ts

@@ -0,0 +1,33 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import { Vec3 } from 'vec3'
+import { collectBlockEntityMetadata } from './blockEntityMetadata'
+
+describe('collectBlockEntityMetadata', () => {
+  it('stores channel light norms on banner metadata', () => {
+    const target = { signs: {}, heads: {}, banners: {} }
+    const block = {
+      name: 'pink_banner',
+      getProperties: () => ({ rotation: 0 }),
+    }
+    collectBlockEntityMetadata(
+      block,
+      1, 2, 3,
+      target,
+      {},
+      {
+        getChannelLightNorm: (pos: Vec3) => {
+          expect(pos).toBeInstanceOf(Vec3)
+          return { block: 0.4, sky: 0.8 }
+        },
+      },
+    )
+    expect(target.banners['1,2,3']).toEqual({
+      isWall: false,
+      blockName: 'pink_banner',
+      rotation: 0,
+      blockLightNorm: 0.4,
+      skyLightNorm: 0.8,
+    })
+  })
+})

package/src/mesher-shared/blockEntityMetadata.ts

@@ -1,7 +1,15 @@
 //@ts-nocheck
+import { Vec3 } from 'vec3'
+
 export interface SignMeta { isWall: boolean; isHanging: boolean; rotation: number }
 export interface HeadMeta { isWall: boolean; rotation: number }
-export interface BannerMeta { isWall: boolean; blockName: string; rotation: number }
+export interface BannerMeta {
+  isWall: boolean
+  blockName: string
+  rotation: number
+  blockLightNorm: number
+  skyLightNorm: number
+}
 
 export interface BlockEntityMetadataTarget {
   signs: Record<string, SignMeta>
@@ -15,11 +23,16 @@ export interface BlockEntityMetadataOptions {
 
 type BlockLike = { name: string; getProperties(): any }
 
+type LightSampler = {
+  getChannelLightNorm(pos: Vec3): { block: number, sky: number }
+}
+
 export function collectBlockEntityMetadata(
   block: BlockLike,
   x: number, y: number, z: number,
   target: BlockEntityMetadataTarget,
-  options: BlockEntityMetadataOptions
+  options: BlockEntityMetadataOptions,
+  world?: LightSampler,
 ): void {
   if ((block.name.includes('_sign') || block.name === 'sign') && !options.disableBlockEntityTextures) {
     const key = `${x},${y},${z}`
@@ -61,10 +74,13 @@ export function collectBlockEntityMetadata(
       'east': 3
     }
     const isWall = block.name.endsWith('_wall_banner')
+    const light = world?.getChannelLightNorm(new Vec3(x, y, z)) ?? { block: 0, sky: 1 }
     target.banners[key] = {
       isWall,
       blockName: block.name, // Pass block name for base color extraction
-      rotation: isWall ? facingRotationMap[props.facing] : (props.rotation === undefined ? 0 : +props.rotation)
+      rotation: isWall ? facingRotationMap[props.facing] : (props.rotation === undefined ? 0 : +props.rotation),
+      blockLightNorm: light.block,
+      skyLightNorm: light.sky,
     }
   }
 }

package/src/mesher-shared/exportedGeometryTypes.ts

@@ -8,6 +8,17 @@ export interface ExportedSection {
     positions: number[]
     normals: number[]
     colors: number[]
+    skyLights: number[]
+    blockLights: number[]
+    uvs: number[]
+    indices: number[]
+  }
+  blendGeometry?: {
+    positions: number[]
+    normals: number[]
+    colors: number[]
+    skyLights: number[]
+    blockLights: number[]
     uvs: number[]
     indices: number[]
   }