minecraft-renderer 0.1.79 → 0.1.80

package/src/lib/blockEntityLighting.ts

@@ -12,7 +12,7 @@ export type BlockLightmapParams = {
 export const DEFAULT_LIGHTMAP_PARAMS: Required<BlockLightmapParams> = {
   curve: 0,
   minBrightness: 0.12,
-  gamma: 1,
+  gamma: 1
 }
 
 /** GLSL body for applyLightmap — requires u_lightCurve, u_minBrightness, u_lightGamma uniforms. */
@@ -25,7 +25,7 @@ float applyLightmap(float L) {
 }
 `
 
-export function applyLightmap (L: number, params: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS): number {
+export function applyLightmap(L: number, params: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS): number {
   const curve = params.curve ?? DEFAULT_LIGHTMAP_PARAMS.curve
   const minBrightness = params.minBrightness ?? DEFAULT_LIGHTMAP_PARAMS.minBrightness
   const gamma = params.gamma ?? DEFAULT_LIGHTMAP_PARAMS.gamma
@@ -37,16 +37,16 @@ export function applyLightmap (L: number, params: BlockLightmapParams = DEFAULT_
 }
 
 /** Same cap as block shaders: max(block, min(sky, skyLevel)). */
-export function combinedBlockLight (block: number, sky: number, skyLevel: number): number {
+export function combinedBlockLight(block: number, sky: number, skyLevel: number): number {
   return Math.max(block, Math.min(sky, skyLevel))
 }
 
 /** 0..1 brightness for MeshBasicMaterial.color.setScalar on block-entity overlays. */
-export function blockEntityBrightness (
+export function blockEntityBrightness(
   blockNorm: number,
   skyNorm: number,
   skyLevel: number,
-  lightmapParams: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS,
+  lightmapParams: BlockLightmapParams = DEFAULT_LIGHTMAP_PARAMS
 ): number {
   const L = combinedBlockLight(blockNorm, skyNorm, skyLevel)
   return applyLightmap(L, lightmapParams)

package/src/lib/buildSharedConfig.mjs

@@ -1,6 +1,6 @@
 export const dynamicMcDataFiles = {
-    'blocks': 'blocksArray',
-    'blockCollisionShapes': 'blockCollisionShapes',
-    'biomes': 'biomesArray',
-    'tints': 'tints',
+  blocks: 'blocksArray',
+  blockCollisionShapes: 'blockCollisionShapes',
+  biomes: 'biomesArray',
+  tints: 'tints'
 }

package/src/lib/buildWorkerMcDataIndexes.test.ts

@@ -6,7 +6,7 @@ describe('augmentWorkerMcData', () => {
   it('is idempotent when mcData is augmented twice (menu then world)', () => {
     const mcData: Record<string, unknown> = {
       entities: [{ name: 'bat', id: 1, type: 'mob' }],
-      blocks: [{ name: 'stone', id: 3, minStateId: 48, maxStateId: 63, defaultState: 48 }],
+      blocks: [{ name: 'stone', id: 3, minStateId: 48, maxStateId: 63, defaultState: 48 }]
     }
     augmentWorkerMcData(mcData)
     expect(() => augmentWorkerMcData(mcData)).not.toThrow()
@@ -16,7 +16,7 @@ describe('augmentWorkerMcData', () => {
 
   it('keeps *Array sources after indexing (esbuild mc-data plugin reads blocksArray)', () => {
     const mcData: Record<string, unknown> = {
-      blocks: [{ name: 'stone', id: 3, minStateId: 48, maxStateId: 63, defaultState: 48 }],
+      blocks: [{ name: 'stone', id: 3, minStateId: 48, maxStateId: 63, defaultState: 48 }]
     }
     augmentWorkerMcData(mcData)
     expect(Array.isArray(mcData.blocksArray)).toBe(true)
@@ -26,7 +26,7 @@ describe('augmentWorkerMcData', () => {
 
   it('coerces valtio-style dense objects into arrays', () => {
     const mcData: Record<string, unknown> = {
-      entities: { 0: { name: 'bat', id: 1, type: 'mob' } },
+      entities: { 0: { name: 'bat', id: 1, type: 'mob' } }
     }
     augmentWorkerMcData(mcData)
     expect((mcData.entitiesByName as Record<string, { name: string }>).bat?.name).toBe('bat')
@@ -36,7 +36,7 @@ describe('augmentWorkerMcData', () => {
     const mcData: Record<string, unknown> = {
       entities: [{ name: 'bat', id: 1, type: 'mob' }],
       items: [{ name: 'dirt', id: 2 }],
-      blocks: [{ name: 'stone', id: 3, minStateId: 48, maxStateId: 63, defaultState: 48 }],
+      blocks: [{ name: 'stone', id: 3, minStateId: 48, maxStateId: 63, defaultState: 48 }]
     }
     augmentWorkerMcData(mcData)
     expect((mcData.entitiesByName as Record<string, { name: string }>).bat?.name).toBe('bat')

package/src/lib/buildWorkerMcDataIndexes.ts

@@ -1,7 +1,7 @@
 //@ts-nocheck
 type McElement = Record<string, unknown>
 
-function coerceDenseArray (value: unknown): McElement[] | undefined {
+function coerceDenseArray(value: unknown): McElement[] | undefined {
   if (Array.isArray(value)) {
     return value as McElement[]
   }
@@ -9,7 +9,10 @@ function coerceDenseArray (value: unknown): McElement[] | undefined {
     return undefined
   }
   const record = value as Record<string, McElement>
-  const keys = Object.keys(record).filter((k) => /^\d+$/.test(k)).map(Number).sort((a, b) => a - b)
+  const keys = Object.keys(record)
+    .filter(k => /^\d+$/.test(k))
+    .map(Number)
+    .sort((a, b) => a - b)
   if (!keys.length || keys[0] !== 0) {
     return undefined
   }
@@ -18,13 +21,10 @@ function coerceDenseArray (value: unknown): McElement[] | undefined {
       return undefined
     }
   }
-  return keys.map((k) => record[String(k)])
+  return keys.map(k => record[String(k)])
 }
 
-function buildIndexFromArray<T extends McElement> (
-  array: T[],
-  field: keyof T
-): Record<string | number, T> {
+function buildIndexFromArray<T extends McElement>(array: T[], field: keyof T): Record<string | number, T> {
   if (!Array.isArray(array)) {
     console.warn('[augmentWorkerMcData] buildIndexFromArray expected array, got', typeof array)
     return {}
@@ -35,11 +35,7 @@ function buildIndexFromArray<T extends McElement> (
   }, {})
 }
 
-function buildIndexFromArrayWithRanges<T extends McElement> (
-  array: T[],
-  minField: keyof T,
-  maxField: keyof T
-): Record<number, T> {
+function buildIndexFromArrayWithRanges<T extends McElement>(array: T[], minField: keyof T, maxField: keyof T): Record<number, T> {
   if (!Array.isArray(array)) {
     console.warn('[augmentWorkerMcData] buildIndexFromArrayWithRanges expected array, got', typeof array)
     return {}
@@ -54,7 +50,7 @@ function buildIndexFromArrayWithRanges<T extends McElement> (
   }, {})
 }
 
-function ensureBlockStateIds (blocks: McElement[]) {
+function ensureBlockStateIds(blocks: McElement[]) {
   if (!blocks.length) return
   if ('minStateId' in blocks[0] && 'defaultState' in blocks[0]) return
   for (const block of blocks) {
@@ -65,11 +61,7 @@ function ensureBlockStateIds (blocks: McElement[]) {
   }
 }
 
-function getSourceArray (
-  mcData: Record<string, unknown>,
-  arrayKey: string,
-  rawKey: string
-): McElement[] | undefined {
+function getSourceArray(mcData: Record<string, unknown>, arrayKey: string, rawKey: string): McElement[] | undefined {
   const fromArrayKey = coerceDenseArray(mcData[arrayKey])
   if (fromArrayKey?.length) {
     return fromArrayKey
@@ -81,7 +73,7 @@ function getSourceArray (
   return undefined
 }
 
-export function augmentWorkerMcData (mcData: Record<string, unknown>) {
+export function augmentWorkerMcData(mcData: Record<string, unknown>) {
   if (mcData.__workerIndexesBuilt) {
     return mcData
   }

package/src/lib/cameraBobbing.ts

@@ -14,7 +14,7 @@ export interface CameraBobInput {
 
 const DEG_TO_RAD = Math.PI / 180
 
-export function computeCameraBob (input: CameraBobInput): CameraBobResult {
+export function computeCameraBob(input: CameraBobInput): CameraBobResult {
   const { walkDist, prevWalkDist, bob, prevBob, partialTick } = input
 
   // Vanilla uses "backwards interpolation": -(walkDist + delta * partialTick)

package/src/lib/canvas2DOverlay.example.ts

@@ -15,7 +15,7 @@ export function example1_SimpleBlackBox(documentRenderer: DocumentRenderer) {
   const overlay = new Canvas2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
 
   // Register to render overlay after main scene
-  documentRenderer.onRender.push((sizeChanged) => {
+  documentRenderer.onRender.push(sizeChanged => {
     if (sizeChanged) {
       overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
@@ -46,7 +46,7 @@ export function example2_FPSCounter(documentRenderer: DocumentRenderer) {
   let lastTime = performance.now()
   let frameCount = 0
 
-  documentRenderer.onRender.push((sizeChanged) => {
+  documentRenderer.onRender.push(sizeChanged => {
     if (sizeChanged) {
       overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
@@ -82,13 +82,10 @@ export function example2_FPSCounter(documentRenderer: DocumentRenderer) {
 // ============================================
 // EXAMPLE 3: Coordinate Display (Bottom-Left)
 // ============================================
-export function example3_CoordinateDisplay(
-  documentRenderer: DocumentRenderer,
-  getPosition: () => { x: number; y: number; z: number }
-) {
+export function example3_CoordinateDisplay(documentRenderer: DocumentRenderer, getPosition: () => { x: number; y: number; z: number }) {
   const overlay = new Canvas2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
 
-  documentRenderer.onRender.push((sizeChanged) => {
+  documentRenderer.onRender.push(sizeChanged => {
     if (sizeChanged) {
       overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
@@ -130,13 +127,10 @@ export function example3_CoordinateDisplay(
 // ============================================
 // EXAMPLE 4: Mini-map (Top-Right Corner)
 // ============================================
-export function example4_MiniMap(
-  documentRenderer: DocumentRenderer,
-  playerPos: { x: number; z: number }
-) {
+export function example4_MiniMap(documentRenderer: DocumentRenderer, playerPos: { x: number; z: number }) {
   const overlay = new Canvas2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
 
-  documentRenderer.onRender.push((sizeChanged) => {
+  documentRenderer.onRender.push(sizeChanged => {
     if (sizeChanged) {
       overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
@@ -197,13 +191,10 @@ export function example5_DirectWebGL(documentRenderer: DocumentRenderer) {
 // ============================================
 // EXAMPLE 6: Health/Status Bar
 // ============================================
-export function example6_HealthBar(
-  documentRenderer: DocumentRenderer,
-  getHealth: () => { current: number; max: number }
-) {
+export function example6_HealthBar(documentRenderer: DocumentRenderer, getHealth: () => { current: number; max: number }) {
   const overlay = new Canvas2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
 
-  documentRenderer.onRender.push((sizeChanged) => {
+  documentRenderer.onRender.push(sizeChanged => {
     if (sizeChanged) {
       overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
@@ -249,7 +240,7 @@ export function example6_HealthBar(
 export function example7_DebugGrid(documentRenderer: DocumentRenderer) {
   const overlay = new Canvas2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
 
-  documentRenderer.onRender.push((sizeChanged) => {
+  documentRenderer.onRender.push(sizeChanged => {
     if (sizeChanged) {
       overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
@@ -262,10 +253,7 @@ export function example7_DebugGrid(documentRenderer: DocumentRenderer) {
 
     // Draw vertical lines
     for (let x = 0; x < width; x += gridSize) {
-      const points = [
-        new THREE.Vector3(x, 0, 0),
-        new THREE.Vector3(x, height, 0)
-      ]
+      const points = [new THREE.Vector3(x, 0, 0), new THREE.Vector3(x, height, 0)]
       const geometry = new THREE.BufferGeometry().setFromPoints(points)
       const material = new THREE.LineBasicMaterial({ color: 0x333333, opacity: 0.3, transparent: true })
       const line = new THREE.Line(geometry, material)
@@ -275,10 +263,7 @@ export function example7_DebugGrid(documentRenderer: DocumentRenderer) {
 
     // Draw horizontal lines
     for (let y = 0; y < height; y += gridSize) {
-      const points = [
-        new THREE.Vector3(0, y, 0),
-        new THREE.Vector3(width, y, 0)
-      ]
+      const points = [new THREE.Vector3(0, y, 0), new THREE.Vector3(width, y, 0)]
       const geometry = new THREE.BufferGeometry().setFromPoints(points)
       const material = new THREE.LineBasicMaterial({ color: 0x333333, opacity: 0.3, transparent: true })
       const line = new THREE.Line(geometry, material)
@@ -301,7 +286,7 @@ export function integrateWithDocumentRenderer(documentRenderer: DocumentRenderer
 
   // Add to render loop
   const originalRender = documentRenderer.render
-  documentRenderer.render = (sizeChanged) => {
+  documentRenderer.render = sizeChanged => {
     // Call original render
     originalRender.call(documentRenderer, sizeChanged)
 
@@ -333,7 +318,7 @@ export function workerCompatibleOverlay(documentRenderer: DocumentRenderer) {
   // This works the same in both main thread and worker!
   const overlay = new Canvas2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
 
-  documentRenderer.onRender.push((sizeChanged) => {
+  documentRenderer.onRender.push(sizeChanged => {
     if (sizeChanged) {
       overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
@@ -355,8 +340,3 @@ export function workerCompatibleOverlay(documentRenderer: DocumentRenderer) {
 
   return overlay
 }
-
-
-
-
-

package/src/lib/canvas2DOverlay.quickstart.ts

@@ -13,21 +13,15 @@ import { Canvas2DOverlay } from './canvas2DOverlay'
 // STEP 1: Create the overlay
 // ============================================
 export function addBlackBoxOverlay(documentRenderer: DocumentRenderer) {
-  const overlay = new Canvas2DOverlay(
-    documentRenderer.renderer,
-    documentRenderer.canvas
-  )
+  const overlay = new Canvas2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
 
   // ============================================
   // STEP 2: Hook into the render loop
   // ============================================
-  documentRenderer.onRender.push((sizeChanged) => {
+  documentRenderer.onRender.push(sizeChanged => {
     // Update overlay camera when canvas size changes
     if (sizeChanged) {
-      overlay.updateSize(
-        documentRenderer.canvas.width,
-        documentRenderer.canvas.height
-      )
+      overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
 
     // Clear previous frame's overlay
@@ -43,12 +37,12 @@ export function addBlackBoxOverlay(documentRenderer: DocumentRenderer) {
     const y = documentRenderer.canvas.height - boxSize - 10 // 10px from bottom
 
     overlay.drawRect(
-      x,        // x position
-      y,        // y position
-      boxSize,  // width
-      boxSize,  // height
+      x, // x position
+      y, // y position
+      boxSize, // width
+      boxSize, // height
       0x000000, // color (black)
-      0.8       // opacity (80%)
+      0.8 // opacity (80%)
     )
 
     // ============================================
@@ -82,12 +76,9 @@ const overlay = addBlackBoxOverlay(documentRenderer)
 // Add More Elements
 // ============================================
 export function addMultipleElements(documentRenderer: DocumentRenderer) {
-  const overlay = new Canvas2DOverlay(
-    documentRenderer.renderer,
-    documentRenderer.canvas
-  )
+  const overlay = new Canvas2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
 
-  documentRenderer.onRender.push((sizeChanged) => {
+  documentRenderer.onRender.push(sizeChanged => {
     if (sizeChanged) {
       overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
@@ -96,14 +87,7 @@ export function addMultipleElements(documentRenderer: DocumentRenderer) {
 
     // Bottom-left black box
     const boxSize = 100
-    overlay.drawRect(
-      10,
-      documentRenderer.canvas.height - boxSize - 10,
-      boxSize,
-      boxSize,
-      0x000000,
-      0.8
-    )
+    overlay.drawRect(10, documentRenderer.canvas.height - boxSize - 10, boxSize, boxSize, 0x000000, 0.8)
 
     // Add label inside the box
     overlay.drawText('Info', 15, documentRenderer.canvas.height - boxSize, {
@@ -144,16 +128,10 @@ export function addMultipleElements(documentRenderer: DocumentRenderer) {
 // ============================================
 // Dynamic Data Example
 // ============================================
-export function addDynamicOverlay(
-  documentRenderer: DocumentRenderer,
-  getData: () => { fps: number; x: number; y: number; z: number }
-) {
-  const overlay = new Canvas2DOverlay(
-    documentRenderer.renderer,
-    documentRenderer.canvas
-  )
-
-  documentRenderer.onRender.push((sizeChanged) => {
+export function addDynamicOverlay(documentRenderer: DocumentRenderer, getData: () => { fps: number; x: number; y: number; z: number }) {
+  const overlay = new Canvas2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
+
+  documentRenderer.onRender.push(sizeChanged => {
     if (sizeChanged) {
       overlay.updateSize(documentRenderer.canvas.width, documentRenderer.canvas.height)
     }
@@ -208,10 +186,7 @@ export function addDynamicOverlay(
 import { WebGLDirect2DOverlay } from './canvas2DOverlay'
 
 export function addHighPerformanceOverlay(documentRenderer: DocumentRenderer) {
-  const overlay = new WebGLDirect2DOverlay(
-    documentRenderer.renderer,
-    documentRenderer.canvas
-  )
+  const overlay = new WebGLDirect2DOverlay(documentRenderer.renderer, documentRenderer.canvas)
 
   documentRenderer.onRender.push(() => {
     // Direct WebGL rendering - very fast!
@@ -223,21 +198,16 @@ export function addHighPerformanceOverlay(documentRenderer: DocumentRenderer) {
     const y = documentRenderer.canvas.height - boxSize - 10
 
     overlay.drawRect(
-      x,        // x
-      y,        // y
-      boxSize,  // width
-      boxSize,  // height
-      0,        // red (0-1)
-      0,        // green (0-1)
-      0,        // blue (0-1)
-      0.8       // alpha (0-1)
+      x, // x
+      y, // y
+      boxSize, // width
+      boxSize, // height
+      0, // red (0-1)
+      0, // green (0-1)
+      0, // blue (0-1)
+      0.8 // alpha (0-1)
     )
   })
 
   return overlay
 }
-
-
-
-
-

package/src/lib/canvas2DOverlay.ts

@@ -123,22 +123,20 @@ export class Canvas2DOverlay {
   /**
    * Draw text using canvas texture (works in worker with OffscreenCanvas)
    */
-  drawText(text: string, x: number, y: number, options: {
-    fontSize?: number
-    fontFamily?: string
-    color?: string
-    backgroundColor?: string
-    padding?: number
-    opacity?: number
-  } = {}) {
-    const {
-      fontSize = 16,
-      fontFamily = 'Arial',
-      color = '#ffffff',
-      backgroundColor = '#000000',
-      padding = 4,
-      opacity = 1
-    } = options
+  drawText(
+    text: string,
+    x: number,
+    y: number,
+    options: {
+      fontSize?: number
+      fontFamily?: string
+      color?: string
+      backgroundColor?: string
+      padding?: number
+      opacity?: number
+    } = {}
+  ) {
+    const { fontSize = 16, fontFamily = 'Arial', color = '#ffffff', backgroundColor = '#000000', padding = 4, opacity = 1 } = options
 
     // Create a temporary canvas for text rendering
     // OffscreenCanvas works in workers!
@@ -178,11 +176,7 @@ export class Canvas2DOverlay {
     const geometry = new THREE.PlaneGeometry(textCanvas.width, textCanvas.height)
     const mesh = new THREE.Mesh(geometry, material)
 
-    mesh.position.set(
-      x + textCanvas.width / 2,
-      y + textCanvas.height / 2,
-      0
-    )
+    mesh.position.set(x + textCanvas.width / 2, y + textCanvas.height / 2, 0)
 
     this.overlayScene.add(mesh)
     this.overlayObjects.push(mesh)
@@ -252,7 +246,9 @@ export class WebGLDirect2DOverlay {
     this.gl = this.renderer.getContext()
 
     // Create shader program for 2D rendering
-    const vertexShader = this.createShader(this.gl.VERTEX_SHADER, `
+    const vertexShader = this.createShader(
+      this.gl.VERTEX_SHADER,
+      `
       attribute vec2 position;
       attribute vec4 color;
       varying vec4 vColor;
@@ -264,16 +260,20 @@ export class WebGLDirect2DOverlay {
         gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);
         vColor = color;
       }
-    `)
+    `
+    )
 
-    const fragmentShader = this.createShader(this.gl.FRAGMENT_SHADER, `
+    const fragmentShader = this.createShader(
+      this.gl.FRAGMENT_SHADER,
+      `
       precision mediump float;
       varying vec4 vColor;
 
       void main() {
         gl_FragColor = vColor;
       }
-    `)
+    `
+    )
 
     this.program = this.createProgram(vertexShader, fragmentShader)
 
@@ -318,23 +318,9 @@ export class WebGLDirect2DOverlay {
     const x2 = x + width
     const y2 = y + height
 
-    const positions = new Float32Array([
-      x1, y1,
-      x2, y1,
-      x1, y2,
-      x1, y2,
-      x2, y1,
-      x2, y2
-    ])
-
-    const colors = new Float32Array([
-      r, g, b, a,
-      r, g, b, a,
-      r, g, b, a,
-      r, g, b, a,
-      r, g, b, a,
-      r, g, b, a
-    ])
+    const positions = new Float32Array([x1, y1, x2, y1, x1, y2, x1, y2, x2, y1, x2, y2])
+
+    const colors = new Float32Array([r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a])
 
     this.gl.useProgram(this.program)
 
@@ -375,8 +361,3 @@ export class WebGLDirect2DOverlay {
     this.gl.deleteProgram(this.program)
   }
 }
-
-
-
-
-

package/src/lib/cleanupDecorator.ts

@@ -1,5 +1,5 @@
 //@ts-nocheck
-export function buildCleanupDecorator (cleanupMethod: string) {
+export function buildCleanupDecorator(cleanupMethod: string) {
   return function () {
     return function (_target: { snapshotInitialValues }, propertyKey: string) {
       const target = _target as any
@@ -13,7 +13,7 @@ export function buildCleanupDecorator (cleanupMethod: string) {
         }
         target._snapshotMethodPatched = true
       }
-      (target._toCleanup ??= []).push(propertyKey)
+      ;(target._toCleanup ??= []).push(propertyKey)
       if (!target._cleanupPatched) {
         const originalMethod = target[cleanupMethod]
         target[cleanupMethod] = function () {

package/src/lib/createPlayerObject.test.ts

@@ -3,7 +3,7 @@ import { describe, expect, it, vi } from 'vitest'
 
 vi.mock('./utils/skins', () => ({
   stevePngUrl: '',
-  loadSkinImage: vi.fn(),
+  loadSkinImage: vi.fn()
 }))
 
 import { PlayerObject } from 'skinview3d'
@@ -16,12 +16,7 @@ describe('configurePlayerSkinMaterials', () => {
 
     configurePlayerSkinMaterials(playerObject)
 
-    const allMaterials = [
-      skin.layer1Material,
-      skin.layer1MaterialBiased,
-      skin.layer2Material,
-      skin.layer2MaterialBiased,
-    ]
+    const allMaterials = [skin.layer1Material, skin.layer1MaterialBiased, skin.layer2Material, skin.layer2MaterialBiased]
     for (const mat of allMaterials) {
       expect(mat.transparent).toBe(false)
       expect(mat.alphaTest).toBe(0.1)

package/src/lib/createPlayerObject.ts

@@ -12,7 +12,7 @@ export type PlayerObjectType = PlayerObject & {
 
 const LOG_DEPTH_BIAS = -2e-4 // tune visually; negative ≈ polygonOffset “closer”
 
-function patchLogDepthBiasShader (shader: THREE.WebGLProgramParametersWithUniforms): void {
+function patchLogDepthBiasShader(shader: THREE.WebGLProgramParametersWithUniforms): void {
   shader.uniforms.uLogDepthBias = { value: LOG_DEPTH_BIAS }
   shader.fragmentShader = shader.fragmentShader.replace(
     '#include <logdepthbuf_pars_fragment>',
@@ -26,7 +26,7 @@ function patchLogDepthBiasShader (shader: THREE.WebGLProgramParametersWithUnifor
   )
 }
 
-function applyLogDepthBias (material: THREE.Material): void {
+function applyLogDepthBias(material: THREE.Material): void {
   if (material.userData.logDepthBiasApplied) return
   material.userData.logDepthBiasApplied = true
   material.onBeforeCompile = patchLogDepthBiasShader
@@ -34,14 +34,9 @@ function applyLogDepthBias (material: THREE.Material): void {
 }
 
 /** Log-depth world: opaque cutout mats (alphaTest + depthWrite, not transparent sort). */
-export function configurePlayerSkinMaterials (playerObject: PlayerObject): void {
+export function configurePlayerSkinMaterials(playerObject: PlayerObject): void {
   const skin = playerObject.skin as any
-  const materials = [
-    skin.layer1Material,
-    skin.layer1MaterialBiased,
-    skin.layer2Material,
-    skin.layer2MaterialBiased,
-  ]
+  const materials = [skin.layer1Material, skin.layer1MaterialBiased, skin.layer2Material, skin.layer2MaterialBiased]
   for (const mat of materials) {
     mat.transparent = false
     mat.alphaTest = 0.1
@@ -51,14 +46,10 @@ export function configurePlayerSkinMaterials (playerObject: PlayerObject): void
   applyLogDepthBias(skin.layer2MaterialBiased)
 }
 
-export function createPlayerObject (options: {
-  username?: string
-  uuid?: string
-  scale?: number
-}): {
-    playerObject: PlayerObjectType
-    wrapper: THREE.Group
-  } {
+export function createPlayerObject(options: { username?: string; uuid?: string; scale?: number }): {
+  playerObject: PlayerObjectType
+  wrapper: THREE.Group
+} {
   const wrapper = new THREE.Group()
   const playerObject = new PlayerObject() as PlayerObjectType
 
@@ -69,7 +60,7 @@ export function createPlayerObject (options: {
   configurePlayerSkinMaterials(playerObject)
 
   wrapper.add(playerObject as any)
-  const scale = options.scale ?? (1 / 16)
+  const scale = options.scale ?? 1 / 16
   wrapper.scale.set(scale, scale, scale)
   wrapper.rotation.set(0, Math.PI, 0)
 
@@ -82,11 +73,13 @@ export function createPlayerObject (options: {
 }
 
 export const applySkinToPlayerObject = async (playerObject: PlayerObjectType, skinUrl: string) => {
-  return loadSkinImage(skinUrl || stevePngUrl).then(({ canvas }) => {
-    const skinTexture = new THREE.CanvasTexture(canvas)
-    skinTexture.magFilter = THREE.NearestFilter
-    skinTexture.minFilter = THREE.NearestFilter
-    skinTexture.needsUpdate = true
-    playerObject.skin.map = skinTexture as any
-  }).catch(console.error)
+  return loadSkinImage(skinUrl || stevePngUrl)
+    .then(({ canvas }) => {
+      const skinTexture = new THREE.CanvasTexture(canvas)
+      skinTexture.magFilter = THREE.NearestFilter
+      skinTexture.minFilter = THREE.NearestFilter
+      skinTexture.needsUpdate = true
+      playerObject.skin.map = skinTexture as any
+    })
+    .catch(console.error)
 }