minecraft-renderer 0.1.44 → 0.1.45

package/package.json

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

package/src/mesher-shared/models.ts

@@ -6,6 +6,7 @@ import legacyJson from '../lib/preflatMap.json'
 import { BlockType } from '../playground/shared'
 import { World, BlockModelPartsResolved, WorldBlock as Block, WorldBlock, worldColumnKey } from './world'
 import { BlockElement, buildRotationMatrix, elemFaces, matmul3, matmulmat3, vecadd3, vecsub3 } from './modelsGeometryCommon'
+import { getSideShading, vertexLightFromAo } from './vertexShading'
 import { INVISIBLE_BLOCKS } from './worldConstants'
 import { MesherGeometryOutput, HighestBlockInfo } from './shared'
 import { collectBlockEntityMetadata } from './blockEntityMetadata'
@@ -51,6 +52,31 @@ function prepareTints(tints) {
 }
 
 const calculatedBlocksEntries = Object.entries(legacyJson.clientCalculatedBlocks)
+
+/**
+ * Block name + properties for model lookup. Only runs neighbor/preflat work when
+ * `world.preflat` (legacy); modern block-state worlds use `fromStateId` only.
+ */
+export function resolveBlockPropertiesForMeshing(
+  world: World | undefined,
+  cursor: Vec3,
+  blockProvider: WorldBlockProvider,
+  blockStateId: number,
+  PrismarineBlockCtor: { fromStateId: (id: number, biome: number) => Block }
+): { name: string, properties: Record<string, unknown> } {
+  if (world?.preflat) {
+    const block = world.getBlock(cursor, blockProvider, {})
+    if (block) {
+      let properties: Record<string, unknown> = { ...block.getProperties() }
+      const patch = preflatBlockCalculation(block, world, cursor)
+      if (patch) properties = { ...properties, ...patch }
+      return { name: block.name, properties }
+    }
+  }
+  const fromState = PrismarineBlockCtor.fromStateId(blockStateId, 1)
+  return { name: fromState.name, properties: fromState.getProperties() }
+}
+
 export function preflatBlockCalculation(block: Block, world: World, position: Vec3) {
   const type = calculatedBlocksEntries.find(([name, blocks]) => blocks.includes(block.name))?.[0]
   if (!type) return
@@ -398,13 +424,7 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
     // 10%
     const { smoothLighting, shadingTheme, cardinalLight } = world.config
     const faceLight = world.getLight(neighborPos, undefined, undefined, block.name)
-    const sideShading = (shadingTheme === 'high-contrast')
-      ? (0.8 + 0.5 * Math.max(0, 0.66 * dir[0] + 0.66 * dir[1] + 0.33 * dir[2])) // old directional light behavior
-      : (
-          cardinalLight === 'nether'
-            ? (0.5 + Math.abs(0.1 * dir[0] + 0.4 * dir[1] + 0.3 * dir[2]))
-            : (0.75 + 0.25 * dir[1] + 0.05 * (Math.abs(dir[2]) - 3 * Math.abs(dir[0])))
-        )
+    const sideShading = getSideShading(dir, shadingTheme, cardinalLight)
     const baseLight = sideShading * faceLight / 15
     for (const pos of corners) {
       let vertex = [
@@ -478,10 +498,7 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
         // TODO: correctly interpolate ao light based on pos (evaluate once for each corner of the block)
 
         const ao = (side1Block && side2Block) ? 0 : (3 - (side1Block + side2Block + cornerBlock))
-        const ao_bias = (shadingTheme === 'high-contrast') ? 0.25 : 0.4
-        const ao_scale = (shadingTheme === 'high-contrast') ? 0.25 : 0.2
-        // todo light should go upper on lower blocks
-        light = sideShading * (ao * ao_scale + ao_bias) * (cornerLightResult / 15)
+        light = vertexLightFromAo(ao, cornerLightResult, sideShading, shadingTheme)
         aos.push(ao)
 
         // Log AO and light for this corner (corner index is aos.length - 1)

package/src/mesher-shared/vertexShading.ts

@@ -0,0 +1,35 @@
+//@ts-nocheck
+import type { MesherConfig } from './shared'
+
+export type FaceDirection = readonly [number, number, number]
+
+/** Directional face darkening (matches legacy `renderElement` in models.ts). */
+export function getSideShading(
+  dir: FaceDirection,
+  shadingTheme: MesherConfig['shadingTheme'],
+  cardinalLight: MesherConfig['cardinalLight']
+): number {
+  if (shadingTheme === 'high-contrast') {
+    return 0.8 + 0.5 * Math.max(0, 0.66 * dir[0] + 0.66 * dir[1] + 0.33 * dir[2])
+  }
+  if (cardinalLight === 'nether') {
+    return 0.5 + Math.abs(0.1 * dir[0] + 0.4 * dir[1] + 0.3 * dir[2])
+  }
+  return 0.75 + 0.25 * dir[1] + 0.05 * (Math.abs(dir[2]) - 3 * Math.abs(dir[0]))
+}
+
+/** Per-vertex brightness from AO (0–3) and corner light (0–15). */
+export function vertexLightFromAo(
+  ao: number,
+  cornerLight15: number,
+  sideShading: number,
+  shadingTheme: MesherConfig['shadingTheme']
+): number {
+  const lightNorm = cornerLight15 / 15
+  if (shadingTheme === 'high-contrast') {
+    return sideShading * ((ao + 1) / 4) * lightNorm
+  }
+  const aoBias = 0.4
+  const aoScale = 0.2
+  return sideShading * (ao * aoScale + aoBias) * lightNorm
+}

package/src/three/modules/rain.ts

@@ -58,7 +58,9 @@ export class RainModule implements RendererModuleController {
   }
 
   render?: (deltaTime: number) => void = (deltaTime) => {
-    if (!this.enabled || !this.instancedMesh) return
+    if (!this.enabled || !this.instancedMesh || !this.material) return
+
+    this.syncMaterialToSceneFog()
 
     const cameraPos = this.worldRenderer.getCameraPosition()
     this.instancedMesh.position.set(0, 0, 0)
@@ -135,16 +137,32 @@ export class RainModule implements RendererModuleController {
     this.particles = []
   }
 
+  /** Match scene fog so rain fades with distance instead of a flat blue sheet. */
+  private syncMaterialToSceneFog(): 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
+  }
+
   private createRain(): void {
     this.geometry = new THREE.BoxGeometry(0.03, 0.3, 0.03)
     this.material = new THREE.MeshBasicMaterial({
-      color: 0x44_66_99,
+      color: 0xcc_dd_ee,
       transparent: true,
-      opacity: 0.6,
+      opacity: 0.35,
+      depthWrite: false,
+      fog: true,
     })
 
     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()

package/src/wasm-mesher/bridge/render-from-wasm.ts

@@ -13,6 +13,8 @@ import { elemFaces, buildRotationMatrix, matmul3, matmulmat3, vecadd3, vecsub3 }
 import type { ExportedWorldGeometry, ExportedSection } from '../../three/worldGeometryExport'
 import type { MesherGeometryOutput } from '../../mesher-shared/shared'
 import type { World } from '../../mesher-shared/world'
+import { resolveBlockPropertiesForMeshing } from '../../mesher-shared/models'
+import { getSideShading, vertexLightFromAo } from '../../mesher-shared/vertexShading'
 
 // Handle both default and named export
 const worldBlockProvider = (worldBlockProviderModule as any).default || worldBlockProviderModule
@@ -134,6 +136,18 @@ export function extractColumnHeightmap(
   return out
 }
 
+function computeMesherVertexLight(
+  world: World | undefined,
+  ao: number,
+  cornerLight15: number,
+  faceDir: [number, number, number]
+): number {
+  const shadingTheme = world?.config.shadingTheme ?? 'high-contrast'
+  const cardinalLight = world?.config.cardinalLight ?? 'default'
+  const sideShading = getSideShading(faceDir, shadingTheme, cardinalLight)
+  return vertexLightFromAo(ao, cornerLight15, sideShading, shadingTheme)
+}
+
 /**
  * Get or create cached block model with precomputed matrices
  */
@@ -141,10 +155,32 @@ function getCachedBlockModel(
   blockStateId: number,
   version: string,
   blockProvider: WorldBlockProvider,
-  PrismarineBlock: any
+  PrismarineBlock: any,
+  world?: World,
+  blockPos?: { x: number, y: number, z: number }
 ): CachedBlockModel | null {
-  // Use a module-level cache
-  const cacheKey = `${version}:${blockStateId}`
+  const usePreflat = !!(world?.preflat && blockPos)
+  let blockName: string
+  let blockProps: Record<string, unknown>
+  if (usePreflat) {
+    const resolved = resolveBlockPropertiesForMeshing(
+      world,
+      new Vec3(blockPos!.x, blockPos!.y, blockPos!.z),
+      blockProvider,
+      blockStateId,
+      PrismarineBlock
+    )
+    blockName = resolved.name
+    blockProps = resolved.properties
+  } else {
+    const blockObj = PrismarineBlock.fromStateId(blockStateId, 1)
+    blockName = blockObj.name
+    blockProps = blockObj.getProperties()
+  }
+
+  const cacheKey = usePreflat
+    ? `${version}:${blockStateId}:${blockName}:${JSON.stringify(blockProps)}`
+    : `${version}:${blockStateId}`
   if (!(globalThis as any).__wasmBlockModelCache) {
     (globalThis as any).__wasmBlockModelCache = new Map()
   }
@@ -156,11 +192,13 @@ function getCachedBlockModel(
 
   try {
     const blockObj = PrismarineBlock.fromStateId(blockStateId, 1)
-    const blockName = blockObj.name
-    const blockProps = blockObj.getProperties()
+    if (!usePreflat) {
+      blockName = blockObj.name
+      blockProps = blockObj.getProperties()
+    }
 
     const models = blockProvider.getAllResolvedModels0_1(
-      { name: blockName, properties: blockProps },
+      { name: blockName, properties: blockProps as Record<string, string | number | boolean> },
       false
     )
 
@@ -505,7 +543,14 @@ export function renderWasmOutputToGeometry(
       }
     }
 
-    const cachedModel = getCachedBlockModel(blockStateId, version, blockProvider, PrismarineBlock)
+    const cachedModel = getCachedBlockModel(
+      blockStateId,
+      version,
+      blockProvider,
+      PrismarineBlock,
+      world,
+      { x: bx, y: by, z: bz }
+    )
     if (!cachedModel) continue
 
     if (false) {
@@ -654,10 +699,9 @@ export function renderWasmOutputToGeometry(
             // But WASM light calculation seems to return 0.0, so we need to handle that
             // In the test case, TypeScript gets baseLight = 1.0 (full brightness)
             // So we should use 1.0 as the base light value when WASM returns 0
-            const baseLight = lightValues[cornerIdx]
-            const cornerLightResult = baseLight * 15
-
-            const light = (ao + 1) / 4 * (cornerLightResult / 15)
+            const cornerLight15 = (lightValues[cornerIdx] ?? 1) * 15
+            const faceDir = transformedDir as [number, number, number]
+            const light = computeMesherVertexLight(world, ao, cornerLight15, faceDir)
 
             colors.push(tint[0] * light, tint[1] * light, tint[2] * light)
 
@@ -907,7 +951,8 @@ export function renderWasmOutputToGeometry(
             }
 
             if (doAO) {
-              light = (ao + 1) / 4 * (cornerLightResult / 15)
+              const faceDir = transformedDirI as [number, number, number]
+              light = computeMesherVertexLight(world, ao, cornerLightResult, faceDir)
             }
 
             colors.push(tint[0] * light!, tint[1] * light!, tint[2] * light!)