minecraft-renderer 0.1.79 → 0.1.81

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

package/src/three/shaders/legacyBlockShader.ts

@@ -1,19 +1,15 @@
 //@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 RenderOrigin = { x: number, y: number, z: number }
+export type RenderOrigin = { x: number; y: number; z: number }
 
-export function computeCameraRelativeUniforms (
+export function computeCameraRelativeUniforms(
   renderOrigin: RenderOrigin,
   x: number,
   y: number,
-  z: number,
-): { originDelta: RenderOrigin, cameraOriginFrac: RenderOrigin } {
+  z: number
+): { originDelta: RenderOrigin; cameraOriginFrac: RenderOrigin } {
   const ix = Math.floor(x)
   const iy = Math.floor(y)
   const iz = Math.floor(z)
@@ -21,13 +17,13 @@ export function computeCameraRelativeUniforms (
     originDelta: {
       x: renderOrigin.x - ix,
       y: renderOrigin.y - iy,
-      z: renderOrigin.z - iz,
+      z: renderOrigin.z - iz
     },
     cameraOriginFrac: {
       x: x - ix,
       y: y - iy,
-      z: z - iz,
-    },
+      z: z - iz
+    }
   }
 }
 
@@ -193,70 +189,55 @@ const legacyUniforms = {
   u_skyLevel: { value: 1.0 },
   u_lightCurve: { value: DEFAULT_LIGHTMAP_PARAMS.curve },
   u_minBrightness: { value: DEFAULT_LIGHTMAP_PARAMS.minBrightness },
-  u_lightGamma: { value: DEFAULT_LIGHTMAP_PARAMS.gamma },
+  u_lightGamma: { value: DEFAULT_LIGHTMAP_PARAMS.gamma }
 }
 
