minecraft-renderer 0.1.79 → 0.1.81

package/src/three/graphicsBackendBase.ts

@@ -49,7 +49,7 @@ export const getBackendMethods = (worldRenderer: WorldRendererThree): any => {
     setVideoVolume: worldRenderer.media.setVideoVolume.bind(worldRenderer.media),
     setVideoSpeed: worldRenderer.media.setVideoSpeed.bind(worldRenderer.media),
     handleUserClick: worldRenderer.media.handleUserClick.bind(worldRenderer.media),
-    addSectionAnimation(id: string, animation: typeof worldRenderer.sectionsOffsetsAnimations[string]) {
+    addSectionAnimation(id: string, animation: (typeof worldRenderer.sectionsOffsetsAnimations)[string]) {
       worldRenderer.sectionsOffsetsAnimations[id] = animation
     },
     removeSectionAnimation(id: string) {
@@ -105,7 +105,7 @@ export const getBackendMethods = (worldRenderer: WorldRendererThree): any => {
       return {
         loadedSectionsChunks,
         loadedChunks: { ...worldRenderer.loadedChunks },
-        finishedChunks: { ...worldRenderer.finishedChunks },
+        finishedChunks: { ...worldRenderer.finishedChunks }
       }
     }
   }
@@ -157,9 +157,9 @@ export const createGraphicsBackendBase = () => {
     }
 
     documentRenderer = new DocumentRenderer(initOptions, mainData?.canvas)
-      ; (globalThis as any).renderer = documentRenderer.renderer
-      ; (globalThis as any).documentRenderer = documentRenderer
-      ; (globalThis as any).threeJsBackend = backend
+    ;(globalThis as any).renderer = documentRenderer.renderer
+    ;(globalThis as any).documentRenderer = documentRenderer
+    ;(globalThis as any).threeJsBackend = backend
 
     callModsMethod('default', backend)
   }
@@ -171,8 +171,8 @@ export const createGraphicsBackendBase = () => {
       worldRenderer.destroy()
       worldRenderer = null
       frameTimingCollector = null
-        ; (globalThis as any).world = undefined
-        ; (globalThis as any).frameTimingCollector = undefined
+      ;(globalThis as any).world = undefined
+      ;(globalThis as any).frameTimingCollector = undefined
     }
 
     if (menuBackgroundRenderer) {
@@ -184,12 +184,7 @@ export const createGraphicsBackendBase = () => {
       ...initOptions.config.menuBackground,
       ...menuBackgroundStartOptions
     }
-    menuBackgroundRenderer = new MenuBackgroundRenderer(
-      documentRenderer,
-      { ...initOptions },
-      mergedOptions,
-      !!process.env.SINGLE_FILE_BUILD_MODE
-    )
+    menuBackgroundRenderer = new MenuBackgroundRenderer(documentRenderer, { ...initOptions }, mergedOptions, !!process.env.SINGLE_FILE_BUILD_MODE)
     callModsMethod('menuBackgroundCreated', menuBackgroundRenderer)
     await menuBackgroundRenderer.start(mergedOptions)
     callModsMethod('menuBackgroundReady', menuBackgroundRenderer)
@@ -207,25 +202,25 @@ export const createGraphicsBackendBase = () => {
       worldRenderer.destroy()
       worldRenderer = null
       frameTimingCollector = null
-        ; (globalThis as any).world = undefined
-        ; (globalThis as any).frameTimingCollector = undefined
+      ;(globalThis as any).world = undefined
+      ;(globalThis as any).frameTimingCollector = undefined
     }
 
     const displayOptionsRestorers = [ResourcesManager, WorldViewWorker]
-    const displayOptions: DisplayWorldOptions = isWebWorker ? restoreTransferred(displayOptionsArg, displayOptionsRestorers, globalThis as unknown as Worker) : displayOptionsArg
+    const displayOptions: DisplayWorldOptions = isWebWorker
+      ? restoreTransferred(displayOptionsArg, displayOptionsRestorers, globalThis as unknown as Worker)
+      : displayOptionsArg
 
     documentRenderer.nonReactiveState = displayOptions.nonReactiveState
-      // Set resourcesManager globally for world rendering
-      ; (globalThis as any).resourcesManager = displayOptions.resourcesManager
+    // Set resourcesManager globally for world rendering
+    ;(globalThis as any).resourcesManager = displayOptions.resourcesManager
 
     worldRenderer = new WorldRendererThree(documentRenderer.renderer, initOptions, displayOptions)
 
     await worldRenderer.worldReadyPromise
 
-    frameTimingCollector = displayOptions.inWorldRenderingConfig.enableDebugOverlay
-      ? new FrameTimingCollector(displayOptions.nonReactiveState)
-      : null
-      ; (globalThis as any).frameTimingCollector = frameTimingCollector
+    frameTimingCollector = displayOptions.inWorldRenderingConfig.enableDebugOverlay ? new FrameTimingCollector(displayOptions.nonReactiveState) : null
+    ;(globalThis as any).frameTimingCollector = frameTimingCollector
 
     const originalRender = documentRenderer.render
 
@@ -242,8 +237,7 @@ export const createGraphicsBackendBase = () => {
     }
 
     documentRenderer.inWorldRenderingConfig = displayOptions.inWorldRenderingConfig
-
-      ; (globalThis as any).world = worldRenderer
+    ;(globalThis as any).world = worldRenderer
 
     callModsMethod('worldReady', worldRenderer)
   }
@@ -284,7 +278,7 @@ export const createGraphicsBackendBase = () => {
         return {
           'Geo Memory': worldRenderer?.chunkMeshManager.getEstimatedMemoryUsage().total ?? '-'
         }
-      },
+      }
     }),
     updateCamera(pos: Vec3 | null, yaw: number, pitch: number) {
       // Mark camera update event for frame timing visualization

package/src/three/graphicsBackendOffThread.ts

@@ -27,15 +27,18 @@ function initThreeWorker(onGotMessage: (data: any) => void) {
   worker.onmessage = ({ data }) => {
     onGotMessage(data)
   }
-  if (worker.on) worker.on('message', (data) => { worker.onmessage({ data }) })
+  if (worker.on)
+    worker.on('message', data => {
+      worker.onmessage({ data })
+    })
   return worker
 }
 
-export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (initOptions) => {
+export const createGraphicsBackendOffThread: GraphicsBackendLoader = async initOptions => {
   const workerSideChannel = {
-    onMessage: (_data: unknown) => {},
+    onMessage: (_data: unknown) => {}
   }
-  const worker = initThreeWorker((data) => {
+  const worker = initThreeWorker(data => {
     workerSideChannel.onMessage(data)
   })
   type WorkerType = ReturnType<ReturnType<typeof createGraphicsBackendBase>['workerProxy']>
@@ -72,7 +75,7 @@ export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (init
         const workerThreeSendData = {
           ...dynamicMcDataFiles,
           items: 'itemsArray',
-          entities: 'entitiesArray',
+          entities: 'entitiesArray'
         }
         await meshersSendMcDataAwait([worker], MENU_BACKGROUND_MC_VERSION, workerThreeSendData, mcData)
       }
@@ -88,7 +91,7 @@ export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (init
       const worldView = options.worldView as unknown as WorldView
       workerSideChannel.onMessage = (data: any) => {
         if (data?.type === 'reloadLoadedChunks') {
-          void worldView.reloadLoadedChunks().catch((err) => {
+          void worldView.reloadLoadedChunks().catch(err => {
             console.error('[Renderer] Failed to reload chunks after mesher reconfigure:', err)
           })
         }
@@ -97,14 +100,9 @@ export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (init
       const workerThreeSendData = {
         ...dynamicMcDataFiles,
         items: 'itemsArray',
-        entities: 'entitiesArray',
+        entities: 'entitiesArray'
       }
-      await meshersSendMcDataAwait(
-        [worker],
-        options.version,
-        workerThreeSendData,
-        options.resourcesManager.currentResources.mcData
-      )
+      await meshersSendMcDataAwait([worker], options.version, workerThreeSendData, options.resourcesManager.currentResources.mcData)
       console.log('mc data sent to three worker')
 
       options.inWorldRenderingConfig['__syncToWorker'] = true
@@ -130,7 +128,6 @@ export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (init
       }
       proxy.updateSizeExternal(canvas.size.width, canvas.size.height, window.devicePixelRatio || 1)
 
-
       const fpsStat = addNewStat('fps')
       setInterval(() => {
         const { fps, avgRenderTime, worstRenderTime } = options.nonReactiveState
@@ -139,7 +136,7 @@ export const createGraphicsBackendOffThread: GraphicsBackendLoader = async (init
       }, 1000)
 
       const chunksStat = addNewStat('downloaded-chunks', 100, 140, 20, {
-        className: MC_RENDERER_DEBUG_OVERLAY_CLASS,
+        className: MC_RENDERER_DEBUG_OVERLAY_CLASS
       })
       setInterval(() => {
         const advanced = (initOptions.config.statsVisible ?? 0) > 1

package/src/three/hand.ts

@@ -2,7 +2,6 @@
 import * as THREE from 'three'
 import { loadSkinFromUsername, loadSkinImage, stevePngUrl } from '../lib/utils/skins'
 
-
 export const getMyHand = async (image?: string, userName?: string) => {
   let newMap: THREE.Texture
   if (!image && !userName) {
@@ -26,12 +25,7 @@ export const getMyHand = async (image?: string, userName?: string) => {
   const pixelWidth = slim ? 3 : 4
 
   // Exact replica of vanilla's Cube: addBox(-3, -2, -2, 4, 12, 4) at texOffs(40, 16)
-  const box = createVanillaCubeGeometry(
-    40, 16,
-    slim ? -2 : -3, -2, -2,
-    pixelWidth, 12, 4,
-    64, 64
-  )
+  const box = createVanillaCubeGeometry(40, 16, slim ? -2 : -3, -2, -2, pixelWidth, 12, 4, 64, 64)
 
   const material = new THREE.MeshStandardMaterial()
   material.map = newMap
@@ -49,11 +43,17 @@ export const getMyHand = async (image?: string, userName?: string) => {
  * Vertices, face winding, normals, and UV mapping match the decompiled Java source.
  * Position coordinates are in pixels, divided by 16 for block units.
  */
-function createVanillaCubeGeometry (
-  texU: number, texV: number,
-  originX: number, originY: number, originZ: number,
-  sizeX: number, sizeY: number, sizeZ: number,
-  texWidth: number, texHeight: number,
+function createVanillaCubeGeometry(
+  texU: number,
+  texV: number,
+  originX: number,
+  originY: number,
+  originZ: number,
+  sizeX: number,
+  sizeY: number,
+  sizeZ: number,
+  texWidth: number,
+  texHeight: number,
   mirror = false
 ): THREE.BufferGeometry {
   let minX = originX / 16
@@ -64,7 +64,7 @@ function createVanillaCubeGeometry (
   let maxZ = (originZ + sizeZ) / 16
 
   if (mirror) {
-    [minX, maxX] = [maxX, minX]
+    ;[minX, maxX] = [maxX, minX]
   }
 
   // 8 corner vertices matching vanilla's Cube constructor
@@ -76,7 +76,7 @@ function createVanillaCubeGeometry (
     [minX, minY, maxZ], // 4
     [maxX, minY, maxZ], // 5
     [maxX, maxY, maxZ], // 6
-    [minX, maxY, maxZ], // 7
+    [minX, maxY, maxZ] // 7
   ]
 
   // UV grid (pixel coords)
@@ -92,12 +92,12 @@ function createVanillaCubeGeometry (
 
   // 6 faces: vanilla vertex order + UV rect + normal
   const faces: { vi: number[]; uv: number[]; n: number[] }[] = [
-    { vi: [5, 4, 0, 1], uv: [u1, v0, u2, v1], n: [0, -1, 0] },  // DOWN
-    { vi: [2, 3, 7, 6], uv: [u2, v1, u3, v0], n: [0, 1, 0] },   // UP
-    { vi: [0, 4, 7, 3], uv: [u0, v1, u1, v2], n: [-1, 0, 0] },  // WEST
-    { vi: [1, 0, 3, 2], uv: [u1, v1, u2, v2], n: [0, 0, -1] },  // NORTH
-    { vi: [5, 1, 2, 6], uv: [u2, v1, u4, v2], n: [1, 0, 0] },   // EAST
-    { vi: [4, 5, 6, 7], uv: [u4, v1, u5, v2], n: [0, 0, 1] },   // SOUTH
+    { vi: [5, 4, 0, 1], uv: [u1, v0, u2, v1], n: [0, -1, 0] }, // DOWN
+    { vi: [2, 3, 7, 6], uv: [u2, v1, u3, v0], n: [0, 1, 0] }, // UP
+    { vi: [0, 4, 7, 3], uv: [u0, v1, u1, v2], n: [-1, 0, 0] }, // WEST
+    { vi: [1, 0, 3, 2], uv: [u1, v1, u2, v2], n: [0, 0, -1] }, // NORTH
+    { vi: [5, 1, 2, 6], uv: [u2, v1, u4, v2], n: [1, 0, 0] }, // EAST
+    { vi: [4, 5, 6, 7], uv: [u4, v1, u5, v2], n: [0, 0, 1] } // SOUTH
   ]
 
   const positions: number[] = []
@@ -115,7 +115,7 @@ function createVanillaCubeGeometry (
       [uR / texWidth, 1 - vT / texHeight],
       [uL / texWidth, 1 - vT / texHeight],
       [uL / texWidth, 1 - vB / texHeight],
-      [uR / texWidth, 1 - vB / texHeight],
+      [uR / texWidth, 1 - vB / texHeight]
     ]
 
     const order = mirror ? [3, 2, 1, 0] : [0, 1, 2, 3]

package/src/three/handLegacy.ts

@@ -3,7 +3,6 @@ import * as THREE from 'three'
 import { loadSkinFromUsername, loadSkinImage } from '../lib/utils/skins'
 import { steveTexture } from './entities'
 
-
 export const getMyHand = async (image?: string, userName?: string) => {
   let newMap: THREE.Texture
   if (!image && !userName) {
@@ -39,21 +38,12 @@ export const getMyHand = async (image?: string, userName?: string) => {
   return group
 }
 
-function setUVs (
-  box: THREE.BoxGeometry,
-  u: number,
-  v: number,
-  width: number,
-  height: number,
-  depth: number,
-  textureWidth: number,
-  textureHeight: number
-): void {
+function setUVs(box: THREE.BoxGeometry, u: number, v: number, width: number, height: number, depth: number, textureWidth: number, textureHeight: number): void {
   const toFaceVertices = (x1: number, y1: number, x2: number, y2: number) => [
     new THREE.Vector2(x1 / textureWidth, 1 - y2 / textureHeight),
     new THREE.Vector2(x2 / textureWidth, 1 - y2 / textureHeight),
     new THREE.Vector2(x2 / textureWidth, 1 - y1 / textureHeight),
-    new THREE.Vector2(x1 / textureWidth, 1 - y1 / textureHeight),
+    new THREE.Vector2(x1 / textureWidth, 1 - y1 / textureHeight)
   ]
 
   const top = toFaceVertices(u + depth, v, u + width + depth, v + depth)
@@ -85,6 +75,6 @@ function setUVs (
   uvAttr.needsUpdate = true
 }
 
-function setSkinUVs (box: THREE.BoxGeometry, u: number, v: number, width: number, height: number, depth: number): void {
+function setSkinUVs(box: THREE.BoxGeometry, u: number, v: number, width: number, height: number, depth: number): void {
   setUVs(box, u, v, width, height, depth, 64, 64)
 }

package/src/three/holdingBlock.ts

@@ -38,23 +38,23 @@ function buildBareHandMatrix(swingProgress: number, equipProgress: number): THRE
   // Step 1: Base position with swing
   mat.multiply(_tempMat.makeTranslation(side * (swingX + 0.64), swingY - 0.6 + equipProgress * -0.6, swingZ - 0.72))
   // Step 2: Base Y rotation 45°
-  mat.multiply(_tempMat.makeRotationY(side * 45 * Math.PI / 180))
+  mat.multiply(_tempMat.makeRotationY((side * 45 * Math.PI) / 180))
   // Step 3: Swing Y rotation
-  mat.multiply(_tempMat.makeRotationY(side * Math.sin(sqrtSwing * Math.PI) * 70 * Math.PI / 180))
+  mat.multiply(_tempMat.makeRotationY((side * Math.sin(sqrtSwing * Math.PI) * 70 * Math.PI) / 180))
   // Step 4: Swing Z rotation
-  mat.multiply(_tempMat.makeRotationZ(side * Math.sin(swingProgress * swingProgress * Math.PI) * -20 * Math.PI / 180))
+  mat.multiply(_tempMat.makeRotationZ((side * Math.sin(swingProgress * swingProgress * Math.PI) * -20 * Math.PI) / 180))
   // Step 5: Second translation
   mat.multiply(_tempMat.makeTranslation(side * -1, 3.6, 3.5))
   // Step 6: Z rotation 120°
-  mat.multiply(_tempMat.makeRotationZ(side * 120 * Math.PI / 180))
+  mat.multiply(_tempMat.makeRotationZ((side * 120 * Math.PI) / 180))
   // Step 7: X rotation 200°
-  mat.multiply(_tempMat.makeRotationX(200 * Math.PI / 180))
+  mat.multiply(_tempMat.makeRotationX((200 * Math.PI) / 180))
   // Step 8: Y rotation -135°
-  mat.multiply(_tempMat.makeRotationY(side * -135 * Math.PI / 180))
+  mat.multiply(_tempMat.makeRotationY((side * -135 * Math.PI) / 180))
   // Step 9: Final X offset
   mat.multiply(_tempMat.makeTranslation(side * 5.6, 0, 0))
   // Step 10: translateToHand - arm part position (-5/16, 2/16, 0)
-  mat.multiply(_tempMat.makeTranslation(side * -5 / 16, 2 / 16, 0))
+  mat.multiply(_tempMat.makeTranslation((side * -5) / 16, 2 / 16, 0))
 
   return mat
 }
@@ -78,10 +78,10 @@ function buildItemArmMatrix(swingProgress: number, equipProgress: number): THREE
   // applyItemArmAttackTransform
   const sinSwingSq = Math.sin(swingProgress * swingProgress * Math.PI)
   const sinSqrtSwing = Math.sin(sqrtSwing * Math.PI)
-  mat.multiply(_tempMat.makeRotationY(side * (45 + sinSwingSq * -20) * Math.PI / 180))
-  mat.multiply(_tempMat.makeRotationZ(side * sinSqrtSwing * -20 * Math.PI / 180))
-  mat.multiply(_tempMat.makeRotationX(sinSqrtSwing * -80 * Math.PI / 180))
-  mat.multiply(_tempMat.makeRotationY(side * -45 * Math.PI / 180))
+  mat.multiply(_tempMat.makeRotationY((side * (45 + sinSwingSq * -20) * Math.PI) / 180))
+  mat.multiply(_tempMat.makeRotationZ((side * sinSqrtSwing * -20 * Math.PI) / 180))
+  mat.multiply(_tempMat.makeRotationX((sinSqrtSwing * -80 * Math.PI) / 180))
+  mat.multiply(_tempMat.makeRotationY((side * -45 * Math.PI) / 180))
 
   return mat
 }
@@ -89,10 +89,12 @@ function buildItemArmMatrix(swingProgress: number, equipProgress: number): THREE
 export default class HoldingBlock implements IHoldingBlock {
   // TODO refactor with the tree builder for better visual understanding
   holdingBlock: THREE.Object3D | undefined = undefined
-  blockSwapAnimation: {
-    switcher: SmoothSwitcher
-    // hidden: boolean
-  } | undefined = undefined
+  blockSwapAnimation:
+    | {
+        switcher: SmoothSwitcher
+        // hidden: boolean
+      }
+    | undefined = undefined
   cameraGroup = new THREE.Mesh()
   armTransformGroup = new THREE.Group()
   camera = new THREE.PerspectiveCamera(70, 1, 0.05, 100)
@@ -120,20 +122,31 @@ export default class HoldingBlock implements IHoldingBlock {
   private disposed = false
   private unsubs: Array<() => void> = []
 
-  constructor(public worldRenderer: WorldRendererThree, public offHand = false) {
+  constructor(
+    public worldRenderer: WorldRendererThree,
+    public offHand = false
+  ) {
     this.initCameraGroup()
     this.swingAnimator = new HandSwingAnimator()
     this.unsubs.push(
-      this.worldRenderer.onReactivePlayerStateUpdated('heldItemMain', () => {
-        if (!this.offHand) {
-          this.updateItem()
-        }
-      }, false),
-      this.worldRenderer.onReactivePlayerStateUpdated('heldItemOff', () => {
-        if (this.offHand) {
-          this.updateItem()
-        }
-      }, false)
+      this.worldRenderer.onReactivePlayerStateUpdated(
+        'heldItemMain',
+        () => {
+          if (!this.offHand) {
+            this.updateItem()
+          }
+        },
+        false
+      ),
+      this.worldRenderer.onReactivePlayerStateUpdated(
+        'heldItemOff',
+        () => {
+          if (this.offHand) {
+            this.updateItem()
+          }
+        },
+        false
+      )
     )
     this.config = worldRenderer.displayOptions.inWorldRenderingConfig
 
@@ -141,33 +154,38 @@ export default class HoldingBlock implements IHoldingBlock {
     // this.offHandDisplay = true
     if (!this.offHand) {
       // load default hand
-      void getMyHand().then((hand) => {
-        if (this.disposed) return
-        this.playerHand = hand
-        // trigger update
-        this.updateItem()
-      }).then(() => {
-        if (this.disposed) return
-        // now watch over the player skin
-        const unsub = watchProperty(
-          async () => {
-            return getMyHand(this.worldRenderer.playerStateReactive.playerSkin, this.worldRenderer.playerStateReactive.onlineMode ? this.worldRenderer.playerStateReactive.username : undefined)
-          },
-          this.worldRenderer.playerStateReactive,
-          'playerSkin',
-          (newHand) => {
-            if (newHand) {
-              this.playerHand = newHand
-              // trigger update
-              this.updateItem()
+      void getMyHand()
+        .then(hand => {
+          if (this.disposed) return
+          this.playerHand = hand
+          // trigger update
+          this.updateItem()
+        })
+        .then(() => {
+          if (this.disposed) return
+          // now watch over the player skin
+          const unsub = watchProperty(
+            async () => {
+              return getMyHand(
+                this.worldRenderer.playerStateReactive.playerSkin,
+                this.worldRenderer.playerStateReactive.onlineMode ? this.worldRenderer.playerStateReactive.username : undefined
+              )
+            },
+            this.worldRenderer.playerStateReactive,
+            'playerSkin',
+            newHand => {
+              if (newHand) {
+                this.playerHand = newHand
+                // trigger update
+                this.updateItem()
+              }
+            },
+            oldHand => {
+              disposeObject(oldHand!, true)
             }
-          },
-          (oldHand) => {
-            disposeObject(oldHand!, true)
-          }
-        )
-        this.unsubs.push(unsub)
-      })
+          )
+          this.unsubs.push(unsub)
+        })
     }
   }
 
@@ -202,7 +220,7 @@ export default class HoldingBlock implements IHoldingBlock {
       void this.setNewItem()
     } else {
       void this.setNewItem({
-        type: 'hand',
+        type: 'hand'
       })
     }
   }
@@ -225,7 +243,8 @@ export default class HoldingBlock implements IHoldingBlock {
   render(originalCamera: THREE.PerspectiveCamera, renderer: THREE.WebGLRenderer, ambientLight: THREE.AmbientLight, directionalLight: THREE.DirectionalLight) {
     if (!this.lastHeldItem) return
     const now = performance.now()
-    if (this.lastUpdate && now - this.lastUpdate > 50) { // one tick
+    if (this.lastUpdate && now - this.lastUpdate > 50) {
+      // one tick
       void this.replaceItemModel(this.lastHeldItem)
     }
 
@@ -323,7 +342,7 @@ export default class HoldingBlock implements IHoldingBlock {
 
     const targetProgress = forceState === 'disappeared' ? 1 : 0
     let cancelled = false
-    return new Promise<boolean>((resolve) => {
+    return new Promise<boolean>(resolve => {
       this.blockSwapAnimation!.switcher.transitionTo(
         { progress: targetProgress },
         forceState,
@@ -423,10 +442,15 @@ export default class HoldingBlock implements IHoldingBlock {
 
     let blockInner: THREE.Object3D | undefined
     if (handItem.type === 'item' || handItem.type === 'block') {
-      const result = this.worldRenderer.entities.getItemMesh({
-        ...handItem.fullItem,
-        itemId: handItem.id,
-      }, getFirstPersonItemSpecificProps(this.worldRenderer), false, this.lastItemModelName)
+      const result = this.worldRenderer.entities.getItemMesh(
+        {
+          ...handItem.fullItem,
+          itemId: handItem.id
+        },
+        getFirstPersonItemSpecificProps(this.worldRenderer),
+        false,
+        this.lastItemModelName
+      )
       if (result) {
         const { mesh: itemMesh, isBlock, modelName } = result
         if (isBlock) {
@@ -495,8 +519,6 @@ export default class HoldingBlock implements IHoldingBlock {
     this.holdingBlock = result.model
     this.currentDisplayType = result.type
     this.armTransformGroup.add(result.model)
-
-
   }
 
   testUnknownBlockSwitch() {
@@ -562,7 +584,6 @@ export default class HoldingBlock implements IHoldingBlock {
     // Idle animation disabled — walking bob is handled by vanilla bobView applied to cameraGroup
     this.idleAnimator = undefined
   }
-
 }
 
 class HandIdleAnimator {
@@ -587,7 +608,10 @@ class HandIdleAnimator {
 
   private readonly debugGui: DebugGui
 
-  constructor(public handMesh: THREE.Object3D, public playerState: PlayerStateRenderer) {
+  constructor(
+    public handMesh: THREE.Object3D,
+    public playerState: PlayerStateRenderer
+  ) {
     this.handMesh = handMesh
     this.globalTime = 0
     this.currentState = 'NOT_MOVING'
@@ -616,12 +640,24 @@ class HandIdleAnimator {
       },
       (property, value) => {
         switch (property) {
-          case 'x': this.handMesh.position.x = value; break
-          case 'y': this.handMesh.position.y = value; break
-          case 'z': this.handMesh.position.z = value; break
-          case 'rotationX': this.handMesh.rotation.x = value; break
-          case 'rotationY': this.handMesh.rotation.y = value; break
-          case 'rotationZ': this.handMesh.rotation.z = value; break
+          case 'x':
+            this.handMesh.position.x = value
+            break
+          case 'y':
+            this.handMesh.position.y = value
+            break
+          case 'z':
+            this.handMesh.position.z = value
+            break
+          case 'rotationX':
+            this.handMesh.rotation.x = value
+            break
+          case 'rotationY':
+            this.handMesh.rotation.y = value
+            break
+          case 'rotationZ':
+            this.handMesh.rotation.z = value
+            break
         }
       },
       {
@@ -647,10 +683,13 @@ class HandIdleAnimator {
     this.idleOffset.rotationZ = this.handMesh.rotation.z - this.defaultPosition.rotationZ
 
     this.idleTween = new tweenJs.Tween(this.idleOffset, this.tween)
-      .to({
-        y: 0.05,
-        rotationZ: 0.05
-      }, 3000)
+      .to(
+        {
+          y: 0.05,
+          rotationZ: 0.05
+        },
+        3000
+      )
       .easing(tweenJs.Easing.Sinusoidal.InOut)
       .yoyo(true)
       .repeat(Infinity)
@@ -748,8 +787,7 @@ class HandIdleAnimator {
     }
 
     // If we're not transitioning between states and in a stable state that should have idle animation
-    if (!this.stateSwitcher.isTransitioning &&
-      (this.currentState === 'NOT_MOVING' || this.currentState === 'SNEAKING')) {
+    if (!this.stateSwitcher.isTransitioning && (this.currentState === 'NOT_MOVING' || this.currentState === 'SNEAKING')) {
       // Start idle animation if not already running
       if (!this.idleTween?.isPlaying()) {
         this.startIdleAnimation()
@@ -763,8 +801,7 @@ class HandIdleAnimator {
     }
 
     // If we're in a movement state and not transitioning, update the movement animation
-    if (!this.stateSwitcher.isTransitioning &&
-      (this.currentState === 'WALKING' || this.currentState === 'SPRINTING')) {
+    if (!this.stateSwitcher.isTransitioning && (this.currentState === 'WALKING' || this.currentState === 'SPRINTING')) {
       const stateTransform = this.getStateTransform(this.currentState, this.globalTime)
       Object.assign(this.handMesh.position, stateTransform)
       Object.assign(this.handMesh.rotation, {
@@ -796,14 +833,14 @@ class HandSwingAnimator {
 
   readonly debugParams = {
     animationTime: 250,
-    animationStage: 0,
+    animationStage: 0
   }
 
   private readonly debugGui: DebugGui
 
   constructor() {
     this.debugGui = new DebugGui('hand_animator', this.debugParams, undefined, {
-      animationStage: { min: 0, max: 1, step: 0.01 },
+      animationStage: { min: 0, max: 1, step: 0.01 }
     })
   }
 

package/src/three/holdingBlockFactory.ts

@@ -4,10 +4,7 @@ import HoldingBlockLegacy from './holdingBlockLegacy'
 import type { IHoldingBlock } from './holdingBlockTypes'
 import type { WorldRendererThree } from './worldRendererThree'
 
-export function createHoldingBlock(
-  worldRenderer: WorldRendererThree,
-  offHand: boolean = false
-): IHoldingBlock {
+export function createHoldingBlock(worldRenderer: WorldRendererThree, offHand: boolean = false): IHoldingBlock {
   const config = worldRenderer.displayOptions.inWorldRenderingConfig
   if (config.handRenderer === 'legacy') {
     return new HoldingBlockLegacy(worldRenderer, offHand)