minecraft-renderer 0.1.78 → 0.1.80

package/src/three/menuBackground/worldBlocks.ts

@@ -22,8 +22,12 @@ export class WorldBlocksMenuBackground implements MenuBackgroundView {
   private _scene: THREE.Scene
   private _camera: THREE.PerspectiveCamera
 
-  get scene() { return this._scene }
-  get camera() { return this._camera }
+  get scene() {
+    return this._scene
+  }
+  get camera() {
+    return this._camera
+  }
 
   private worldRenderer?: WorldRendererCommon | WorldRendererThree
   WorldRendererClass = WorldRendererThree
@@ -35,12 +39,7 @@ export class WorldBlocksMenuBackground implements MenuBackgroundView {
   ) {
     this._scene = new THREE.Scene()
     this._scene.background = new THREE.Color(0x32_45_68)
-    this._camera = new THREE.PerspectiveCamera(
-      85,
-      documentRenderer.canvas.width / documentRenderer.canvas.height,
-      0.05,
-      1000
-    )
+    this._camera = new THREE.PerspectiveCamera(85, documentRenderer.canvas.width / documentRenderer.canvas.height, 0.05, 1000)
     this.camera.position.set(0, 0, 0)
     this.camera.rotation.set(0, 0, 0)
   }
@@ -57,7 +56,7 @@ export class WorldBlocksMenuBackground implements MenuBackgroundView {
     const PrismarineBlock = require('prismarine-block')
     const Block = PrismarineBlock(version)
     const mcData = (globalThis as any).mcData
-    const fullBlocks = mcData.blocksArray.filter((block: { name: string, defaultState: number }) => {
+    const fullBlocks = mcData.blocksArray.filter((block: { name: string; defaultState: number }) => {
       if (!block.name.includes('stained_glass')) return false
       const b = Block.fromStateId(block.defaultState, 0)
       if (b.shapes?.length !== 1) return false
@@ -82,19 +81,15 @@ export class WorldBlocksMenuBackground implements MenuBackgroundView {
     const worldView = new WorldView(world, 2, initPos)
     if (this.abortSignal.aborted) return
 
-    this.worldRenderer = new this.WorldRendererClass(
-      this.documentRenderer.renderer,
-      this.options,
-      {
-        version,
-        worldView,
-        inWorldRenderingConfig: defaultWorldRendererConfig,
-        playerStateReactive: getInitialPlayerStateRenderer().reactive,
-        rendererState: getDefaultRendererState().reactive,
-        nonReactiveState: getDefaultRendererState().nonReactive,
-        resourcesManager: fullResourceManager as ResourcesManagerTransferred
-      }
-    )
+    this.worldRenderer = new this.WorldRendererClass(this.documentRenderer.renderer, this.options, {
+      version,
+      worldView,
+      inWorldRenderingConfig: defaultWorldRendererConfig,
+      playerStateReactive: getInitialPlayerStateRenderer().reactive,
+      rendererState: getDefaultRendererState().reactive,
+      nonReactiveState: getDefaultRendererState().nonReactive,
+      resourcesManager: fullResourceManager as ResourcesManagerTransferred
+    })
 
     if (this.worldRenderer instanceof WorldRendererThree) {
       this._scene = this.worldRenderer.realScene
@@ -127,18 +122,25 @@ export class WorldBlocksMenuBackground implements MenuBackgroundView {
     const initY = camera.position.y
     let prevTween: tweenJs.Tween<THREE.Vector3> | undefined
 
-    document.body.addEventListener('pointermove', (e) => {
-      if (e.pointerType !== 'mouse') return
-      const SCALE = 0.2
-      const xRel = e.clientX / window.innerWidth - 0.5
-      const yRel = -(e.clientY / window.innerHeight - 0.5)
-      prevTween?.stop()
-      prevTween = new tweenJs.Tween(camera.position).to({
-        x: initX + xRel * SCALE,
-        y: initY + yRel * SCALE
-      }, 0)
-      prevTween.start()
-      camera.updateProjectionMatrix()
-    }, { signal: this.abortSignal })
+    document.body.addEventListener(
+      'pointermove',
+      e => {
+        if (e.pointerType !== 'mouse') return
+        const SCALE = 0.2
+        const xRel = e.clientX / window.innerWidth - 0.5
+        const yRel = -(e.clientY / window.innerHeight - 0.5)
+        prevTween?.stop()
+        prevTween = new tweenJs.Tween(camera.position).to(
+          {
+            x: initX + xRel * SCALE,
+            y: initY + yRel * SCALE
+          },
+          0
+        )
+        prevTween.start()
+        camera.updateProjectionMatrix()
+      },
+      { signal: this.abortSignal }
+    )
   }
 }

package/src/three/modules/blockBreakParticles.ts

@@ -19,7 +19,7 @@ function ensureTintsLoaded(): void {
 
 function prepareTints(data: any): Record<string, [number, number, number]> {
   const result: Record<string, [number, number, number]> = {}
-  const defaultColor = tintToGl(data.default ?? 0xFFFFFF)
+  const defaultColor = tintToGl(data.default ?? 0xffffff)
   if (data.data) {
     for (const entry of data.data) {
       const color = tintToGl(entry.color)
@@ -36,11 +36,7 @@ function prepareTints(data: any): Record<string, [number, number, number]> {
 }
 
 function tintToGl(tint: number): [number, number, number] {
-  return [
-    ((tint >> 16) & 0xFF) / 255,
-    ((tint >> 8) & 0xFF) / 255,
-    (tint & 0xFF) / 255,
-  ]
+  return [((tint >> 16) & 0xff) / 255, ((tint >> 8) & 0xff) / 255, (tint & 0xff) / 255]
 }
 
 function resolveTintColor(blockName: string, biomeName: string): [number, number, number] {
@@ -63,9 +59,15 @@ function resolveTintColor(blockName: string, biomeName: string): [number, number
 interface BreakParticle {
   mesh: THREE.Mesh
   active: boolean
-  x: number; y: number; z: number
-  prevX: number; prevY: number; prevZ: number
-  xd: number; yd: number; zd: number
+  x: number
+  y: number
+  z: number
+  prevX: number
+  prevY: number
+  prevZ: number
+  xd: number
+  yd: number
+  zd: number
   age: number
   maxAge: number
   onGround: boolean
@@ -232,12 +234,24 @@ export class BlockBreakParticlesModule implements RendererModuleController {
 
     // Override position on the hit face axis to be at face + 0.1 offset outward
     switch (face) {
-      case 0: py = worldY - 0.1; break
-      case 1: py = worldY + 1.0 + 0.1; break
-      case 2: pz = worldZ - 0.1; break
-      case 3: pz = worldZ + 1.0 + 0.1; break
-      case 4: px = worldX - 0.1; break
-      case 5: px = worldX + 1.0 + 0.1; break
+      case 0:
+        py = worldY - 0.1
+        break
+      case 1:
+        py = worldY + 1.0 + 0.1
+        break
+      case 2:
+        pz = worldZ - 0.1
+        break
+      case 3:
+        pz = worldZ + 1.0 + 0.1
+        break
+      case 4:
+        px = worldX - 0.1
+        break
+      case 5:
+        px = worldX + 1.0 + 0.1
+        break
     }
 
     // Small random velocity, heavily damped
@@ -251,12 +265,17 @@ export class BlockBreakParticlesModule implements RendererModuleController {
   }
 
   private createParticle(
-    px: number, py: number, pz: number,
-    xd: number, yd: number, zd: number,
+    px: number,
+    py: number,
+    pz: number,
+    xd: number,
+    yd: number,
+    zd: number,
     maxAge: number,
     texInfo: { u: number; v: number; su: number; sv: number },
     floorMap: number[],
-    blockX: number, blockZ: number,
+    blockX: number,
+    blockZ: number,
     scaleFactor = 1.0,
     tintColor: [number, number, number] = [1, 1, 1]
   ): void {
@@ -282,9 +301,15 @@ export class BlockBreakParticlesModule implements RendererModuleController {
     this.setGeometryUVs(particle.mesh.geometry as THREE.PlaneGeometry, particleU, particleV, particleSU, particleSV)
 
     particle.active = true
-    particle.x = px; particle.y = py; particle.z = pz
-    particle.prevX = px; particle.prevY = py; particle.prevZ = pz
-    particle.xd = xd; particle.yd = yd; particle.zd = zd
+    particle.x = px
+    particle.y = py
+    particle.z = pz
+    particle.prevX = px
+    particle.prevY = py
+    particle.prevZ = pz
+    particle.xd = xd
+    particle.yd = yd
+    particle.zd = zd
     particle.age = 0
     particle.maxAge = maxAge
     particle.onGround = false
@@ -321,15 +346,21 @@ export class BlockBreakParticlesModule implements RendererModuleController {
     const particle: BreakParticle = {
       mesh,
       active: false,
-      x: 0, y: 0, z: 0,
-      prevX: 0, prevY: 0, prevZ: 0,
-      xd: 0, yd: 0, zd: 0,
+      x: 0,
+      y: 0,
+      z: 0,
+      prevX: 0,
+      prevY: 0,
+      prevZ: 0,
+      xd: 0,
+      yd: 0,
+      zd: 0,
       age: 0,
       maxAge: 0,
       onGround: false,
       floorMap: [],
       blockX: 0,
-      blockZ: 0,
+      blockZ: 0
     }
 
     this.particles.push(particle)
@@ -402,7 +433,7 @@ export class BlockBreakParticlesModule implements RendererModuleController {
       u: texInfo.u,
       v: texInfo.v,
       su: texInfo.su ?? atlasJson.suSv,
-      sv: texInfo.sv ?? atlasJson.suSv,
+      sv: texInfo.sv ?? atlasJson.suSv
     }
   }
 
@@ -424,7 +455,7 @@ export class BlockBreakParticlesModule implements RendererModuleController {
       map: atlasTexture,
       vertexColors: true,
       transparent: true,
-      alphaTest: 0.1,
+      alphaTest: 0.1
     })
   }
 }
@@ -434,5 +465,5 @@ export const blockBreakParticlesManifest: RendererModuleManifest = {
   controller: BlockBreakParticlesModule,
   enabledDefault: true,
   cannotBeDisabled: true,
-  requiresHeightmap: false,
+  requiresHeightmap: false
 }

package/src/three/modules/cameraBobbing.ts

@@ -7,7 +7,7 @@ export class CameraBobbingModule implements RendererModuleController {
   private lastBobWalkDist = 0
   private lastBobTickTime = 0
 
-  constructor(private readonly worldRenderer: WorldRendererThree) { }
+  constructor(private readonly worldRenderer: WorldRendererThree) {}
 
   enable(): void {
     this.enabled = true
@@ -29,10 +29,7 @@ export class CameraBobbingModule implements RendererModuleController {
     // Spectator (gm3) flies through blocks and does not "walk" — view bobbing
     // there only makes the camera feel jittery/unstable. Keep it gated even
     // when the user has `viewBobbing` enabled in settings.
-    const shouldBobCamera =
-      config.viewBobbing
-      && perspective === 'first_person'
-      && !this.worldRenderer.playerStateUtils.isSpectator()
+    const shouldBobCamera = config.viewBobbing && perspective === 'first_person' && !this.worldRenderer.playerStateUtils.isSpectator()
 
     if (shouldBobCamera) {
       if (this.worldRenderer.playerStateReactive.walkDist !== this.lastBobWalkDist) {
@@ -62,5 +59,5 @@ export const cameraBobbingManifest: RendererModuleManifest = {
   id: 'cameraBobbing',
   controller: CameraBobbingModule,
   enabledDefault: true,
-  cannotBeDisabled: true,
+  cannotBeDisabled: true
 }

package/src/three/modules/index.ts

@@ -10,5 +10,5 @@ export const BUILTIN_MODULES = {
   futuristicReveal: sciFiWorldRevealManifest,
   rain: rainManifest,
   cameraBobbing: cameraBobbingManifest,
-  blockBreakParticles: blockBreakParticlesManifest,
+  blockBreakParticles: blockBreakParticlesManifest
 }

package/src/three/modules/rain.ts

@@ -32,7 +32,7 @@ export class RainModule implements RendererModuleController {
   constructor(private readonly worldRenderer: WorldRendererThree) {
     this.configUnsubs.push(
       this.worldRenderer.onReactiveConfigUpdated('rainColor', () => this.syncRainAppearance()),
-      this.worldRenderer.onReactiveConfigUpdated('rainOpacity', () => this.syncRainAppearance()),
+      this.worldRenderer.onReactiveConfigUpdated('rainOpacity', () => this.syncRainAppearance())
     )
   }
 
@@ -59,7 +59,7 @@ export class RainModule implements RendererModuleController {
     return this.worldRenderer.worldRendererConfig.isRaining === true
   }
 
-  render?: (deltaTime: number) => void = (deltaTime) => {
+  render?: (deltaTime: number) => void = deltaTime => {
     if (!this.enabled || !this.instancedMesh || !this.material) return
 
     const cameraPos = this.worldRenderer.getCameraPosition()
@@ -103,18 +103,13 @@ export class RainModule implements RendererModuleController {
       const heightY = cachedHeightmap?.[localZ * 16 + localX]
 
       // Respawn when: out of range, hit heightmap surface (heightY + 1 = block top face), or fell too far
-      const shouldRespawn = horizontalDist > RANGE ||
-        (heightY !== undefined && heightY !== -32768 && worldY <= heightY + 1 + particle.despawnOffset) ||
-        relativeY < RESPAWN_BELOW
+      const shouldRespawn =
+        horizontalDist > RANGE || (heightY !== undefined && heightY !== -32768 && worldY <= heightY + 1 + particle.despawnOffset) || relativeY < RESPAWN_BELOW
 
       if (shouldRespawn) {
         this.respawnParticle(position)
         const speed = FALL_SPEED_MIN + Math.random() * (FALL_SPEED_MAX - FALL_SPEED_MIN)
-        particle.velocity.set(
-          (Math.random() - 0.5) * HORIZONTAL_DRIFT,
-          -speed,
-          (Math.random() - 0.5) * HORIZONTAL_DRIFT,
-        )
+        particle.velocity.set((Math.random() - 0.5) * HORIZONTAL_DRIFT, -speed, (Math.random() - 0.5) * HORIZONTAL_DRIFT)
         particle.despawnOffset = Math.random() * 0.5
       }
 
@@ -159,7 +154,7 @@ export class RainModule implements RendererModuleController {
       opacity: Math.max(0, Math.min(1, rainOpacity)),
       // Must write depth so log-depth blocks occlude rain correctly (see cubeBlockShader).
       depthWrite: true,
-      fog: false,
+      fog: false
     })
 
     this.instancedMesh = new THREE.InstancedMesh(this.geometry, this.material, PARTICLE_COUNT)
@@ -177,13 +172,9 @@ export class RainModule implements RendererModuleController {
 
       const speed = FALL_SPEED_MIN + Math.random() * (FALL_SPEED_MAX - FALL_SPEED_MIN)
       this.particles.push({
-        velocity: new THREE.Vector3(
-          (Math.random() - 0.5) * HORIZONTAL_DRIFT,
-          -speed,
-          (Math.random() - 0.5) * HORIZONTAL_DRIFT,
-        ),
+        velocity: new THREE.Vector3((Math.random() - 0.5) * HORIZONTAL_DRIFT, -speed, (Math.random() - 0.5) * HORIZONTAL_DRIFT),
         age: 0,
-        despawnOffset: Math.random() * 0.5,
+        despawnOffset: Math.random() * 0.5
       })
     }
 
@@ -194,11 +185,7 @@ export class RainModule implements RendererModuleController {
   private respawnParticle(position: THREE.Vector3): void {
     const angle = Math.random() * Math.PI * 2
     const distance = Math.random() * RANGE
-    position.set(
-      Math.cos(angle) * distance,
-      HEIGHT,
-      Math.sin(angle) * distance,
-    )
+    position.set(Math.cos(angle) * distance, HEIGHT, Math.sin(angle) * distance)
   }
 }
 
@@ -206,5 +193,5 @@ export const rainManifest: RendererModuleManifest = {
   id: 'rain',
   controller: RainModule,
   enabledDefault: false,
-  requiresHeightmap: true,
+  requiresHeightmap: true
 }

package/src/three/modules/sciFiWorldReveal.ts

@@ -53,7 +53,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
     transparent: true,
     opacity: 1,
     blending: THREE.AdditiveBlending,
-    depthWrite: false,
+    depthWrite: false
   })
 
   private readonly wireframeGlowMaterial = new THREE.LineBasicMaterial({
@@ -61,7 +61,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
     transparent: true,
     opacity: 0.55,
     blending: THREE.AdditiveBlending,
-    depthWrite: false,
+    depthWrite: false
   })
 
   constructor(private readonly worldRenderer: WorldRendererThree) {
@@ -119,12 +119,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
 
     this.tryStartGlobalWave(now)
 
-    if (
-      !this.globalWaveStarted &&
-      this.firstQueuedMs !== null &&
-      this.sections.size > 0 &&
-      now - this.firstQueuedMs >= GLOBAL_START_FALLBACK_MS
-    ) {
+    if (!this.globalWaveStarted && this.firstQueuedMs !== null && this.sections.size > 0 && now - this.firstQueuedMs >= GLOBAL_START_FALLBACK_MS) {
       this.startGlobalWave(now)
     }
 
@@ -209,7 +204,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
       wireframeGroup: null,
       mesh,
       savedMaterial: null,
-      pulseOffset: Math.random() * Math.PI * 2,
+      pulseOffset: Math.random() * Math.PI * 2
     })
 
     mesh.visible = false
@@ -343,7 +338,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
       mat.color.setRGB((13 / 255) * intensity, (234 / 255) * intensity, (238 / 255) * intensity)
     }
     if (glow?.material) {
-      (glow.material as THREE.LineBasicMaterial).opacity = basePulse * 0.4
+      ;(glow.material as THREE.LineBasicMaterial).opacity = basePulse * 0.4
     }
   }
 
@@ -357,7 +352,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
     }
     const mesh = section.mesh
     if (mesh && section.savedMaterial && !Array.isArray(mesh.material)) {
-      (mesh.material as THREE.Material).opacity = eased
+      ;(mesh.material as THREE.Material).opacity = eased
     }
     this.setShaderMeshesVisible(section.key, eased > 0.001)
   }
@@ -430,7 +425,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
   private unhideAllSectionMeshes(): void {
     for (const obj of Object.values(this.worldRenderer.chunkMeshManager.sectionObjects)) {
       if (!obj) continue
-      obj.traverse((child) => {
+      obj.traverse(child => {
         if (child instanceof THREE.Mesh && (child.name === 'mesh' || child.name === 'shaderMesh')) {
           child.visible = true
         }
@@ -441,7 +436,7 @@ export class SciFiWorldRevealModule implements RendererModuleController {
   private disposeWireframeGroup(group: THREE.Group): void {
     this.worldRenderer.sceneOrigin.removeAndUntrackAll(group)
     this.worldRenderer.realScene.remove(group)
-    group.traverse((child) => {
+    group.traverse(child => {
       const line = child as THREE.LineSegments
       line.geometry?.dispose()
       const mat = line.material
@@ -469,27 +464,18 @@ export class SciFiWorldRevealModule implements RendererModuleController {
     return wireframeGeom
   }
 
-  private addEdge(
-    positions: Float32Array,
-    i0: number,
-    i1: number,
-    linePositions: number[],
-    edgeSet: Set<string>,
-  ): void {
+  private addEdge(positions: Float32Array, i0: number, i1: number, linePositions: number[], edgeSet: Set<string>): void {
     const minI = Math.min(i0, i1)
     const maxI = Math.max(i0, i1)
     const edgeKey = `${minI}-${maxI}`
     if (edgeSet.has(edgeKey)) return
     edgeSet.add(edgeKey)
-    linePositions.push(
-      positions[i0 * 3]!, positions[i0 * 3 + 1]!, positions[i0 * 3 + 2]!,
-      positions[i1 * 3]!, positions[i1 * 3 + 1]!, positions[i1 * 3 + 2]!,
-    )
+    linePositions.push(positions[i0 * 3]!, positions[i0 * 3 + 1]!, positions[i0 * 3 + 2]!, positions[i1 * 3]!, positions[i1 * 3 + 1]!, positions[i1 * 3 + 2]!)
   }
 }
 
 export const sciFiWorldRevealManifest: RendererModuleManifest = {
   id: 'futuristicReveal',
   controller: SciFiWorldRevealModule,
-  enabledDefault: true,
+  enabledDefault: true
 }

package/src/three/modules/starfield.ts

@@ -33,7 +33,7 @@ class StarfieldMaterial extends THREE.ShaderMaterial {
 
           #include <tonemapping_fragment>
           #include <${threeVersion >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
-        }`,
+        }`
     })
   }
 }
@@ -46,7 +46,7 @@ export class StarfieldModule implements RendererModuleController {
   /** Current star brightness multiplier; lerps toward 0 while raining, 1 otherwise. */
   private fade = 1
 
-  constructor(private readonly worldRenderer: WorldRendererThree) { }
+  constructor(private readonly worldRenderer: WorldRendererThree) {}
 
   enable(): void {
     if (this.enabled) return
@@ -76,7 +76,7 @@ export class StarfieldModule implements RendererModuleController {
     return this.currentTime > nightTime && this.currentTime < morningStart
   }
 
-  render?: (deltaTime: number) => void = (deltaTime) => {
+  render?: (deltaTime: number) => void = deltaTime => {
     if (!this.points) return
     this.points.position.set(0, 0, 0)
 
@@ -124,13 +124,7 @@ export class StarfieldModule implements RendererModuleController {
     const geometry = new THREE.BufferGeometry()
 
     const genStar = (r: number): THREE.Vector3 =>
-      new THREE.Vector3().setFromSpherical(
-        new THREE.Spherical(
-          r,
-          Math.acos(1 - Math.random() * 2),
-          Math.random() * 2 * Math.PI
-        )
-      )
+      new THREE.Vector3().setFromSpherical(new THREE.Spherical(r, Math.acos(1 - Math.random() * 2), Math.random() * 2 * Math.PI))
 
     const positions: number[] = []
     const colors: number[] = []
@@ -175,8 +169,8 @@ export class StarfieldModule implements RendererModuleController {
   private removeStars(): void {
     if (!this.points) return
 
-    this.points.geometry.dispose();
-    (this.points.material as THREE.Material).dispose()
+    this.points.geometry.dispose()
+    ;(this.points.material as THREE.Material).dispose()
     this.worldRenderer.scene.remove(this.points)
     this.points = undefined
   }
@@ -186,5 +180,5 @@ export const starfieldManifest: RendererModuleManifest = {
   id: 'starfield',
   controller: StarfieldModule,
   enabledDefault: true,
-  cannotBeDisabled: true,
+  cannotBeDisabled: true
 }

package/src/three/renderSlot.ts

@@ -5,31 +5,40 @@ import { versionToNumber } from 'mc-assets/dist/utils'
 import type { ResourcesManagerCommon } from '../resourcesManager'
 
 export type ResolvedItemModelRender = {
-  modelName: string,
+  modelName: string
   originalItemName?: string
 }
 
-export const renderSlot = (model: ResolvedItemModelRender, resourcesManager: ResourcesManagerCommon, debugIsQuickbar = false, fullBlockModelSupport = false): {
-  texture: string,
-  blockData: Record<string, { slice, path }> & { resolvedModel: BlockModel } | null,
-  scale: number | null,
-  slice: number[] | null,
-  modelName: string | null,
+export const renderSlot = (
+  model: ResolvedItemModelRender,
+  resourcesManager: ResourcesManagerCommon,
+  debugIsQuickbar = false,
+  fullBlockModelSupport = false
+): {
+  texture: string
+  blockData: (Record<string, { slice; path }> & { resolvedModel: BlockModel }) | null
+  scale: number | null
+  slice: number[] | null
+  modelName: string | null
 } => {
   let itemModelName = model.modelName
   const isItem = globalThis.loadedData.itemsByName[itemModelName]
 
   // #region normalize item name
-  if (versionToNumber(resourcesManager.currentResources!.version) < versionToNumber('1.13')) itemModelName = getRenamedData(isItem ? 'items' : 'blocks', itemModelName, resourcesManager.currentResources!.version, '1.13.1') as string
+  if (versionToNumber(resourcesManager.currentResources!.version) < versionToNumber('1.13'))
+    itemModelName = getRenamedData(isItem ? 'items' : 'blocks', itemModelName, resourcesManager.currentResources!.version, '1.13.1') as string
   // #endregion
 
-
   let itemTexture
 
   if (!fullBlockModelSupport) {
     const atlas = resourcesManager.currentResources?.guiAtlas?.json
     // todo atlas holds all rendered blocks, not all possibly rendered item/block models, need to request this on demand instead (this is how vanilla works)
-    const tryGetAtlasTexture = (name?: string) => name && atlas?.textures[name.replace('minecraft:', '').replace('block/', '').replace('blocks/', '').replace('item/', '').replace('items/', '').replace('_inventory', '')]
+    const tryGetAtlasTexture = (name?: string) =>
+      name &&
+      atlas?.textures[
+        name.replace('minecraft:', '').replace('block/', '').replace('blocks/', '').replace('item/', '').replace('items/', '').replace('_inventory', '')
+      ]
     const item = tryGetAtlasTexture(itemModelName) ?? tryGetAtlasTexture(model.originalItemName)
     if (item) {
       const x = item.u * atlas.width
@@ -44,23 +53,26 @@ export const renderSlot = (model: ResolvedItemModelRender, resourcesManager: Res
     }
   }
 
-  const blockToTopTexture = (r) => r.top ?? r
+  const blockToTopTexture = r => r.top ?? r
 
   try {
     if (!resourcesManager.currentResources?.itemsRenderer) throw new Error('Items renderer is not available')
     itemTexture =
-      resourcesManager.currentResources.itemsRenderer.getItemTexture(itemModelName, {}, false, fullBlockModelSupport)
-      ?? (model.originalItemName ? resourcesManager.currentResources.itemsRenderer.getItemTexture(model.originalItemName, {}, false, fullBlockModelSupport) : undefined)
-      ?? resourcesManager.currentResources.itemsRenderer.getItemTexture('item/missing_texture')!
+      resourcesManager.currentResources.itemsRenderer.getItemTexture(itemModelName, {}, false, fullBlockModelSupport) ??
+      (model.originalItemName
+        ? resourcesManager.currentResources.itemsRenderer.getItemTexture(model.originalItemName, {}, false, fullBlockModelSupport)
+        : undefined) ??
+      resourcesManager.currentResources.itemsRenderer.getItemTexture('item/missing_texture')!
   } catch (err) {
     // get resourcepack from resource manager
-    reportError?.(`Failed to render item ${itemModelName} (original: ${model.originalItemName}) on ${resourcesManager.currentResources!.version} (resourcepack: TODO!): ${err.stack}`)
+    reportError?.(
+      `Failed to render item ${itemModelName} (original: ${model.originalItemName}) on ${resourcesManager.currentResources!.version} (resourcepack: TODO!): ${err.stack}`
+    )
     itemTexture = blockToTopTexture(resourcesManager.currentResources!.itemsRenderer!.getItemTexture('errored')!)
   }
 
   itemTexture ??= blockToTopTexture(resourcesManager.currentResources!.itemsRenderer!.getItemTexture('unknown')!)
 
-
   if ('type' in itemTexture) {
     // is item
     return {

package/src/three/rendererModuleSystem.ts

@@ -17,9 +17,7 @@ export interface RendererModuleController {
 /**
  * Constructor type for module controllers
  */
-export type RendererModuleControllerConstructor = new (
-  worldRenderer: WorldRendererThree
-) => RendererModuleController
+export type RendererModuleControllerConstructor = new (worldRenderer: WorldRendererThree) => RendererModuleController
 
 export interface RendererModuleManifest {
   id: string