minecraft-renderer 0.1.67 → 0.1.68

package/package.json

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

package/src/mesher-shared/exportedGeometryTypes.ts

@@ -14,7 +14,7 @@ export interface ExportedSection {
   shaderCubes?: {
     words: Uint32Array
     count: number
-    formatVersion: 2
+    formatVersion: 3
   }
 }
 

package/src/mesher-shared/shared.ts

@@ -69,7 +69,7 @@ export type MesherGeometryOutput = {
   shaderCubes?: {
     words: Uint32Array
     count: number
-    formatVersion: 2
+    formatVersion: 3
   }
 }
 

package/src/three/shaders/cubeBlockShader.ts

@@ -148,8 +148,9 @@ void main() {
     }
 
     // --- Position: section base (multiples of 16) + face quad + block-local 0..15 ---
-    int sX = int(a_w3 & 0xFFFFu) - 32768;
-    int sZ = int((a_w3 >> 16u) & 0xFFFFu) - 32768;
+    // Must mirror WORD2/WORD3 constants in TS (GLSL cannot import them).
+    int sX = int((a_w3 & 0xFFFFu) | (((a_w2 >> 19u) & 0x3Fu) << 16u)) - 2097152;
+    int sZ = int(((a_w3 >> 16u) & 0xFFFFu) | (((a_w2 >> 25u) & 0x3Fu) << 16u)) - 2097152;
     int sY = int((a_w2 >> 13u) & 0x1Fu) - 4;
     vec3 sectionBase = vec3(float(sX * 16), float(sY * 16), float(sZ * 16));
     vec3 facePos = BASE[faceId] + u * DU[faceId] + v * DV[faceId];
@@ -343,12 +344,17 @@ export const WORD2 = {
     SECTION_Y_SHIFT: 13,
     SECTION_Y_BITS: 5,
     EMPTY_SHIFT: 18,
-    SPARE_BITS: 13,
+    SECTION_X_HI_SHIFT: 19,
+    SECTION_Z_HI_SHIFT: 25,
+    SECTION_HI_BITS: 6,
+    SPARE_BITS: 1,
 } as const
 
-/** Section base X/Z packed into a_w3 (16-block units, biased). */
+/** Section base X/Z: low 16 bits in a_w3, high 6 in a_w2 (22-bit biased section index). */
 export const WORD3 = {
-    SECTION_X_BITS: 16,
-    SECTION_Z_BITS: 16,
-    SECTION_BIAS: 32768,
+    SECTION_BITS: 22,
+    SECTION_MASK: (1 << 22) - 1,
+    LO_BITS: 16,
+    HI_BITS: 6,
+    SECTION_BIAS: 2097152,
 } as const

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

