minecraft-renderer 0.1.79 → 0.1.80

package/src/three/sceneOrigin.ts

@@ -4,20 +4,53 @@ import type { Object3D, Scene, Vector3 } from 'three'
 const IS_TRACKED_PROXY = Symbol('tracked-proxy')
 
 const MUTATING_METHODS = new Set([
-  'add', 'addScalar', 'addScaledVector', 'addVectors',
-  'sub', 'subScalar', 'subVectors',
-  'multiply', 'multiplyScalar', 'multiplyVectors',
-  'divide', 'divideScalar',
-  'applyEuler', 'applyAxisAngle', 'applyMatrix3', 'applyMatrix4', 'applyNormalMatrix', 'applyQuaternion',
-  'negate', 'floor', 'ceil', 'round', 'roundToZero',
-  'min', 'max', 'clamp', 'clampLength', 'clampScalar',
-  'project', 'unproject', 'reflect',
-  'lerp', 'lerpVectors',
-  'cross', 'crossVectors',
-  'setFromMatrixPosition', 'setFromMatrixColumn', 'setFromMatrix3Column',
-  'setFromEuler', 'setFromSpherical', 'setFromSphericalCoords', 'setFromCylindrical',
-  'fromArray', 'fromBufferAttribute',
-  'setComponent', 'randomDirection', 'random',
+  'add',
+  'addScalar',
+  'addScaledVector',
+  'addVectors',
+  'sub',
+  'subScalar',
+  'subVectors',
+  'multiply',
+  'multiplyScalar',
+  'multiplyVectors',
+  'divide',
+  'divideScalar',
+  'applyEuler',
+  'applyAxisAngle',
+  'applyMatrix3',
+  'applyMatrix4',
+  'applyNormalMatrix',
+  'applyQuaternion',
+  'negate',
+  'floor',
+  'ceil',
+  'round',
+  'roundToZero',
+  'min',
+  'max',
+  'clamp',
+  'clampLength',
+  'clampScalar',
+  'project',
+  'unproject',
+  'reflect',
+  'lerp',
+  'lerpVectors',
+  'cross',
+  'crossVectors',
+  'setFromMatrixPosition',
+  'setFromMatrixColumn',
+  'setFromMatrix3Column',
+  'setFromEuler',
+  'setFromSpherical',
+  'setFromSphericalCoords',
+  'setFromCylindrical',
+  'fromArray',
+  'fromBufferAttribute',
+  'setComponent',
+  'randomDirection',
+  'random'
 ])
 
 interface TrackOptions {
@@ -41,9 +74,15 @@ export class SceneOrigin {
     this.scene = scene
   }
 
-  get x(): number { return this._x }
-  get y(): number { return this._y }
-  get z(): number { return this._z }
+  get x(): number {
+    return this._x
+  }
+  get y(): number {
+    return this._y
+  }
+  get z(): number {
+    return this._z
+  }
 
   /** Update origin (called each frame with camera world position) */
   update(worldX: number, worldY: number, worldZ: number): void {
@@ -83,7 +122,9 @@ export class SceneOrigin {
         if (prop === IS_TRACKED_PROXY) return worldData
         if (prop === 'set') {
           return (x: number, y: number, z: number) => {
-            worldData.x = x; worldData.y = y; worldData.z = z
+            worldData.x = x
+            worldData.y = y
+            worldData.z = z
             target.set(x - origin._x, y - origin._y, z - origin._z)
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
@@ -95,7 +136,9 @@ export class SceneOrigin {
             const wx = srcWorld ? srcWorld.x : v.x
             const wy = srcWorld ? srcWorld.y : v.y
             const wz = srcWorld ? srcWorld.z : v.z
-            worldData.x = wx; worldData.y = wy; worldData.z = wz
+            worldData.x = wx
+            worldData.y = wy
+            worldData.z = wz
             target.set(wx - origin._x, wy - origin._y, wz - origin._z)
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
@@ -103,27 +146,32 @@ export class SceneOrigin {
         }
         if (prop === 'setX') {
           return (val: number) => {
-            worldData.x = val; target.x = val - origin._x
+            worldData.x = val
+            target.x = val - origin._x
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
           }
         }
         if (prop === 'setY') {
           return (val: number) => {
-            worldData.y = val; target.y = val - origin._y
+            worldData.y = val
+            target.y = val - origin._y
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
           }
         }
         if (prop === 'setZ') {
           return (val: number) => {
-            worldData.z = val; target.z = val - origin._z
+            worldData.z = val
+            target.z = val - origin._z
             if (opts?.updateMatrix) obj.updateMatrix()
             return receiver
           }
         }
         if (typeof prop === 'string' && MUTATING_METHODS.has(prop)) {
-          return () => { throw new Error(`Cannot call position.${prop}() on a tracked object. Use position.set(x, y, z) instead.`) }
+          return () => {
+            throw new Error(`Cannot call position.${prop}() on a tracked object. Use position.set(x, y, z) instead.`)
+          }
         }
         const value = (target as any)[prop]
         if (typeof value === 'function') return value.bind(target)
@@ -131,17 +179,20 @@ export class SceneOrigin {
       },
       set(target, prop, value) {
         if (prop === 'x') {
-          worldData.x = value; target.x = value - origin._x
+          worldData.x = value
+          target.x = value - origin._x
           if (opts?.updateMatrix) obj.updateMatrix()
           return true
         }
         if (prop === 'y') {
-          worldData.y = value; target.y = value - origin._y
+          worldData.y = value
+          target.y = value - origin._y
           if (opts?.updateMatrix) obj.updateMatrix()
           return true
         }
         if (prop === 'z') {
-          worldData.z = value; target.z = value - origin._z
+          worldData.z = value
+          target.z = value - origin._z
           if (opts?.updateMatrix) obj.updateMatrix()
           return true
         }
@@ -179,7 +230,7 @@ export class SceneOrigin {
 
   /** Untrack an Object3D and all its descendants, then remove from the scene */
   removeAndUntrackAll(obj: Object3D): void {
-    obj.traverse((child) => {
+    obj.traverse(child => {
       this.untrack(child)
     })
     obj.removeFromParent()
@@ -204,12 +255,24 @@ export class SceneOrigin {
   }
 
   /** Convert world coordinates → scene coordinates */
-  toSceneX(worldX: number): number { return worldX - this._x }
-  toSceneY(worldY: number): number { return worldY - this._y }
-  toSceneZ(worldZ: number): number { return worldZ - this._z }
+  toSceneX(worldX: number): number {
+    return worldX - this._x
+  }
+  toSceneY(worldY: number): number {
+    return worldY - this._y
+  }
+  toSceneZ(worldZ: number): number {
+    return worldZ - this._z
+  }
 
   /** Convert scene coordinates → world coordinates */
-  toWorldX(sceneX: number): number { return sceneX + this._x }
-  toWorldY(sceneY: number): number { return sceneY + this._y }
-  toWorldZ(sceneZ: number): number { return sceneZ + this._z }
+  toWorldX(sceneX: number): number {
+    return sceneX + this._x
+  }
+  toWorldY(sceneY: number): number {
+    return sceneY + this._y
+  }
+  toWorldZ(sceneZ: number): number {
+    return sceneZ + this._z
+  }
 }

package/src/three/sectionRaycastAabb.ts

@@ -25,12 +25,12 @@ export type ShaderSectionRaycastEntry = {
  * Tight world-space AABB covering occupied shader-cube blocks in a section.
  * `sectionCenter*` is geometryData.sx/sy/sz (section base + 8).
  */
-export function computeShaderSectionRaycastAabb (
+export function computeShaderSectionRaycastAabb(
   words: Uint32Array,
   faceCount: number,
   sectionCenterX: number,
   sectionCenterY: number,
-  sectionCenterZ: number,
+  sectionCenterZ: number
 ): ShaderSectionRaycastBox | undefined {
   if (faceCount <= 0) return undefined
 
@@ -77,11 +77,11 @@ export function computeShaderSectionRaycastAabb (
     maxZ,
     cx: (minX + maxX) * 0.5,
     cy: (minY + maxY) * 0.5,
-    cz: (minZ + maxZ) * 0.5,
+    cz: (minZ + maxZ) * 0.5
   }
 }
 
-export function isPointInsideAabb (
+export function isPointInsideAabb(
   ox: number,
   oy: number,
   oz: number,
@@ -90,14 +90,14 @@ export function isPointInsideAabb (
   minZ: number,
   maxX: number,
   maxY: number,
-  maxZ: number,
+  maxZ: number
 ): boolean {
   return ox >= minX && ox <= maxX && oy >= minY && oy <= maxY && oz >= minZ && oz <= maxZ
 }
 
 /** True if a `far`-bounded ray from (ox,oy,oz) dir (dx,dy,dz) crosses or starts inside
  *  the cube-section AABB centered at (cx,cy,cz) with the given half-extent. */
-export function sectionAabbIntersectsRay (
+export function sectionAabbIntersectsRay(
   cx: number,
   cy: number,
   cz: number,
@@ -108,7 +108,7 @@ export function sectionAabbIntersectsRay (
   dy: number,
   dz: number,
   far: number,
-  halfExtent: number,
+  halfExtent: number
 ): boolean {
   const minX = cx - halfExtent
   const minY = cy - halfExtent
@@ -121,7 +121,7 @@ export function sectionAabbIntersectsRay (
 }
 
 /** Ray–AABB entry distance, or undefined. Ignores hits when origin is inside the box. */
-export function raycastAabb (
+export function raycastAabb(
   ox: number,
   oy: number,
   oz: number,
@@ -134,7 +134,7 @@ export function raycastAabb (
   maxX: number,
   maxY: number,
   maxZ: number,
-  maxDist: number,
+  maxDist: number
 ): number | undefined {
   if (isPointInsideAabb(ox, oy, oz, minX, minY, minZ, maxX, maxY, maxZ)) {
     return undefined
@@ -149,7 +149,11 @@ export function raycastAabb (
     const inv = 1 / dx
     let t1 = (minX - ox) * inv
     let t2 = (maxX - ox) * inv
-    if (t1 > t2) { const tmp = t1; t1 = t2; t2 = tmp }
+    if (t1 > t2) {
+      const tmp = t1
+      t1 = t2
+      t2 = tmp
+    }
     tmin = Math.max(tmin, t1)
     tmax = Math.min(tmax, t2)
     if (tmin > tmax) return undefined
@@ -161,7 +165,11 @@ export function raycastAabb (
     const inv = 1 / dy
     let t1 = (minY - oy) * inv
     let t2 = (maxY - oy) * inv
-    if (t1 > t2) { const tmp = t1; t1 = t2; t2 = tmp }
+    if (t1 > t2) {
+      const tmp = t1
+      t1 = t2
+      t2 = tmp
+    }
     tmin = Math.max(tmin, t1)
     tmax = Math.min(tmax, t2)
     if (tmin > tmax) return undefined
@@ -173,7 +181,11 @@ export function raycastAabb (
     const inv = 1 / dz
     let t1 = (minZ - oz) * inv
     let t2 = (maxZ - oz) * inv
-    if (t1 > t2) { const tmp = t1; t1 = t2; t2 = tmp }
+    if (t1 > t2) {
+      const tmp = t1
+      t1 = t2
+      t2 = tmp
+    }
     tmin = Math.max(tmin, t1)
     tmax = Math.min(tmax, t2)
     if (tmin > tmax) return undefined
@@ -183,7 +195,7 @@ export function raycastAabb (
 }
 
 /** Ray origin inside AABB: distance to exit face along the ray. */
-export function raycastAabbFromInside (
+export function raycastAabbFromInside(
   ox: number,
   oy: number,
   oz: number,
@@ -196,7 +208,7 @@ export function raycastAabbFromInside (
   maxX: number,
   maxY: number,
   maxZ: number,
-  maxDist: number,
+  maxDist: number
 ): number | undefined {
   let tExit = maxDist
 
@@ -219,7 +231,7 @@ export function raycastAabbFromInside (
 }
 
 /** Per-block raycast; `word0Stride` 1 = GlobalBlockBuffer SoA, 4 = deferred AoS. */
-export function raycastShaderBlocksAabb (
+export function raycastShaderBlocksAabb(
   w0Source: Uint32Array,
   start: number,
   faceCount: number,
@@ -235,7 +247,7 @@ export function raycastShaderBlocksAabb (
   dz: number,
   maxDist: number,
   visitGen: Uint16Array,
-  visitStamp: number,
+  visitStamp: number
 ): number | undefined {
   const baseX = sectionCenterX - 8
   const baseY = sectionCenterY - 8
@@ -276,7 +288,7 @@ export function raycastShaderBlocksAabb (
 }
 
 /** 16³ section box centered at (cx, cy, cz) — tests / legacy helper. */
-export function raycastSectionAabb (
+export function raycastSectionAabb(
   ox: number,
   oy: number,
   oz: number,
@@ -286,7 +298,7 @@ export function raycastSectionAabb (
   cx: number,
   cy: number,
   cz: number,
-  maxDist: number,
+  maxDist: number
 ): number | undefined {
   return raycastAabb(ox, oy, oz, dx, dy, dz, cx - 8, cy - 8, cz - 8, cx + 8, cy + 8, cz + 8, maxDist)
 }

package/src/three/shaderCubeMesh.ts

@@ -12,10 +12,7 @@ export type ShaderCubeInstanceData = {
  * Build InstancedBufferGeometry for full-cube shader faces.
  * One instance = one visible face; vertex shader uses gl_VertexID (6 verts/face).
  */
-export function buildShaderCubeGeometry(
-  words: Uint32Array,
-  faceCount: number,
-): THREE.InstancedBufferGeometry {
+export function buildShaderCubeGeometry(words: Uint32Array, faceCount: number): THREE.InstancedBufferGeometry {
   const geometry = new THREE.InstancedBufferGeometry()
 
   const positions = new Float32Array(VERTICES_PER_FACE * 3)
@@ -39,14 +36,8 @@ export function buildShaderCubeGeometry(
   geometry.setAttribute('a_w3', new THREE.InstancedBufferAttribute(w3, 1))
 
   geometry.instanceCount = faceCount
-  geometry.boundingBox = new THREE.Box3(
-    new THREE.Vector3(-8, -8, -8),
-    new THREE.Vector3(8, 8, 8),
-  )
-  geometry.boundingSphere = new THREE.Sphere(
-    new THREE.Vector3(0, 0, 0),
-    Math.sqrt(3 * 8 ** 2),
-  )
+  geometry.boundingBox = new THREE.Box3(new THREE.Vector3(-8, -8, -8), new THREE.Vector3(8, 8, 8))
+  geometry.boundingSphere = new THREE.Sphere(new THREE.Vector3(0, 0, 0), Math.sqrt(3 * 8 ** 2))
 
   return geometry
 }
@@ -58,9 +49,7 @@ const _raycastPoint = new THREE.Vector3()
  * CPU raycast uses section AABB (geometry.boundingBox), not GPU-generated faces.
  * Enough for third-person camera collision; block pick uses mineflayer, not mesh raycast.
  */
-export function attachShaderCubeRaycast(
-  mesh: THREE.Mesh<THREE.BufferGeometry, THREE.Material>,
-): void {
+export function attachShaderCubeRaycast(mesh: THREE.Mesh<THREE.BufferGeometry, THREE.Material>): void {
   mesh.raycast = (raycaster, intersects) => {
     const { geometry } = mesh
     if (!geometry.boundingBox) return
@@ -70,14 +59,14 @@ export function attachShaderCubeRaycast(
     intersects.push({
       distance,
       point: _raycastPoint.clone(),
-      object: mesh,
+      object: mesh
     })
   }
 }
 
 export function createShaderCubeMesh(
   data: ShaderCubeInstanceData,
-  material: THREE.ShaderMaterial,
+  material: THREE.ShaderMaterial
 ): THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial> {
   const geometry = buildShaderCubeGeometry(data.words, data.count)
   const mesh = new THREE.Mesh(geometry, material)

package/src/three/shaders/cubeBlockShader.ts

@@ -1,10 +1,6 @@
 //@ts-nocheck
 import * as THREE from 'three'
-import {
-  APPLY_LIGHTMAP_GLSL,
-  DEFAULT_LIGHTMAP_PARAMS,
-  type BlockLightmapParams,
-} from '../../lib/blockEntityLighting'
+import { APPLY_LIGHTMAP_GLSL, DEFAULT_LIGHTMAP_PARAMS, type BlockLightmapParams } from '../../lib/blockEntityLighting'
 
 export type { BlockLightmapParams }
 
@@ -326,81 +322,74 @@ void main() {
 `
 
 export function createCubeBlockMaterial(): THREE.ShaderMaterial {
-    return new THREE.ShaderMaterial({
-        vertexShader,
-        fragmentShader,
-        // Merge UniformsLib.fog (fogColor/fogNear/fogFar/fogDensity) so Three.js's
-        // WebGLMaterials.refreshFogUniforms can keep them in sync with scene.fog each
-        // frame — only happens for materials with \`fog: true\` set below.
-        uniforms: THREE.UniformsUtils.merge([
-            THREE.UniformsLib.fog,
-            {
-                u_atlas: { value: null },
-                u_tintPalette: { value: null },
-                u_debugMode: { value: 0 },
-                u_skyLevel: { value: 1.0 },
-                u_shadingTheme: { value: 1.0 },
-                u_cardinalLight: { value: 0.0 },
-                u_lightCurve: { value: DEFAULT_LIGHTMAP_PARAMS.curve },
-                u_minBrightness: { value: DEFAULT_LIGHTMAP_PARAMS.minBrightness },
-                u_lightGamma: { value: DEFAULT_LIGHTMAP_PARAMS.gamma },
-                u_sectionOriginRel: { value: new THREE.Vector3(0, 0, 0) },
-                u_originDelta: { value: new THREE.Vector3() },
-                u_cameraOriginFrac: { value: new THREE.Vector3() },
-            },
-        ]),
-        // Opaque full cubes — WASM mesher already culls interior faces between
-        // solid neighbors, so no z-fighting between own faces. Keep NoBlending so
-        // the alpha=1 path writes pure pixels and depth.
-        transparent: false,
-        depthWrite: true,
-        depthTest: true,
-        blending: THREE.NoBlending,
-        glslVersion: THREE.GLSL3,
-        // Required for Three.js to inject \`#define USE_FOG\` (and refresh fog uniforms).
-        fog: true,
-    })
+  return new THREE.ShaderMaterial({
+    vertexShader,
+    fragmentShader,
+    // Merge UniformsLib.fog (fogColor/fogNear/fogFar/fogDensity) so Three.js's
+    // WebGLMaterials.refreshFogUniforms can keep them in sync with scene.fog each
+    // frame — only happens for materials with \`fog: true\` set below.
+    uniforms: THREE.UniformsUtils.merge([
+      THREE.UniformsLib.fog,
+      {
+        u_atlas: { value: null },
+        u_tintPalette: { value: null },
+        u_debugMode: { value: 0 },
+        u_skyLevel: { value: 1.0 },
+        u_shadingTheme: { value: 1.0 },
+        u_cardinalLight: { value: 0.0 },
+        u_lightCurve: { value: DEFAULT_LIGHTMAP_PARAMS.curve },
+        u_minBrightness: { value: DEFAULT_LIGHTMAP_PARAMS.minBrightness },
+        u_lightGamma: { value: DEFAULT_LIGHTMAP_PARAMS.gamma },
+        u_sectionOriginRel: { value: new THREE.Vector3(0, 0, 0) },
+        u_originDelta: { value: new THREE.Vector3() },
+        u_cameraOriginFrac: { value: new THREE.Vector3() }
+      }
+    ]),
+    // Opaque full cubes — WASM mesher already culls interior faces between
+    // solid neighbors, so no z-fighting between own faces. Keep NoBlending so
+    // the alpha=1 path writes pure pixels and depth.
+    transparent: false,
+    depthWrite: true,
+    depthTest: true,
+    blending: THREE.NoBlending,
+    glslVersion: THREE.GLSL3,
+    // Required for Three.js to inject \`#define USE_FOG\` (and refresh fog uniforms).
+    fog: true
+  })
 }
 
 // Three geometry constants: 6 vertices per face (2 triangles, un-indexed)
-export function setCubeSkyLevel (material: THREE.ShaderMaterial, value: number): void {
-    const u = material.uniforms.u_skyLevel
-    if (u) u.value = value
+export function setCubeSkyLevel(material: THREE.ShaderMaterial, value: number): void {
+  const u = material.uniforms.u_skyLevel
+  if (u) u.value = value
 }
 
-export function setCubeShadingTheme (
-  material: THREE.ShaderMaterial,
-  theme: 'vanilla' | 'high-contrast',
-  cardinalLight: string,
-): void {
+export function setCubeShadingTheme(material: THREE.ShaderMaterial, theme: 'vanilla' | 'high-contrast', cardinalLight: string): void {
   const t = material.uniforms.u_shadingTheme
   if (t) t.value = theme === 'high-contrast' ? 1.0 : 0.0
   const c = material.uniforms.u_cardinalLight
   if (c) c.value = cardinalLight === 'nether' ? 1.0 : 0.0
 }
 
-export function setCubeLightmapParams (
-    material: THREE.ShaderMaterial,
-    params: BlockLightmapParams,
-): void {
-    if (params.curve !== undefined) {
-        const u = material.uniforms.u_lightCurve
-        if (u) u.value = params.curve
-    }
-    if (params.minBrightness !== undefined) {
-        const u = material.uniforms.u_minBrightness
-        if (u) u.value = params.minBrightness
-    }
-    if (params.gamma !== undefined) {
-        const u = material.uniforms.u_lightGamma
-        if (u) u.value = params.gamma
-    }
+export function setCubeLightmapParams(material: THREE.ShaderMaterial, params: BlockLightmapParams): void {
+  if (params.curve !== undefined) {
+    const u = material.uniforms.u_lightCurve
+    if (u) u.value = params.curve
+  }
+  if (params.minBrightness !== undefined) {
+    const u = material.uniforms.u_minBrightness
+    if (u) u.value = params.minBrightness
+  }
+  if (params.gamma !== undefined) {
+    const u = material.uniforms.u_lightGamma
+    if (u) u.value = params.gamma
+  }
 }
 
 export const VERTICES_PER_FACE = 6
 
 /** Section index units for render origin R (R is always a multiple of 16). */
-export function computeSectionOriginRel (renderOrigin: { x: number, y: number, z: number }): {
+export function computeSectionOriginRel(renderOrigin: { x: number; y: number; z: number }): {
   x: number
   y: number
   z: number
@@ -408,51 +397,51 @@ export function computeSectionOriginRel (renderOrigin: { x: number, y: number, z
   return {
     x: Math.round(renderOrigin.x / 16),
     y: Math.round(renderOrigin.y / 16),
-    z: Math.round(renderOrigin.z / 16),
+    z: Math.round(renderOrigin.z / 16)
   }
 }
 
 // Word layout constants (for encoding/decoding instances)
 export const WORD0 = {
-    LX_BITS: 4,
-    LY_BITS: 4,
-    LZ_BITS: 4,
-    FACE_BITS: 3,
-    TINT_BITS: 8,
-    AO_BITS_PER_CORNER: 2,
-    NUM_CORNERS: 4,
-    // Bit offsets
-    LX_SHIFT: 0,
-    LY_SHIFT: 4,
-    LZ_SHIFT: 8,
-    FACE_SHIFT: 12,
-    TINT_SHIFT: 15,
-    AO_SHIFT: 23,
-    TRANSPARENT_SHIFT: 31,
+  LX_BITS: 4,
+  LY_BITS: 4,
+  LZ_BITS: 4,
+  FACE_BITS: 3,
+  TINT_BITS: 8,
+  AO_BITS_PER_CORNER: 2,
+  NUM_CORNERS: 4,
+  // Bit offsets
+  LX_SHIFT: 0,
+  LY_SHIFT: 4,
+  LZ_SHIFT: 8,
+  FACE_SHIFT: 12,
+  TINT_SHIFT: 15,
+  AO_SHIFT: 23,
+  TRANSPARENT_SHIFT: 31
 } as const
 
 export const WORD1 = {
-    LIGHT_BITS_PER_CORNER: 8,
-    NUM_CORNERS: 4,
+  LIGHT_BITS_PER_CORNER: 8,
+  NUM_CORNERS: 4
 } as const
 
 export const WORD2 = {
-    TEX_INDEX_BITS: 12,
-    DIAGONAL_FLAG_SHIFT: 12,
-    SECTION_Y_SHIFT: 13,
-    SECTION_Y_BITS: 5,
-    EMPTY_SHIFT: 18,
-    SECTION_X_HI_SHIFT: 19,
-    SECTION_Z_HI_SHIFT: 25,
-    SECTION_HI_BITS: 6,
-    SPARE_BITS: 1,
+  TEX_INDEX_BITS: 12,
+  DIAGONAL_FLAG_SHIFT: 12,
+  SECTION_Y_SHIFT: 13,
+  SECTION_Y_BITS: 5,
+  EMPTY_SHIFT: 18,
+  SECTION_X_HI_SHIFT: 19,
+  SECTION_Z_HI_SHIFT: 25,
+  SECTION_HI_BITS: 6,
+  SPARE_BITS: 1
 } as const
 
 /** Section base X/Z: low 16 bits in a_w3, high 6 in a_w2 (22-bit biased section index). */
 export const WORD3 = {
-    SECTION_BITS: 22,
-    SECTION_MASK: (1 << 22) - 1,
-    LO_BITS: 16,
-    HI_BITS: 6,
-    SECTION_BIAS: 2097152,
+  SECTION_BITS: 22,
+  SECTION_MASK: (1 << 22) - 1,
+  LO_BITS: 16,
+  HI_BITS: 6,
+  SECTION_BIAS: 2097152
 } as const