-export function createLegacyBlockMaterial (): THREE.ShaderMaterial {
+export function createLegacyBlockMaterial(): THREE.ShaderMaterial {
   return new THREE.ShaderMaterial({
     vertexShader,
     fragmentShader,
-    uniforms: THREE.UniformsUtils.merge([
-      THREE.UniformsLib.fog,
-      legacyUniforms,
-    ]),
+    uniforms: THREE.UniformsUtils.merge([THREE.UniformsLib.fog, legacyUniforms]),
     transparent: true,
     depthWrite: true,
     depthTest: true,
     vertexColors: true,
     glslVersion: THREE.GLSL3,
-    fog: true,
+    fog: true
   })
 }
 
 /** Global opaque legacy buffer — per-vertex section origin via a_origin. */
-export function createGlobalLegacyBlockMaterial (): THREE.ShaderMaterial {
+export function createGlobalLegacyBlockMaterial(): THREE.ShaderMaterial {
   return new THREE.ShaderMaterial({
     vertexShader: globalVertexShader,
     fragmentShader,
-    uniforms: THREE.UniformsUtils.merge([
-      THREE.UniformsLib.fog,
-      legacyUniforms,
-    ]),
+    uniforms: THREE.UniformsUtils.merge([THREE.UniformsLib.fog, legacyUniforms]),
     transparent: false,
     depthWrite: true,
     depthTest: true,
     vertexColors: true,
     glslVersion: THREE.GLSL3,
-    fog: true,
+    fog: true
   })
 }
 
 /** Global transparent blend buffer — same shaders as opaque global, blend material flags. */
-export function createGlobalLegacyBlendMaterial (): THREE.ShaderMaterial {
+export function createGlobalLegacyBlendMaterial(): THREE.ShaderMaterial {
   return new THREE.ShaderMaterial({
     vertexShader: globalVertexShader,
     fragmentShader,
-    uniforms: THREE.UniformsUtils.merge([
-      THREE.UniformsLib.fog,
-      legacyUniforms,
-    ]),
+    uniforms: THREE.UniformsUtils.merge([THREE.UniformsLib.fog, legacyUniforms]),
     transparent: true,
     depthWrite: true,
     depthTest: true,
     vertexColors: true,
     glslVersion: THREE.GLSL3,
-    fog: true,
+    fog: true
   })
 }
 
 /** Render-origin + fractional camera split — matches GlobalBlockBuffer.setCameraOrigin. */
-export function setLegacyCameraOrigin (
-  material: THREE.ShaderMaterial,
-  renderOrigin: RenderOrigin,
-  x: number,
-  y: number,
-  z: number,
-): void {
+export function setLegacyCameraOrigin(material: THREE.ShaderMaterial, renderOrigin: RenderOrigin, x: number, y: number, z: number): void {
   const { originDelta, cameraOriginFrac } = computeCameraRelativeUniforms(renderOrigin, x, y, z)
   const u = material.uniforms.u_originDelta
   if (u?.value?.set) {
@@ -268,15 +249,12 @@ export function setLegacyCameraOrigin (
   }
 }
 
-export function setLegacySkyLevel (material: THREE.ShaderMaterial, value: number): void {
+export function setLegacySkyLevel(material: THREE.ShaderMaterial, value: number): void {
   const u = material.uniforms.u_skyLevel
   if (u) u.value = value
 }
 
-export function setLegacyLightmapParams (
-  material: THREE.ShaderMaterial,
-  params: BlockLightmapParams,
-): void {
+export function setLegacyLightmapParams(material: THREE.ShaderMaterial, params: BlockLightmapParams): void {
   if (params.curve !== undefined) {
     const u = material.uniforms.u_lightCurve
     if (u) u.value = params.curve

package/src/three/shaders/textureIndexMapping.ts

@@ -10,113 +10,107 @@
 
 // WorldBlockProvider interface (subset used by this module)
 export interface TextureAtlasInfo {
-    /** Atlas width in pixels (must be 1024) */
-    width: number
-    /** Atlas height in pixels (must be 1024) */
-    height: number
-    /** Tile size in pixels (must be 16) */
-    tileSize: number
-    /** Resolution scale (suSv = tileSize * resolution) */
-    suSv: number
-    /** Texture name → atlas position */
-    textures: Record<string, TextureEntry>
+  /** Atlas width in pixels (must be 1024) */
+  width: number
+  /** Atlas height in pixels (must be 1024) */
+  height: number
+  /** Tile size in pixels (must be 16) */
+  tileSize: number
+  /** Resolution scale (suSv = tileSize * resolution) */
+  suSv: number
+  /** Texture name → atlas position */
+  textures: Record<string, TextureEntry>
 }
 
 export interface TextureEntry {
-    /** Horizontal pixel offset within atlas */
-    u: number
-    /** Vertical pixel offset within atlas */
-    v: number
-    /** Horizontal pixel count (typically 16 or suSv) */
-    su: number
-    /** Vertical pixel count (typically 16 or suSv) */
-    sv: number
+  /** Horizontal pixel offset within atlas */
+  u: number
+  /** Vertical pixel offset within atlas */
+  v: number
+  /** Horizontal pixel count (typically 16 or suSv) */
+  su: number
+  /** Vertical pixel count (typically 16 or suSv) */
+  sv: number
 }
 
 export class TextureIndexMapping {
-    private atlasWidth: number
-    private atlasHeight: number
-    private tileSize: number
-    private tilesPerRow: number
-    private maxTiles: number
-    private valid: boolean
+  private atlasWidth: number
+  private atlasHeight: number
+  private tileSize: number
+  private tilesPerRow: number
+  private maxTiles: number
+  private valid: boolean
 
-    constructor(atlasInfo: TextureAtlasInfo) {
-        this.atlasWidth = atlasInfo.width
-        this.atlasHeight = atlasInfo.height
-        this.tileSize = atlasInfo.tileSize
-        this.tilesPerRow = Math.floor(this.atlasWidth / this.tileSize)
-        this.maxTiles = this.tilesPerRow * Math.floor(this.atlasHeight / this.tileSize)
+  constructor(atlasInfo: TextureAtlasInfo) {
+    this.atlasWidth = atlasInfo.width
+    this.atlasHeight = atlasInfo.height
+    this.tileSize = atlasInfo.tileSize
+    this.tilesPerRow = Math.floor(this.atlasWidth / this.tileSize)
+    this.maxTiles = this.tilesPerRow * Math.floor(this.atlasHeight / this.tileSize)
 
-        // Only valid when atlas matches the shader's hardcoded layout (1024×1024, 16×16 tiles).
-        this.valid = this.atlasWidth === 1024
-            && this.atlasHeight === 1024
-            && this.tileSize === 16
-            && this.maxTiles <= 4096 // 12-bit limit
-    }
+    // Only valid when atlas matches the shader's hardcoded layout (1024×1024, 16×16 tiles).
+    this.valid = this.atlasWidth === 1024 && this.atlasHeight === 1024 && this.tileSize === 16 && this.maxTiles <= 4096 // 12-bit limit
+  }
 
-    /** True when 12-bit texIndex encoding is safe (atlas matches the shader's layout). */
-    isValid(): boolean {
-        return this.valid
-    }
+  /** True when 12-bit texIndex encoding is safe (atlas matches the shader's layout). */
+  isValid(): boolean {
+    return this.valid
+  }
 
-    /** Tiles per row in the atlas */
-    getTilesPerRow(): number {
-        return this.tilesPerRow
-    }
+  /** Tiles per row in the atlas */
+  getTilesPerRow(): number {
+    return this.tilesPerRow
+  }
 
-    /**
-     * Compute absolute tile index from atlas pixel position.
-     * Returns -1 if the position is out of range or gate fails.
-     */
-    tileIndexFromPixelCoords(u: number, v: number): number {
-        if (!this.valid) return -1
-        const tileCol = Math.floor(u / this.tileSize)
-        const tileRow = Math.floor(v / this.tileSize)
-        if (tileCol < 0 || tileCol >= this.tilesPerRow || tileRow < 0) return -1
-        const index = tileRow * this.tilesPerRow + tileCol
-        if (index >= this.maxTiles) return -1
-        return index
-    }
+  /**
+   * Compute absolute tile index from atlas pixel position.
+   * Returns -1 if the position is out of range or gate fails.
+   */
+  tileIndexFromPixelCoords(u: number, v: number): number {
+    if (!this.valid) return -1
+    const tileCol = Math.floor(u / this.tileSize)
+    const tileRow = Math.floor(v / this.tileSize)
+    if (tileCol < 0 || tileCol >= this.tilesPerRow || tileRow < 0) return -1
+    const index = tileRow * this.tilesPerRow + tileCol
+    if (index >= this.maxTiles) return -1
+    return index
+  }
 
-    /**
-     * Get tile index for a texture entry from the atlas.
-     * Returns -1 if the texture spans multiple tiles or gate fails.
-     */
-    tileIndexFromTextureEntry(entry: TextureEntry): number {
-        if (!this.valid) return -1
-        // Verify the texture occupies exactly one tile
-        if (entry.su !== this.tileSize || entry.sv !== this.tileSize) return -1
-        return this.tileIndexFromPixelCoords(entry.u, entry.v)
-    }
+  /**
+   * Get tile index for a texture entry from the atlas.
+   * Returns -1 if the texture spans multiple tiles or gate fails.
+   */
+  tileIndexFromTextureEntry(entry: TextureEntry): number {
+    if (!this.valid) return -1
+    // Verify the texture occupies exactly one tile
+    if (entry.su !== this.tileSize || entry.sv !== this.tileSize) return -1
+    return this.tileIndexFromPixelCoords(entry.u, entry.v)
+  }
 
-    /**
-     * Look up tile index by texture name.
-     * Returns -1 if the texture is not found, spans multiple tiles, or gate fails.
-     */
-    tileIndexFromTextureName(
-        textureName: string,
-        atlasInfo: TextureAtlasInfo,
-    ): number {
-        if (!this.valid) return -1
-        // Try exact name, then strip namespace prefix
-        let entry = atlasInfo.textures[textureName]
-        if (!entry && textureName.includes(':')) {
-            entry = atlasInfo.textures[textureName.split(':')[1]]
-        }
-        if (!entry && textureName.includes('/')) {
-            entry = atlasInfo.textures[textureName.split('/')[1]]
-        }
-        if (!entry) {
-            // Try 'block/' prefix
-            entry = atlasInfo.textures[`block/${textureName}`]
-        }
-        if (!entry) {
-            // Try without 'block/' prefix
-            const stripped = textureName.replace(/^block\//, '')
-            entry = atlasInfo.textures[stripped]
-        }
-        if (!entry) return -1
-        return this.tileIndexFromTextureEntry(entry)
+  /**
+   * Look up tile index by texture name.
+   * Returns -1 if the texture is not found, spans multiple tiles, or gate fails.
+   */
+  tileIndexFromTextureName(textureName: string, atlasInfo: TextureAtlasInfo): number {
+    if (!this.valid) return -1
+    // Try exact name, then strip namespace prefix
+    let entry = atlasInfo.textures[textureName]
+    if (!entry && textureName.includes(':')) {
+      entry = atlasInfo.textures[textureName.split(':')[1]]
+    }
+    if (!entry && textureName.includes('/')) {
+      entry = atlasInfo.textures[textureName.split('/')[1]]
+    }
+    if (!entry) {
+      // Try 'block/' prefix
+      entry = atlasInfo.textures[`block/${textureName}`]
+    }
+    if (!entry) {
+      // Try without 'block/' prefix
+      const stripped = textureName.replace(/^block\//, '')
+      entry = atlasInfo.textures[stripped]
     }
+    if (!entry) return -1
+    return this.tileIndexFromTextureEntry(entry)
+  }
 }