@@ -524,8 +524,6 @@ export function renderWasmOutputToGeometry(
     const [bx, by, bz] = block.position
     const blockStateId = block.block_state_id
 
-    log(`[WASM] Processing block at (${bx}, ${by}, ${bz}), stateId=${blockStateId}, visible_faces=0b${block.visible_faces.toString(2).padStart(6, '0')}`)
-
     const prismBlock = PrismarineBlock.fromStateId(blockStateId, 1)
 
     let biome: string | undefined

package/src/wasm-mesher/bridge/shaderCubeBridge.ts

@@ -10,7 +10,7 @@ import { WORD0, WORD1, WORD2, WORD3 } from '../../three/shaders/cubeBlockShader'
 import { TextureIndexMapping, type TextureEntry } from '../../three/shaders/textureIndexMapping'
 import { TintPalette } from '../../three/shaders/tintPalette'
 
-export const SHADER_CUBES_FORMAT_VERSION = 2 as const
+export const SHADER_CUBES_FORMAT_VERSION = 3 as const
 export const SHADER_CUBES_WORDS_PER_FACE = 4 as const
 
 export type ShaderCubesOutput = {
@@ -238,26 +238,40 @@ function packWord1(lightCombined: number[]): number {
   return w >>> 0
 }
 
-export function packWord2(texIndex: number, aoDiagonalFlip: boolean, sectionBaseY: number): number {
+function biasedSectionIndex(sectionBaseCoord: number): number {
+  return (Math.floor(sectionBaseCoord / 16) + WORD3.SECTION_BIAS) & WORD3.SECTION_MASK
+}
+
+export function packWord2(
+  texIndex: number,
+  aoDiagonalFlip: boolean,
+  sectionBaseX: number,
+  sectionBaseY: number,
+  sectionBaseZ: number,
+): number {
   let w = texIndex & ((1 << WORD2.TEX_INDEX_BITS) - 1)
   if (aoDiagonalFlip) {
     w |= 1 << WORD2.DIAGONAL_FLAG_SHIFT
   }
   const sectionY = ((Math.floor(sectionBaseY / 16) + 4) & 0x1f) << WORD2.SECTION_Y_SHIFT
   w |= sectionY
+  const sx = biasedSectionIndex(sectionBaseX)
+  const sz = biasedSectionIndex(sectionBaseZ)
+  w |= ((sx >>> 16) & 0x3f) << WORD2.SECTION_X_HI_SHIFT
+  w |= ((sz >>> 16) & 0x3f) << WORD2.SECTION_Z_HI_SHIFT
   return w >>> 0
 }
 
 export function packWord3(sectionBaseX: number, sectionBaseZ: number): number {
-  const sx = (Math.floor(sectionBaseX / 16) + WORD3.SECTION_BIAS) & 0xffff
-  const sz = (Math.floor(sectionBaseZ / 16) + WORD3.SECTION_BIAS) & 0xffff
-  return (sx | (sz << 16)) >>> 0
+  const sx = biasedSectionIndex(sectionBaseX)
+  const sz = biasedSectionIndex(sectionBaseZ)
+  return ((sx & 0xffff) | ((sz & 0xffff) << 16)) >>> 0
 }
 
 /** Decode section base block coords from packed words (round-trip helper for tests). */
 export function decodeSectionBaseFromWords(word2: number, word3: number): { x: number, y: number, z: number } {
-  const sX = (word3 & 0xffff) - WORD3.SECTION_BIAS
-  const sZ = ((word3 >>> 16) & 0xffff) - WORD3.SECTION_BIAS
+  const sX = ((word3 & 0xffff) | (((word2 >>> WORD2.SECTION_X_HI_SHIFT) & 0x3f) << 16)) - WORD3.SECTION_BIAS
+  const sZ = (((word3 >>> 16) & 0xffff) | (((word2 >>> WORD2.SECTION_Z_HI_SHIFT) & 0x3f) << 16)) - WORD3.SECTION_BIAS
   const sY = ((word2 >>> WORD2.SECTION_Y_SHIFT) & ((1 << WORD2.SECTION_Y_BITS) - 1)) - 4
   return { x: sX * 16, y: sY * 16, z: sZ * 16 }
 }
@@ -323,7 +337,14 @@ export function tryBuildShaderCubeInstances(
   opts: BuildShaderCubeInstancesOpts,
   words: number[],
 ): boolean {
-  const { sectionOrigin, sectionHeight, biome, tintPalette, textureIndexMapping, doAO = true } = opts
+  const {
+    sectionOrigin,
+    sectionHeight,
+    biome,
+    tintPalette,
+    textureIndexMapping,
+    doAO = true,
+  } = opts
 
   if (!isShaderCubeBlock(cached, model, sectionHeight, textureIndexMapping)) {
     return false
@@ -381,9 +402,10 @@ export function tryBuildShaderCubeInstances(
     words.push(
       packWord0(lx, ly, lz, faceIdx, tintIndex, ao),
       packWord1(lightCombined),
-      packWord2(texIndex, aoDiagonalFlip, sectionOrigin.y),
+      packWord2(texIndex, aoDiagonalFlip, sectionOrigin.x, sectionOrigin.y, sectionOrigin.z),
       packWord3(sectionOrigin.x, sectionOrigin.z),
     )
+
   }
 
   return true

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

@@ -1,6 +1,6 @@
 //@ts-nocheck
 import { test, expect, beforeEach } from 'vitest'
-import { WORD0, WORD2, WORD3 } from '../../three/shaders/cubeBlockShader'
+import { WORD0, WORD2 } from '../../three/shaders/cubeBlockShader'
 import {
   resetShaderCubeResources,
   getShaderCubeResources,
@@ -10,6 +10,7 @@ import {
   countVisibleFaces,
   unpackTexIndexFromWord2,
   decodeSectionBaseFromWords,
+  packWord2Empty,
   packWord3,
   SHADER_CUBES_FORMAT_VERSION,
   SHADER_CUBES_WORDS_PER_FACE,
@@ -305,33 +306,47 @@ test('doAO false: full bright AO/light and no diagonal flip', () => {
   expect(words[2]! & (1 << WORD2.DIAGONAL_FLAG_SHIFT)).toBe(0)
 })
 
-test('section base coords round-trip in word2/word3', () => {
-  const words: number[] = []
-  const block = {
-    position: [10, 17, 4] 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 } = getShaderCubeResources()
-  const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
-  const sectionOrigin = { x: 0, y: 16, z: 32 }
-  tryBuildShaderCubeInstances(
-    block,
-    { blockName: 'stone', blockProps: {}, isCube: true, model },
-    model,
-    { sectionOrigin, sectionHeight: 16, tintPalette, textureIndexMapping },
-    words,
-  )
-  const base = decodeSectionBaseFromWords(words[2]!, words[3]!)
-  expect(base).toEqual(sectionOrigin)
-  const sX = (words[3]! & 0xffff) - WORD3.SECTION_BIAS
-  const sZ = ((words[3]! >>> 16) & 0xffff) - WORD3.SECTION_BIAS
-  const sY = ((words[2]! >>> WORD2.SECTION_Y_SHIFT) & 0x1f) - 4
-  expect(sX * 16).toBe(sectionOrigin.x)
-  expect(sY * 16).toBe(sectionOrigin.y)
-  expect(sZ * 16).toBe(sectionOrigin.z)
+const SECTION_ORIGIN_ROUND_TRIP_CASES: Array<{ x: number, y: number, z: number }> = [
+  { x: 0, y: 16, z: 32 },
+  { x: 0, y: 0, z: 0 },
+  { x: 524288, y: 0, z: 524288 },
+  { x: 1000000, y: 64, z: 1000000 },
+  { x: 33000000, y: 0, z: 33000000 },
+  { x: -524288, y: 0, z: -524288 },
+  { x: -1000000, y: 0, z: -1000000 },
+  { x: 1000000, y: 0, z: -1000000 },
+]
+
+test.each(SECTION_ORIGIN_ROUND_TRIP_CASES)(
+  'section base coords round-trip in word2/word3 at origin (%#)',
+  (sectionOrigin) => {
+    const words: number[] = []
+    const block = {
+      position: [10, 17, 4] 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 } = getShaderCubeResources()
+    const model = { elements: [{ faces: SIX_FACE_TEXTURES }] }
+    tryBuildShaderCubeInstances(
+      block,
+      { blockName: 'stone', blockProps: {}, isCube: true, model },
+      model,
+      { sectionOrigin, sectionHeight: 16, tintPalette, textureIndexMapping },
+      words,
+    )
+    const base = decodeSectionBaseFromWords(words[2]!, words[3]!)
+    expect(base).toEqual(sectionOrigin)
+  },
+)
+
+test('packWord2Empty: bit 18 set regardless of high X/Z bits in word2', () => {
+  const empty = packWord2Empty()
+  expect(empty & (1 << WORD2.EMPTY_SHIFT)).not.toBe(0)
+  const withHighBits = empty | (0x3f << WORD2.SECTION_X_HI_SHIFT) | (0x3f << WORD2.SECTION_Z_HI_SHIFT)
+  expect(withHighBits & (1 << WORD2.EMPTY_SHIFT)).not.toBe(0)
 })
 
 test('GlobalBlockBuffer: free-list reuses slot with EMPTY sentinel', () => {

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

@@ -1357,7 +1357,7 @@ function processColumnTick() {
             geometry.shaderCubes = {
               words: new Uint32Array(exported.shaderCubes.words),
               count: exported.shaderCubes.count,
-              formatVersion: 2,
+              formatVersion: 3,
             }
           }
           transferable = [