minecraft-renderer 0.1.82 → 0.1.84

package/package.json

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

package/src/three/threeJsUtils.ts

@@ -9,6 +9,12 @@ export const disposeObject = (obj: THREE.Object3D, cleanTextures = false) => {
     obj.geometry?.dispose?.()
     obj.material?.dispose?.()
   }
+  if (obj instanceof THREE.SkinnedMesh) {
+    // SkinnedMesh skeletons are not scene-graph children, so the recursion below never reaches them.
+    // skeleton.dispose() frees the lazily-created bone DataTexture (Skeleton.computeBoneTexture),
+    // which otherwise leaks +1 GPU texture per entity on every F3+A reload (issue #56).
+    obj.skeleton?.dispose?.()
+  }
   if (obj.children) {
     // eslint-disable-next-line unicorn/no-array-for-each
     obj.children.forEach(child => disposeObject(child, cleanTextures))

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

@@ -746,8 +746,8 @@ export function renderWasmOutputToGeometry(
       }
 
       // Mirror JS mesher: doAO = model.ao ?? block.boundingBox !== 'empty'.
-      // When false, faces are emitted full-bright without AO/light sampling and without
-      // triangle-flip reordering (matches JS `light = 1` and standard winding).
+      // When false, faces skip AO but still use flat block/sky light from the
+      // neighbor cell (see models.ts baseChannels), not full-bright defaults.
       const doAO = (model as any).ao ?? cachedModel.boundingBox !== 'empty'
 
       for (const element of model.elements ?? []) {
@@ -828,6 +828,11 @@ export function renderWasmOutputToGeometry(
 
           const tint = getTint(matchingEFace, cachedModel.blockName, cachedModel.blockProps, biome, world)
 
+          const useModelLighting = (!cachedModel.isCube || globalMatrix != null) && world
+          const baseChannels = useModelLighting
+            ? world.getChannelLightNorm(new Vec3(bx, by, bz).offset(transformedDirI[0], transformedDirI[1], transformedDirI[2]))
+            : null
+
           const baseIndex = tgtPos.length / 3
           const computedAoValues = [3, 3, 3, 3]
           for (let cornerIdx = 0; cornerIdx < 4; cornerIdx++) {
@@ -845,11 +850,9 @@ export function renderWasmOutputToGeometry(
 
             tgtNorm.push(transformedDir[0], transformedDir[1], transformedDir[2])
 
-            const useModelLighting = (!cachedModel.isCube || globalMatrix != null) && world
-
             let ao = 3
-            let skyLightNorm = 1
-            let blockLightNorm = 0
+            let skyLightNorm = baseChannels?.sky ?? 1
+            let blockLightNorm = baseChannels?.block ?? 0
             const faceDir = transformedDirI as [number, number, number]
 
             if (!doAO) {

package/src/wasm-mesher/worker/mesherWasm.ts

@@ -44,6 +44,9 @@ function processUpdateLightV17(rawPacket: Uint8Array, numSections: number): void
     })
     invalidateConversion(x, z)
     dirtyColumnSectionsForLightUpdate(x, z)
+    const hadColumn = !!world?.getColumn(x, z)
+    syncV17LightToColumn(x, z)
+    if (!hadColumn) pendingLightDirtyColumns.add(rawCacheKey(x, z))
   } catch (err) {
     console.warn('[WASM Mesher] parseUpdateLightV17 failed:', err)
   }
@@ -248,6 +251,44 @@ interface UpdateLightV17Entry {
   blockLight: Uint8Array
 }
 const updateLightV17Cache = new Map<string, UpdateLightV17Entry>()
+/** Columns that received `update_light` before the worker column existed. */
+const pendingLightDirtyColumns = new Set<string>()
+const _syncLightPos = new Vec3(0, 0, 0)
+
+function resolveUpdateLightV17Entry(x: number, z: number, chunk: any | undefined, worldMinY: number, worldMaxY: number): UpdateLightV17Entry | undefined {
+  const cached = updateLightV17Cache.get(rawCacheKey(x, z))
+  if (cached?.blockLight?.length) return cached
+  if (!chunk) return cached
+  const { result } = getOrConvertColumn(x, z, chunk, version, worldMinY, worldMaxY, () => convertChunkToWasm(chunk, version, x, z, worldMinY, worldMaxY), chunk)
+  return { blockLight: result.blockLight, skyLight: result.skyLight }
+}
+
+/** Write cached 1.17 `update_light` arrays into the worker prismarine column. */
+function syncV17LightToColumn(x: number, z: number): boolean {
+  if (!world) return false
+  const col = world.getColumn(x, z)
+  const entry = updateLightV17Cache.get(rawCacheKey(x, z))
+  if (!col || !entry) return false
+
+  const CHUNK_SIZE = 16
+  const minY = config?.worldMinY ?? 0
+  const maxY = config?.worldMaxY ?? 256
+  const { blockLight, skyLight } = entry
+
+  for (let y = minY; y < maxY; y++) {
+    for (let lz = 0; lz < CHUNK_SIZE; lz++) {
+      for (let lx = 0; lx < CHUNK_SIZE; lx++) {
+        const idx = lx + lz * CHUNK_SIZE + (y - minY) * CHUNK_SIZE * CHUNK_SIZE
+        if (idx >= blockLight.length) continue
+        _syncLightPos.set(lx, y, lz)
+        col.setBlockLight(_syncLightPos, blockLight[idx]!)
+        col.setSkyLight(_syncLightPos, skyLight[idx]!)
+      }
+    }
+  }
+
+  return true
+}
 
 // 1.16 path: pre-extracted section bytes + bit mask. Bit mask in 1.16
 // is a varint that fits in i32 (only 16 sections), so we accept it as a
@@ -625,7 +666,7 @@ const meshMultiColumnsFromParsedV16V17 = (
       bitMapLoHi[i * 2] = entry.bitMapLoHi[0]
       bitMapLoHi[i * 2 + 1] = entry.bitMapLoHi[1]
       if (i === 0) maxBitsPerBlock = entry.maxBitsPerBlock
-      const light = updateLightV17Cache.get(key)
+      const light = resolveUpdateLightV17Entry(chunksToUse[i].x, chunksToUse[i].z, chunksToUse[i].chunk, worldMinY, worldMaxY)
       skyLightList.push(light?.skyLight ?? new Uint8Array(0))
       blockLightList.push(light?.blockLight ?? new Uint8Array(0))
     } else {
@@ -720,6 +761,11 @@ const handleMessage = async (data: any) => {
       invalidateConversion(data.x, data.z)
       if (!world) break
       world.addColumn(data.x, data.z, data.chunk)
+      syncV17LightToColumn(data.x, data.z)
+      const lightKey = rawCacheKey(data.x, data.z)
+      if (pendingLightDirtyColumns.delete(lightKey) || updateLightV17Cache.has(lightKey)) {
+        dirtyColumnSectionsForLightUpdate(data.x, data.z)
+      }
       if (data.customBlockModels) {
         const chunkKey = `${data.x},${data.z}`
         world.customBlockModels.set(chunkKey, data.customBlockModels)
@@ -760,6 +806,7 @@ const handleMessage = async (data: any) => {
       updateLightV17Cache.delete(rawCacheKey(data.x, data.z))
       parsedV16Cache.delete(rawCacheKey(data.x, data.z))
       updateLightV16Cache.delete(rawCacheKey(data.x, data.z))
+      pendingLightDirtyColumns.delete(rawCacheKey(data.x, data.z))
       if (!world) break
       world.removeColumn(data.x, data.z)
       world.customBlockModels.delete(`${data.x},${data.z}`)
@@ -863,6 +910,7 @@ const handleMessage = async (data: any) => {
       rawMapChunkCache.clear()
       parsedV17Cache.clear()
       updateLightV17Cache.clear()
+      pendingLightDirtyColumns.clear()
       parsedV16Cache.clear()
       updateLightV16Cache.clear()
       globalVar.mcData = null
@@ -1068,7 +1116,7 @@ function processColumnTick() {
             wasmResult = meshColumnFromRawV18Plus(rawEntry, x, z, worldMinY, worldMaxY, meta)
             if (wasmResult) columnMeshPath = 'v18_fused'
           } else if (v17Entry) {
-            const v17Light = updateLightV17Cache.get(rawCacheKey(x, z))
+            const v17Light = resolveUpdateLightV17Entry(x, z, targetChunk, worldMinY, worldMaxY)
             wasmResult = meshColumnFromParsedV16V17(
               v17Entry.chunkData,
               v17Entry.bitMapLoHi,
@@ -1139,7 +1187,7 @@ function processColumnTick() {
             const cs = performance.now()
             const rawEntry = rawMapChunkCache.get(rawCacheKey(cx, cz))
             const v17Entry = parsedV17Cache.get(rawCacheKey(cx, cz))
-            const v17Light = updateLightV17Cache.get(rawCacheKey(cx, cz))
+            const v17Light = resolveUpdateLightV17Entry(cx, cz, chunk, worldMinY, worldMaxY)
             const v16Entry = parsedV16Cache.get(rawCacheKey(cx, cz))
             const v16Light = updateLightV16Cache.get(rawCacheKey(cx, cz))