minecraft-renderer 0.1.78 → 0.1.80

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)
+  }
 }