minecraft-renderer 0.1.72 → 0.1.74

package/src/wasm-mesher/tests/shaderCubeInstances.test.ts

@@ -16,12 +16,19 @@ import {
   SHADER_CUBES_WORDS_PER_FACE,
 } from '../bridge/shaderCubeBridge'
 import { GlobalBlockBuffer } from '../../three/globalBlockBuffer'
-import { createCubeBlockMaterial } from '../../three/shaders/cubeBlockShader'
+import { buildVisibleCubeSpans } from '../../three/cubeDrawSpans'
+import { createCubeBlockMaterial, computeSectionOriginRel } from '../../three/shaders/cubeBlockShader'
 import * as THREE from 'three'
 import { renderWasmOutputToGeometry } from '../bridge/render-from-wasm'
 
 const VERSION = '1.16.5'
 const STONE = 1
+
+function requireShaderCubeResources() {
+  const resources = getShaderCubeResources()
+  if (!resources) throw new Error('shader cube resources unavailable in test')
+  return resources
+}
 /** mc-assets blocksAtlases.json → stone */
 const STONE_ATLAS_TILE_INDEX = 552
 
@@ -38,7 +45,7 @@ test('packWord2: AO diagonal flip sets bit 12', () => {
     light_data: [[1, 1, 1, 1]],
     light_combined: [[255, 255, 255, 255]],
   }
-  const { textureIndexMapping, tintPalette } = getShaderCubeResources()
+  const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = {
     elements: [{
       faces: {
@@ -77,7 +84,7 @@ test('packWord0: section-local lx/ly/lz and face id', () => {
     light_data: [[0.5, 0.5, 0.5, 0.5]],
     light_combined: [[128, 128, 128, 128]],
   }
-  const { textureIndexMapping, tintPalette } = getShaderCubeResources()
+  const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = {
     elements: [{
       faces: {
@@ -110,7 +117,7 @@ test('packWord0: section-local lx/ly/lz and face id', () => {
 })
 
 test('isShaderCubeBlock: rejects model rotation and sectionHeight !== 16', () => {
-  const { textureIndexMapping } = getShaderCubeResources()
+  const { textureIndexMapping } = requireShaderCubeResources()
   const baseModel = {
     elements: [{
       faces: {
@@ -221,7 +228,7 @@ test('south face: AO corners remapped to shader order (elemFaces [0,3,1,2] → s
     light_data: [[1, 1, 1, 1]],
     light_combined: [[10, 20, 30, 40]],
   }
-  const { textureIndexMapping, tintPalette } = getShaderCubeResources()
+  const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
   tryBuildShaderCubeInstances(
     block,
@@ -247,7 +254,7 @@ test('south face: diagonal flip uses remapped AO (differs from raw elemFaces for
     light_data: [[1, 1, 1, 1]],
     light_combined: [[255, 255, 255, 255]],
   }
-  const { textureIndexMapping, tintPalette } = getShaderCubeResources()
+  const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
   const opts = {
     sectionOrigin: { x: 0, y: 0, z: 0 },
@@ -284,7 +291,7 @@ test('doAO false: full bright AO/light and no diagonal flip', () => {
     light_data: [[0, 0, 0, 0]],
     light_combined: [[0, 0, 0, 0]],
   }
-  const { textureIndexMapping, tintPalette } = getShaderCubeResources()
+  const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
   const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
   tryBuildShaderCubeInstances(
     block,
@@ -328,7 +335,7 @@ test.each(SECTION_ORIGIN_ROUND_TRIP_CASES)(
       light_data: [[1, 1, 1, 1]],
       light_combined: [[255, 255, 255, 255]],
     }
-    const { textureIndexMapping, tintPalette } = getShaderCubeResources()
+    const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
     const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
     tryBuildShaderCubeInstances(
       block,
@@ -349,6 +356,38 @@ test('packWord2Empty: bit 18 set regardless of high X/Z bits in word2', () => {
   expect(withHighBits & (1 << WORD2.EMPTY_SHIFT)).not.toBe(0)
 })
 
+test('section index relative decode past 2^20: exact integer subtract', () => {
+  const sectionBlockX = 21_050_000
+  const renderOrigin = { x: 21_000_000, y: 0, z: 0 }
+  const words: number[] = []
+  const block = {
+    position: [0, 0, 0] as [number, number, number],
+    visible_faces: 1 << 2,
+    ao_data: [[3, 3, 3, 3]],
+    light_data: [[1, 1, 1, 1]],
+    light_combined: [[255, 255, 255, 255]],
+  }
+  const { textureIndexMapping, tintPalette } = requireShaderCubeResources()
+  const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
+  tryBuildShaderCubeInstances(
+    block,
+    { blockName: 'stone', blockProps: {}, isCube: true, model },
+    model,
+    {
+      sectionOrigin: { x: sectionBlockX, y: 0, z: 0 },
+      sectionHeight: 16,
+      tintPalette,
+      textureIndexMapping,
+    },
+    words,
+  )
+  const base = decodeSectionBaseFromWords(words[2]!, words[3]!)
+  const sX = base.x / 16
+  const sectionOriginRel = computeSectionOriginRel(renderOrigin)
+  const sXr = sX - sectionOriginRel.x
+  expect(sXr * 16).toBe(sectionBlockX - renderOrigin.x)
+})
+
 test('GlobalBlockBuffer: free-list reuses slot with EMPTY sentinel', () => {
   const scene = new THREE.Scene()
   const mat = createCubeBlockMaterial()
@@ -661,6 +700,35 @@ test('GlobalBlockBuffer: takeSectionData reads relocated section slot', () => {
   mat.dispose()
 })
 
+test('GlobalBlockBuffer: pendingMove draw start uses oldStart for visible spans', () => {
+  const scene = new THREE.Scene()
+  const mat = createCubeBlockMaterial()
+  const buffer = new GlobalBlockBuffer(mat, scene)
+
+  buffer.addSection('a', makeSectionWords([10]), 1)
+  buffer.addSection('b', makeSectionWords([20]), 1)
+  buffer.addSection('c', makeSectionWords([30]), 1)
+  buffer.removeSection('b')
+  drainAllUploads(buffer)
+
+  buffer.compactStep()
+  const move = buffer.getPendingMove()
+  expect(move?.key).toBe('c')
+
+  const slotStart = buffer.getSectionSlot('c')!.start
+  expect(buffer.getSectionDrawStart('c')).toBe(move!.oldStart)
+  expect(buffer.getSectionDrawStart('c')).not.toBe(slotStart)
+
+  const spans = buildVisibleCubeSpans(
+    [{ start: buffer.getSectionDrawStart('c')!, count: 1 }],
+    buffer.getHighWatermark(),
+  )
+  expect(spans[0]?.start).toBe(move!.oldStart)
+
+  buffer.dispose()
+  mat.dispose()
+})
+
 test('GlobalBlockBuffer: uploadDirtyRange budgets large dirty span across frames', () => {
   const scene = new THREE.Scene()
   const mat = createCubeBlockMaterial()
@@ -679,12 +747,12 @@ test('GlobalBlockBuffer: uploadDirtyRange budgets large dirty span across frames
 
   const w0Attr = buffer.mesh.geometry.getAttribute('a_w0') as THREE.InstancedBufferAttribute
   buffer.uploadDirtyRange()
-  expect(w0Attr.updateRange.offset).toBe(0)
-  expect(w0Attr.updateRange.count).toBe(15_000)
+  expect(w0Attr.updateRanges[0].start).toBe(0)
+  expect(w0Attr.updateRanges[0].count).toBe(15_000)
 
   buffer.uploadDirtyRange()
-  expect(w0Attr.updateRange.offset).toBe(15_000)
-  expect(w0Attr.updateRange.count).toBe(5_000)
+  expect(w0Attr.updateRanges[0].start).toBe(15_000)
+  expect(w0Attr.updateRanges[0].count).toBe(5_000)
 
   buffer.uploadDirtyRange()
   expect((buffer as unknown as { pendingRanges: unknown[] }).pendingRanges).toHaveLength(0)

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

@@ -8,6 +8,7 @@ import { worldColumnKey, World } from '../../mesher-shared/world'
 import { handleGetHeightmap, EMPTY_COLUMN_HEIGHTMAP_SENTINEL } from '../../mesher-shared/computeHeightmap'
 import { collectBlockEntityMetadata, type SignMeta, type HeadMeta, type BannerMeta } from '../../mesher-shared/blockEntityMetadata'
 import { SectionRequestTracker } from './mesherWasmRequestTracker'
+import { sectionYsForLightColumnDirty } from './mesherWasmLightDirty'
 import {
   CONVERSION_CACHE_LIMIT,
   clearConversionCache,
@@ -18,6 +19,7 @@ import {
 
 let wasm: typeof import('../runtime-build/wasm_mesher.js') | null = null
 let wasmInitialized = false
+let wasmReady = false // true ONLY after wasm.default() instantiates the module; gates light-packet parsing
 
 // Pending raw `update_light` packets that arrived before WASM finished
 // loading. Parsed and drained once `initWasm` resolves. Without this queue
@@ -33,7 +35,7 @@ const pendingUpdateLightV17: Array<{ rawPacket: Uint8Array, numSections: number
 const pendingUpdateLightV16: Array<{ rawPacket: Uint8Array }> = []
 
 function processUpdateLightV17 (rawPacket: Uint8Array, numSections: number): void {
-  if (!wasm || !(wasm as any).parseUpdateLightV17) {
+  if (!wasmReady) {
     pendingUpdateLightV17.push({ rawPacket, numSections })
     return
   }
@@ -41,11 +43,13 @@ function processUpdateLightV17 (rawPacket: Uint8Array, numSections: number): voi
     const parsed: any = (wasm as any).parseUpdateLightV17(rawPacket, numSections)
     const x = (parsed.x as number) * 16
     const z = (parsed.z as number) * 16
+    const skyLight = parsed.skyLight as Uint8Array
     updateLightV17Cache.set(rawCacheKey(x, z), {
-      skyLight: parsed.skyLight as Uint8Array,
+      skyLight,
       blockLight: parsed.blockLight as Uint8Array,
     })
     invalidateConversion(x, z)
+    dirtyColumnSectionsForLightUpdate(x, z)
   } catch (err) {
     console.warn('[WASM Mesher] parseUpdateLightV17 failed:', err)
   }
@@ -57,7 +61,7 @@ function processUpdateLightV17 (rawPacket: Uint8Array, numSections: number): voi
 // chunk cache has the entry, and crossing the streams could mismatch a
 // stale 1.17 column with 1.16 light or vice versa during version switches.
 function processUpdateLightV16 (rawPacket: Uint8Array): void {
-  if (!wasm || !(wasm as any).parseUpdateLightV17) {
+  if (!wasmReady) {
     pendingUpdateLightV16.push({ rawPacket })
     return
   }
@@ -70,6 +74,7 @@ function processUpdateLightV16 (rawPacket: Uint8Array): void {
       blockLight: parsed.blockLight as Uint8Array,
     })
     invalidateConversion(x, z)
+    dirtyColumnSectionsForLightUpdate(x, z)
   } catch (err) {
     console.warn('[WASM Mesher] parseUpdateLightV17 (v16) failed:', err)
   }
@@ -81,6 +86,7 @@ async function initWasm() {
     wasmInitialized = true
     wasm = await import('../runtime-build/wasm_mesher.js')
     await wasm.default('/wasm_mesher_bg.wasm') as any
+    wasmReady = true // instance is now usable; drained packets below will pass the guard
 
     if (pendingUpdateLightV17.length > 0) {
       console.log('[WASM Mesher] draining', pendingUpdateLightV17.length, 'pending update_light v17 packets')
@@ -94,7 +100,10 @@ async function initWasm() {
       for (const item of queue) processUpdateLightV16(item.rawPacket)
     }
   } catch (err) {
-    console.error('Failed to initialize WASM mesher:', err)
+    console.error(
+      '[WASM Mesher] Failed to initialize WASM mesher — block lighting may stay at full brightness:',
+      err,
+    )
     wasmInitialized = true // Don't try to initialize again
     // Don't throw - allow worker to continue without WASM (will fail on first use)
   }
@@ -195,6 +204,15 @@ function setSectionDirty(pos: Vec3, value = true) {
   }
 }
 
+/** Re-mesh every section in a column after `update_light` updates the light cache. */
+function dirtyColumnSectionsForLightUpdate (x: number, z: number) {
+  const worldMinY = config?.worldMinY ?? 0
+  const worldMaxY = config?.worldMaxY ?? 256
+  for (const y of sectionYsForLightColumnDirty(worldMinY, worldMaxY, SECTION_HEIGHT)) {
+    setSectionDirty(new Vec3(x, y, z))
+  }
+}
+
 const softCleanup = () => {
   world = new World(world.config.version)
   globalThis.world = world
@@ -340,7 +358,7 @@ const convertParsedV17ToWasm = (
   } else {
     blockLight = new Uint8Array(totalBlocks)
     skyLight = new Uint8Array(totalBlocks)
-    skyLight.fill(15)
+    skyLight.fill(config?.skyLight ?? 15)
   }
   const biomesArray: Uint8Array = parsed.biomes
   let blockCount = 0
@@ -406,7 +424,7 @@ const convertParsedV16ToWasm = (
   } else {
     blockLight = new Uint8Array(totalBlocks)
     skyLight = new Uint8Array(totalBlocks)
-    skyLight.fill(15)
+    skyLight.fill(config?.skyLight ?? 15)
   }
   const biomesArray: Uint8Array = parsed.biomes
   let blockCount = 0
@@ -465,7 +483,7 @@ const meshColumnFromRawV18Plus = (
       meta.occludingBlocks,
       config?.enableLighting !== false,
       config?.smoothLighting !== false,
-      config?.skyLight || 15
+      config?.skyLight ?? 15
     )
   } catch (err) {
     console.warn('[WASM Mesher] generateGeometryFromMapChunkV18Plus failed, falling back:', err)
@@ -511,7 +529,7 @@ const meshColumnFromParsedV16V17 = (
       meta.occludingBlocks,
       config?.enableLighting !== false,
       config?.smoothLighting !== false,
-      config?.skyLight || 15
+      config?.skyLight ?? 15
     )
   } catch (err) {
     console.warn('[WASM Mesher] generateGeometryFromParsedV16V17 failed, falling back:', err)
@@ -572,7 +590,7 @@ const meshMultiColumnsFromRawV18Plus = (
       meta.occludingBlocks,
       config?.enableLighting !== false,
       config?.smoothLighting !== false,
-      config?.skyLight || 15
+      config?.skyLight ?? 15
     )
   } catch (err) {
     console.warn('[WASM Mesher] generateGeometryFromMapChunkV18PlusMulti failed:', err)
@@ -672,7 +690,7 @@ const meshMultiColumnsFromParsedV16V17 = (
       meta.occludingBlocks,
       config?.enableLighting !== false,
       config?.smoothLighting !== false,
-      config?.skyLight || 15
+      config?.skyLight ?? 15
     )
   } catch (err) {
     console.warn('[WASM Mesher] generateGeometryFromParsedV16V17Multi failed:', err)
@@ -976,6 +994,8 @@ function makeEmptyColumnGeometry(sx: number, sy: number, sz: number, sectionHeig
     positions: new Float32Array(0),
     normals: new Float32Array(0),
     colors: new Float32Array(0),
+    skyLights: new Float32Array(0),
+    blockLights: new Float32Array(0),
     uvs: new Float32Array(0),
     indices: new Uint32Array(0),
     indicesCount: 0,
@@ -1033,6 +1053,7 @@ function processColumnTick() {
     let preCacheHits = 0
     let preCacheMisses = 0
     let hadError = false
+    let columnMeshPath = 'none'
     // Outer-scope timestamps so we can finalize `processTime` and
     // `postPhase` AFTER the per-section emit loop runs (the loop builds
     // typed arrays, walks block-entity metadata, and calls postMessage —
@@ -1052,6 +1073,7 @@ function processColumnTick() {
         let wasmResult: any
         let t1 = 0
         let usedFusedPath = false
+        columnMeshPath = 'none'
 
         const meta = getBlockMeta(version)
 
@@ -1067,6 +1089,7 @@ function processColumnTick() {
 
           if (rawEntry) {
             wasmResult = meshColumnFromRawV18Plus(rawEntry, x, z, worldMinY, worldMaxY, meta)
+            if (wasmResult) columnMeshPath = 'v18_fused'
           } else if (v17Entry) {
             const v17Light = updateLightV17Cache.get(rawCacheKey(x, z))
             wasmResult = meshColumnFromParsedV16V17(
@@ -1075,6 +1098,7 @@ function processColumnTick() {
               v17Light?.skyLight ?? null, v17Light?.blockLight ?? null,
               x, z, worldMinY, worldMaxY, meta
             )
+            if (wasmResult) columnMeshPath = 'v17_fused'
           } else if (v16Entry) {
             const v16Light = updateLightV16Cache.get(rawCacheKey(x, z))
             const bitMapLoHi = new Uint32Array([v16Entry.bitMap >>> 0, 0])
@@ -1084,6 +1108,7 @@ function processColumnTick() {
               v16Light?.skyLight ?? null, v16Light?.blockLight ?? null,
               x, z, worldMinY, worldMaxY, meta
             )
+            if (wasmResult) columnMeshPath = 'v16_fused'
           }
 
           if (wasmResult) {
@@ -1104,6 +1129,7 @@ function processColumnTick() {
           wasmResult = meshMultiColumnsFromRawV18Plus(chunksToUse, x, z, worldMinY, worldMaxY, meta)
                     ?? meshMultiColumnsFromParsedV16V17(chunksToUse, x, z, worldMinY, worldMaxY, meta)
           if (wasmResult) {
+            columnMeshPath = 'multi_fused'
             usedFusedPath = true
             t1 = performance.now()
             wasmPhase = t1 - t0
@@ -1181,8 +1207,9 @@ function processColumnTick() {
               invisibleBlocks, transparentBlocks, noAoBlocks, cullIdenticalBlocks, occludingBlocks,
               config?.enableLighting !== false,
               config?.smoothLighting !== false,
-              config?.skyLight || 15
+              config?.skyLight ?? 15
             )
+            columnMeshPath = 'two_step_single'
           } else {
             const tBuildStart = performance.now()
             const perChunkLen = conversions[0].blockStates.length
@@ -1214,8 +1241,9 @@ function processColumnTick() {
               invisibleBlocks, transparentBlocks, noAoBlocks, cullIdenticalBlocks, occludingBlocks,
               config?.enableLighting !== false,
               config?.smoothLighting !== false,
-              config?.skyLight || 15
+              config?.skyLight ?? 15
             )
+            columnMeshPath = 'two_step_multi'
           }
         }
 
@@ -1306,14 +1334,16 @@ function processColumnTick() {
             for (cursor.x = sx; cursor.x < sx + 16; cursor.x++) {
               const b = world.getBlock(cursor)
               if (!b) continue
-              collectBlockEntityMetadata(b, cursor.x, cursor.y, cursor.z, beTarget, beOpts)
+              collectBlockEntityMetadata(b, cursor.x, cursor.y, cursor.z, beTarget, beOpts, world)
             }
           }
         }
 
         let geometry: MesherGeometryOutput
         let transferable: any[] = []
-        const hasLegacyMesh = (exported?.geometry.indices.length ?? 0) > 0
+        const hasOpaqueMesh = (exported?.geometry.indices.length ?? 0) > 0
+        const hasBlendMesh = (exported?.blendGeometry?.indices.length ?? 0) > 0
+        const hasLegacyMesh = hasOpaqueMesh || hasBlendMesh
         const hasShaderCubes = (exported?.shaderCubes?.count ?? 0) > 0
         if (exported && (hasLegacyMesh || hasShaderCubes)) {
           const maxIndex = exported.geometry.indices.length > 0
@@ -1335,6 +1365,8 @@ function processColumnTick() {
             positions: new Float32Array(exported.geometry.positions),
             normals: new Float32Array(exported.geometry.normals),
             colors: new Float32Array(exported.geometry.colors),
+            skyLights: new Float32Array(exported.geometry.skyLights),
+            blockLights: new Float32Array(exported.geometry.blockLights),
             uvs: new Float32Array(exported.geometry.uvs),
             indices: using32Array
               ? new Uint32Array(exported.geometry.indices)
@@ -1360,13 +1392,37 @@ function processColumnTick() {
               formatVersion: 3,
             }
           }
+          if (exported.blendGeometry && hasBlendMesh) {
+            const blendMax = Math.max(...exported.blendGeometry.indices)
+            geometry.blend = {
+              positions: new Float32Array(exported.blendGeometry.positions),
+              normals: new Float32Array(exported.blendGeometry.normals),
+              colors: new Float32Array(exported.blendGeometry.colors),
+              skyLights: new Float32Array(exported.blendGeometry.skyLights),
+              blockLights: new Float32Array(exported.blendGeometry.blockLights),
+              uvs: new Float32Array(exported.blendGeometry.uvs),
+              indices: blendMax > 65535
+                ? new Uint32Array(exported.blendGeometry.indices)
+                : new Uint16Array(exported.blendGeometry.indices),
+            }
+          }
           transferable = [
             geometry.positions?.buffer,
             geometry.normals?.buffer,
             geometry.colors?.buffer,
+            geometry.skyLights?.buffer,
+            geometry.blockLights?.buffer,
             geometry.uvs?.buffer,
             //@ts-ignore
             geometry.indices?.buffer,
+            geometry.blend?.positions?.buffer,
+            geometry.blend?.normals?.buffer,
+            geometry.blend?.colors?.buffer,
+            geometry.blend?.skyLights?.buffer,
+            geometry.blend?.blockLights?.buffer,
+            geometry.blend?.uvs?.buffer,
+            //@ts-ignore
+            geometry.blend?.indices?.buffer,
             geometry.shaderCubes?.words?.buffer,
           ].filter(Boolean)
 

package/src/wasm-mesher/worker/mesherWasmLightDirty.test.ts

@@ -0,0 +1,11 @@
+//@ts-nocheck
+import { describe, expect, it } from 'vitest'
+import { sectionYsForLightColumnDirty } from './mesherWasmLightDirty'
+
+describe('sectionYsForLightColumnDirty', () => {
+  it('covers every section in a 256-high overworld column', () => {
+    expect(sectionYsForLightColumnDirty(0, 256)).toEqual(
+      Array.from({ length: 16 }, (_, i) => i * 16),
+    )
+  })
+})

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

@@ -0,0 +1,15 @@
+//@ts-nocheck
+import { SECTION_HEIGHT } from '../../mesher-shared/shared'
+
+/** Section Y values to dirty for a column after `update_light` updates the light cache. */
+export function sectionYsForLightColumnDirty (
+  worldMinY: number,
+  worldMaxY: number,
+  sectionHeight = SECTION_HEIGHT,
+): number[] {
+  const ys: number[] = []
+  for (let y = worldMinY; y < worldMaxY; y += sectionHeight) {
+    ys.push(y)
+  }
+  return ys
+}