minecraft-renderer 0.1.79 → 0.1.81

package/src/mesher-shared/standaloneRenderer.ts

@@ -9,7 +9,7 @@ import { BlockElement, buildRotationMatrix, elemFaces, matmul3, matmulmat3, veca
 
 type NeighborSide = 'up' | 'down' | 'east' | 'west' | 'north' | 'south'
 
-function tintToGl (tint) {
+function tintToGl(tint) {
   const r = (tint >> 16) & 0xff
   const g = (tint >> 8) & 0xff
   const b = tint & 0xff
@@ -17,7 +17,7 @@ function tintToGl (tint) {
 }
 
 type Neighbors = Partial<Record<NeighborSide, boolean>>
-function renderElement (element: BlockElement, doAO: boolean, attr, globalMatrix, globalShift, block: Block | undefined, biome: string, neighbors: Neighbors) {
+function renderElement(element: BlockElement, doAO: boolean, attr, globalMatrix, globalShift, block: Block | undefined, biome: string, neighbors: Neighbors) {
   const cursor = new Vec3(0, 0, 0)
 
   // const key = `${position.x},${position.y},${position.z}`
@@ -71,26 +71,17 @@ function renderElement (element: BlockElement, doAO: boolean, attr, globalMatrix
 
     // UV rotation
     const r = eFace.rotation || 0
-    const uvcs = Math.cos(r * Math.PI / 180)
-    const uvsn = -Math.sin(r * Math.PI / 180)
+    const uvcs = Math.cos((r * Math.PI) / 180)
+    const uvsn = -Math.sin((r * Math.PI) / 180)
 
     let localMatrix = null as any
     let localShift = null as any
 
     if (element.rotation) {
       // todo do we support rescale?
-      localMatrix = buildRotationMatrix(
-        element.rotation.axis,
-        element.rotation.angle
-      )
-
-      localShift = vecsub3(
-        element.rotation.origin,
-        matmul3(
-          localMatrix,
-          element.rotation.origin
-        )
-      )
+      localMatrix = buildRotationMatrix(element.rotation.axis, element.rotation.angle)
+
+      localShift = vecsub3(element.rotation.origin, matmul3(localMatrix, element.rotation.origin))
     }
 
     const aos: number[] = []
@@ -98,21 +89,13 @@ function renderElement (element: BlockElement, doAO: boolean, attr, globalMatrix
     // const baseLight = world.getLight(neighborPos, undefined, undefined, block.name) / 15
     const baseLight = 1
     for (const pos of corners) {
-      let vertex = [
-        (pos[0] ? maxx : minx),
-        (pos[1] ? maxy : miny),
-        (pos[2] ? maxz : minz)
-      ]
+      let vertex = [pos[0] ? maxx : minx, pos[1] ? maxy : miny, pos[2] ? maxz : minz]
 
       vertex = vecadd3(matmul3(localMatrix, vertex), localShift)
       vertex = vecadd3(matmul3(globalMatrix, vertex), globalShift)
       vertex = vertex.map(v => v / 16)
 
-      attr.positions.push(
-        vertex[0]/*  + (cursor.x & 15) - 8 */,
-        vertex[1]/*  + (cursor.y & 15) x */,
-        vertex[2]/*  + (cursor.z & 15) - 8 */
-      )
+      attr.positions.push(vertex[0] /*  + (cursor.x & 15) - 8 */, vertex[1] /*  + (cursor.y & 15) x */, vertex[2] /*  + (cursor.z & 15) - 8 */)
 
       attr.normals.push(...dir)
 
@@ -128,9 +111,9 @@ function renderElement (element: BlockElement, doAO: boolean, attr, globalMatrix
         const side2Block = 0
         const cornerBlock = 0
 
-        const ao = (side1Block && side2Block) ? 0 : (3 - (side1Block + side2Block + cornerBlock))
+        const ao = side1Block && side2Block ? 0 : 3 - (side1Block + side2Block + cornerBlock)
         // todo light should go upper on lower blocks
-        light = (ao + 1) / 4 * (cornerLightResult / 15)
+        light = ((ao + 1) / 4) * (cornerLightResult / 15)
         aos.push(ao)
       }
 
@@ -151,22 +134,21 @@ function renderElement (element: BlockElement, doAO: boolean, attr, globalMatrix
     // }
 
     if (doAO && aos[0] + aos[3] >= aos[1] + aos[2]) {
-      attr.indices.push(
-
-        ndx, ndx + 3, ndx + 2,
-        ndx, ndx + 1, ndx + 3
-      )
+      attr.indices.push(ndx, ndx + 3, ndx + 2, ndx, ndx + 1, ndx + 3)
     } else {
-      attr.indices.push(
-
-        ndx, ndx + 1, ndx + 2,
-        ndx + 2, ndx + 1, ndx + 3
-      )
+      attr.indices.push(ndx, ndx + 1, ndx + 2, ndx + 2, ndx + 1, ndx + 3)
     }
   }
 }
 
-export const renderBlockThreeAttr = (models: BlockModelPartsResolved, block: Block | undefined, biome: string, mcData: IndexedData, variants = [], neighbors: Neighbors = {}) => {
+export const renderBlockThreeAttr = (
+  models: BlockModelPartsResolved,
+  block: Block | undefined,
+  biome: string,
+  mcData: IndexedData,
+  variants = [],
+  neighbors: Neighbors = {}
+) => {
   const sx = 0
   const sy = 0
   const sz = 0
@@ -184,7 +166,7 @@ export const renderBlockThreeAttr = (models: BlockModelPartsResolved, block: Blo
     t_colors: [],
     t_uvs: [],
     indices: [],
-    tiles: {},
+    tiles: {}
   } as Record<string, any>
 
   for (const [i, modelVars] of models.entries()) {
@@ -194,7 +176,11 @@ export const renderBlockThreeAttr = (models: BlockModelPartsResolved, block: Blo
     let globalShift = null as any
     for (const axis of ['x', 'y', 'z'] as const) {
       if (axis in model) {
-        if (globalMatrix) { globalMatrix = matmulmat3(globalMatrix, buildRotationMatrix(axis, -(model[axis] ?? 0))) } else { globalMatrix = buildRotationMatrix(axis, -(model[axis] ?? 0)) }
+        if (globalMatrix) {
+          globalMatrix = matmulmat3(globalMatrix, buildRotationMatrix(axis, -(model[axis] ?? 0)))
+        } else {
+          globalMatrix = buildRotationMatrix(axis, -(model[axis] ?? 0))
+        }
       }
     }
     if (globalMatrix) {
@@ -212,9 +198,19 @@ export const renderBlockThreeAttr = (models: BlockModelPartsResolved, block: Blo
   let ndx = attr.positions.length / 3
   for (let i = 0; i < attr.t_positions.length / 12; i++) {
     attr.indices.push(
-      ndx, ndx + 1, ndx + 2, ndx + 2, ndx + 1, ndx + 3,
+      ndx,
+      ndx + 1,
+      ndx + 2,
+      ndx + 2,
+      ndx + 1,
+      ndx + 3,
       // back face
-      ndx, ndx + 2, ndx + 1, ndx + 2, ndx + 3, ndx + 1
+      ndx,
+      ndx + 2,
+      ndx + 1,
+      ndx + 2,
+      ndx + 3,
+      ndx + 1
     )
     ndx += 4
   }
@@ -266,6 +262,6 @@ export const getThreeBlockModelGroup = (material: THREE.Material, ...args: Param
   // return new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), new THREE.MeshPhongMaterial({ color: 0x00_00_ff, transparent: true, opacity: 0.5 }))
 }
 
-export const setBlockPosition = (object: THREE.Object3D, position: { x: number, y: number, z: number }) => {
+export const setBlockPosition = (object: THREE.Object3D, position: { x: number; y: number; z: number }) => {
   object.position.set(position.x + 0.5, position.y + 0.5, position.z + 0.5)
 }

package/src/mesher-shared/tests/faceOcclusion.test.ts

@@ -0,0 +1,179 @@
+//@ts-nocheck
+import { test, expect, beforeEach } from 'vitest'
+import MinecraftData from 'minecraft-data'
+import blocksAtlasesJson from 'mc-assets/dist/blocksAtlases.json'
+import blockStatesModels from 'mc-assets/dist/blockStatesModels.json'
+import worldBlockProvider from 'mc-assets/dist/worldBlockProvider'
+import PrismarineBlockLoader from 'prismarine-block'
+import Chunks from 'prismarine-chunk'
+import { Vec3 } from 'vec3'
+import { blockRendersSolid, getOcclusionShape, faceIsCulled, resetFaceOcclusionCache, oppositeDir, buildModelGlobalMatrix } from '../faceOcclusion'
+import { elemFaces } from '../modelsGeometryCommon'
+import { setBlockStatesData, getSectionGeometry } from '../models'
+import { World } from '../world'
+
+const VERSION = '1.18.2'
+
+beforeEach(() => {
+  resetFaceOcclusionCache()
+  const mcData = MinecraftData(VERSION)
+  setBlockStatesData(blockStatesModels, blocksAtlasesJson, false, true, VERSION, { blocks: mcData.blocksArray })
+})
+
+function blockProvider() {
+  return (globalThis as any).blockProvider
+}
+
+function farmlandElement(provider: ReturnType<typeof worldBlockProvider>) {
+  const mcData = MinecraftData(VERSION)
+  const farmlandId = mcData.blocksByName.farmland!.defaultState
+  const blockObj = PrismarineBlockLoader(VERSION).fromStateId(farmlandId, 1)
+  const models = provider.getAllResolvedModels0_1({ name: blockObj.name, properties: blockObj.getProperties() }, false)
+  return { farmlandId, element: models[0]![0]!.elements![0]! }
+}
+
+function stairStateId(props: Record<string, string | boolean>) {
+  const mcData = MinecraftData(VERSION)
+  const Block = PrismarineBlockLoader(VERSION)
+  for (let sid = mcData.blocksByName.cut_copper_stairs!.minStateId; sid <= mcData.blocksByName.cut_copper_stairs!.maxStateId; sid++) {
+    const p = Block.fromStateId(sid, 1).getProperties() as Record<string, string>
+    let match = true
+    for (const [k, v] of Object.entries(props)) {
+      if (p[k] !== v) {
+        match = false
+        break
+      }
+    }
+    if (match) return sid
+  }
+  throw new Error(`no stair state for ${JSON.stringify(props)}`)
+}
+
+function stairModel(stateId: number, provider: ReturnType<typeof worldBlockProvider>) {
+  const blockObj = PrismarineBlockLoader(VERSION).fromStateId(stateId, 1)
+  return provider.getAllResolvedModels0_1({ name: blockObj.name, properties: blockObj.getProperties() }, false)[0]![0]!
+}
+
+test('blockRendersSolid: farmland opaque, glass and leaves not', () => {
+  const Block = PrismarineBlockLoader(VERSION)
+  const farmland = Block.fromStateId(MinecraftData(VERSION).blocksByName.farmland!.defaultState, 1)
+  const glass = Block.fromStateId(MinecraftData(VERSION).blocksByName.glass!.defaultState, 1)
+  const leaves = Block.fromStateId(MinecraftData(VERSION).blocksByName.oak_leaves!.defaultState, 1)
+  expect(blockRendersSolid(farmland)).toBe(true)
+  expect(blockRendersSolid(glass)).toBe(false)
+  expect(blockRendersSolid(leaves)).toBe(false)
+})
+
+test('getOcclusionShape: full cube covers entire plane', () => {
+  const mcData = MinecraftData(VERSION)
+  const stoneId = mcData.blocksByName.stone!.defaultState
+  const shape = getOcclusionShape(VERSION, stoneId, [1, 0, 0], blockProvider())
+  for (let row = 0; row < 16; row++) {
+    expect(shape[row]).toBe(0xffff)
+  }
+})
+
+test('getOcclusionShape: farmland side is shorter than full height', () => {
+  const mcData = MinecraftData(VERSION)
+  const farmlandId = mcData.blocksByName.farmland!.defaultState
+  const eastShape = getOcclusionShape(VERSION, farmlandId, [1, 0, 0], blockProvider())
+  let covered = 0
+  for (let row = 0; row < 16; row++) {
+    for (let col = 0; col < 16; col++) {
+      if (eastShape[row]! & (1 << col)) covered++
+    }
+  }
+  expect(covered).toBeLessThan(16 * 16)
+  expect(covered).toBeGreaterThan(0)
+})
+
+test('getOcclusionShape: west-facing stair fully covers west plane (step on west side)', () => {
+  const westId = stairStateId({ facing: 'west', half: 'bottom', shape: 'straight', waterlogged: false })
+  const westShape = getOcclusionShape(VERSION, westId, [-1, 0, 0], blockProvider())
+  for (let row = 0; row < 16; row++) {
+    expect(westShape[row]).toBe(0xffff)
+  }
+})
+
+test('faceIsCulled: farmland east face culled by adjacent farmland', () => {
+  const provider = blockProvider()
+  const { farmlandId, element } = farmlandElement(provider)
+  expect(faceIsCulled(VERSION, element, 'east', farmlandId, { stateId: farmlandId, name: 'farmland' }, provider, [1, 0, 0], null)).toBe(true)
+})
+
+test('faceIsCulled: farmland east face not culled by air', () => {
+  const provider = blockProvider()
+  const { farmlandId, element } = farmlandElement(provider)
+  expect(faceIsCulled(VERSION, element, 'east', 0, { stateId: farmlandId, name: 'farmland' }, provider, [1, 0, 0], null)).toBe(false)
+})
+
+test('faceIsCulled: glass identical neighbor still culls', () => {
+  const mcData = MinecraftData(VERSION)
+  const glassId = mcData.blocksByName.glass!.defaultState
+  const provider = blockProvider()
+  const models = provider.getAllResolvedModels0_1({ name: 'glass', properties: {} }, false)
+  const element = models[0]![0]!.elements![0]!
+  expect(faceIsCulled(VERSION, element, 'north', glassId, { stateId: glassId, name: 'glass' }, provider, [0, 0, -1], null)).toBe(true)
+})
+
+test('legacy mesher: adjacent farmland culled internal side', () => {
+  const mcData = MinecraftData(VERSION)
+  const Chunk = Chunks(VERSION) as any
+  const chunk = new Chunk(undefined as any)
+  const farmlandId = mcData.blocksByName.farmland!.defaultState
+  chunk.setBlockStateId(new Vec3(0, 0, 0), farmlandId)
+  chunk.setBlockStateId(new Vec3(1, 0, 0), farmlandId)
+  const world = new World(VERSION)
+  world.addColumn(0, 0, chunk.toJson())
+  const geo = getSectionGeometry(0, 0, 0, world, 16)
+  expect(geo.indicesCount / 6).toBe(10)
+})
+
+test('faceIsCulled: east stair interior faces culled against identical stair', () => {
+  const stairId = stairStateId({ facing: 'east', half: 'bottom', shape: 'straight', waterlogged: false })
+  const provider = blockProvider()
+  const model = stairModel(stairId, provider)
+  const globalMatrix = buildModelGlobalMatrix(model)
+  let culled = 0
+  for (const element of model.elements ?? []) {
+    for (const face of Object.keys(element.faces)) {
+      const localDir = elemFaces[face as keyof typeof elemFaces].dir as [number, number, number]
+      const worldDir = [Math.round(localDir[0]), Math.round(localDir[1]), Math.round(localDir[2])] as [number, number, number]
+      if (faceIsCulled(VERSION, element, face, stairId, { stateId: stairId, name: 'cut_copper_stairs' }, provider, worldDir, globalMatrix)) {
+        culled++
+      }
+    }
+  }
+  expect(culled).toBeGreaterThan(0)
+})
+
+test('faceIsCulled: west stair interior faces culled against identical west stair', () => {
+  const stairId = stairStateId({ facing: 'west', half: 'bottom', shape: 'straight', waterlogged: false })
+  const provider = blockProvider()
+  const model = stairModel(stairId, provider)
+  const globalMatrix = buildModelGlobalMatrix(model)
+  expect(globalMatrix).not.toBeNull()
+  let culled = 0
+  for (const element of model.elements ?? []) {
+    for (const face of Object.keys(element.faces)) {
+      const localDir = elemFaces[face as keyof typeof elemFaces].dir
+      const rotated = globalMatrix
+        ? [
+            globalMatrix[0][0] * localDir[0] + globalMatrix[0][1] * localDir[1] + globalMatrix[0][2] * localDir[2],
+            globalMatrix[1][0] * localDir[0] + globalMatrix[1][1] * localDir[1] + globalMatrix[1][2] * localDir[2],
+            globalMatrix[2][0] * localDir[0] + globalMatrix[2][1] * localDir[1] + globalMatrix[2][2] * localDir[2]
+          ]
+        : localDir
+      const worldDir = [Math.round(rotated[0]), Math.round(rotated[1]), Math.round(rotated[2])] as [number, number, number]
+      if (faceIsCulled(VERSION, element, face, stairId, { stateId: stairId, name: 'cut_copper_stairs' }, provider, worldDir, globalMatrix)) {
+        culled++
+      }
+    }
+  }
+  expect(culled).toBeGreaterThan(0)
+})
+
+test('oppositeDir inverts cardinal directions', () => {
+  expect(oppositeDir([1, 0, 0])[0]).toBe(-1)
+  expect(oppositeDir([0, 1, 0])[1]).toBe(-1)
+})

package/src/mesher-shared/tests/liquidQuadInvariant.test.ts

@@ -3,14 +3,18 @@ import { test, expect } from 'vitest'
 import { setup } from '../../mesher-legacy/test/mesherTester'
 
 test('renderLiquid blend output satisfies 6/4 quad invariant with both windings', () => {
-  const { getGeometry } = setup('1.16.5', [
-    [[0, 0, 0], 'water'],
-    [[0, -1, 0], 'stone'],
-    [[1, 0, 0], 'stone'],
-    [[-1, 0, 0], 'stone'],
-    [[0, 0, 1], 'stone'],
-    [[0, 0, -1], 'stone'],
-  ], { noDebugTiles: true })
+  const { getGeometry } = setup(
+    '1.16.5',
+    [
+      [[0, 0, 0], 'water'],
+      [[0, -1, 0], 'stone'],
+      [[1, 0, 0], 'stone'],
+      [[-1, 0, 0], 'stone'],
+      [[0, 0, 1], 'stone'],
+      [[0, 0, -1], 'stone']
+    ],
+    { noDebugTiles: true }
+  )
 
   const { attr } = getGeometry()
   const blend = attr.blend

package/src/mesher-shared/vertexShading.ts

@@ -4,11 +4,7 @@ import type { MesherConfig } from './shared'
 export type FaceDirection = readonly [number, number, number]
 
 /** Directional face darkening (matches legacy `renderElement` in models.ts). */
-export function getSideShading(
-  dir: FaceDirection,
-  shadingTheme: MesherConfig['shadingTheme'],
-  cardinalLight: MesherConfig['cardinalLight']
-): number {
+export function getSideShading(dir: FaceDirection, shadingTheme: MesherConfig['shadingTheme'], cardinalLight: MesherConfig['cardinalLight']): number {
   if (shadingTheme === 'high-contrast') {
     return 0.8 + 0.5 * Math.max(0, 0.66 * dir[0] + 0.66 * dir[1] + 0.33 * dir[2])
   }
@@ -19,12 +15,7 @@ export function getSideShading(
 }
 
 /** Per-vertex brightness from AO (0–3) and corner light (0–15). */
-export function vertexLightFromAo(
-  ao: number,
-  cornerLight15: number,
-  sideShading: number,
-  shadingTheme: MesherConfig['shadingTheme']
-): number {
+export function vertexLightFromAo(ao: number, cornerLight15: number, sideShading: number, shadingTheme: MesherConfig['shadingTheme']): number {
   const lightNorm = cornerLight15 / 15
   if (shadingTheme === 'high-contrast') {
     return sideShading * ((ao + 1) / 4) * lightNorm

package/src/mesher-shared/world.ts

@@ -76,36 +76,31 @@ export class World {
     this.config.version = version
   }
 
-  getChannelLightNorm (pos: Vec3): { block: number, sky: number } {
-    if (!(pos instanceof Vec3)) pos = new Vec3(...pos as [number, number, number])
+  getChannelLightNorm(pos: Vec3): { block: number; sky: number } {
+    if (!(pos instanceof Vec3)) pos = new Vec3(...(pos as [number, number, number]))
     if (!this.config.enableLighting) return { block: 0, sky: 1 }
     const column = this.getColumnByPos(pos)
     if (!column || !hasChunkSection(column, pos)) return { block: 0, sky: 1 }
     const loc = posInChunk(pos)
     return {
       block: Math.min(15, column.getBlockLight(loc) + 2) / 15,
-      sky: Math.min(15, column.getSkyLight(loc) + 2) / 15,
+      sky: Math.min(15, column.getSkyLight(loc) + 2) / 15
     }
   }
 
   getLight(pos: Vec3, isNeighbor = false, skipMoreChecks = false, curBlockName = '') {
     // for easier testing
-    if (!(pos instanceof Vec3)) pos = new Vec3(...pos as [number, number, number])
+    if (!(pos instanceof Vec3)) pos = new Vec3(...(pos as [number, number, number]))
     const { enableLighting, skyLight } = this.config
     if (!enableLighting) return 15
     // const key = `${pos.x},${pos.y},${pos.z}`
     // if (lightsCache.has(key)) return lightsCache.get(key)
     const column = this.getColumnByPos(pos)
     if (!column || !hasChunkSection(column, pos)) return 15
-    let result = Math.min(
-      15,
-      Math.max(
-        column.getBlockLight(posInChunk(pos)),
-        Math.min(skyLight, column.getSkyLight(posInChunk(pos)))
-      ) + 2
-    )
+    let result = Math.min(15, Math.max(column.getBlockLight(posInChunk(pos)), Math.min(skyLight, column.getSkyLight(posInChunk(pos)))) + 2)
     // lightsCache.set(key, result)
-    if (result === 2 && [this.getBlock(pos)?.name ?? '', curBlockName].some(x => /_stairs|slab|glass_pane/.exec(x)) && !skipMoreChecks) { // todo this is obviously wrong
+    if (result === 2 && [this.getBlock(pos)?.name ?? '', curBlockName].some(x => /_stairs|slab|glass_pane/.exec(x)) && !skipMoreChecks) {
+      // todo this is obviously wrong
       const lights = [
         this.getLight(pos.offset(0, 1, 0), undefined, true),
         this.getLight(pos.offset(0, -1, 0), undefined, true),
@@ -156,7 +151,7 @@ export class World {
 
   getBlock(pos: Vec3, blockProvider?: WorldBlockProvider, attr?: { hadErrors?: boolean }): WorldBlock | null {
     // for easier testing
-    if (!(pos instanceof Vec3)) pos = new Vec3(...pos as [number, number, number])
+    if (!(pos instanceof Vec3)) pos = new Vec3(...(pos as [number, number, number]))
     const chunkKey = worldColumnKey(Math.floor(pos.x / 16) * 16, Math.floor(pos.z / 16) * 16)
     const modelOverride = this.customBlockModels.get(chunkKey)?.[getBlockPosKey(pos)]
 
@@ -190,11 +185,16 @@ export class World {
           b.name = namePropsStr.split('[')[0]
           const propsStr = namePropsStr.split('[')?.[1]?.split(']')
           if (propsStr) {
-            const newProperties = Object.fromEntries(propsStr.join('').split(',').map(x => {
-              let [key, val] = x.split('=')
-              if (!isNaN(val)) val = parseInt(val, 10)
-              return [key, val]
-            }))
+            const newProperties = Object.fromEntries(
+              propsStr
+                .join('')
+                .split(',')
+                .map(x => {
+                  let [key, val] = x.split('=')
+                  if (!isNaN(val)) val = parseInt(val, 10)
+                  return [key, val]
+                })
+            )
             b._properties = newProperties
           }
         }
@@ -228,7 +228,7 @@ export class World {
         block.models = blockProvider.getAllResolvedModels0_1(
           {
             name: block.name,
-            properties: props,
+            properties: props
           },
           useFallbackModel,
           issues,

package/src/mesher-shared/worldLighting.test.ts

@@ -3,10 +3,10 @@ import { describe, expect, it } from 'vitest'
 import { Vec3 } from 'vec3'
 import { World } from './world'
 
-function mockColumn (blockLight: number, skyLight: number, withSection = true) {
+function mockColumn(blockLight: number, skyLight: number, withSection = true) {
   return {
     getBlockLight: () => blockLight,
-    getSkyLight: () => skyLight,
+    getSkyLight: () => skyLight
   }
 }
 

package/src/performanceMonitor/PerformanceMonitor.ts

@@ -7,7 +7,7 @@ import {
   LONG_RENDER_TIME_MS,
   LOW_FPS_THRESHOLD,
   RENDER_TIME_HISTORY_SIZE,
-  SLOW_ENTITIES_RENDER_MS,
+  SLOW_ENTITIES_RENDER_MS
 } from './constants'
 import type { FramePerformanceSample, PerformanceInstabilityFactors } from './types'
 
@@ -40,22 +40,13 @@ export class PerformanceMonitor {
 
     const historyLen = this.renderTimeHistory.length
     const longFrames = this.renderTimeHistory.filter(t => t >= LONG_RENDER_TIME_MS).length
-    const constantLongRenderTime =
-      historyLen >= CONSTANT_LONG_RENDER_MIN_SAMPLES &&
-      longFrames / historyLen >= CONSTANT_LONG_RENDER_FRACTION
+    const constantLongRenderTime = historyLen >= CONSTANT_LONG_RENDER_MIN_SAMPLES && longFrames / historyLen >= CONSTANT_LONG_RENDER_FRACTION
 
     const tooManyTextures = sample.loadedTextureCount >= HIGH_TEXTURE_COUNT
 
-    const tooManyEntities =
-      lowFps &&
-      sample.entitiesMs >= SLOW_ENTITIES_RENDER_MS &&
-      sceneWithoutEntitiesMs <= FAST_SCENE_WITHOUT_ENTITIES_MS
+    const tooManyEntities = lowFps && sample.entitiesMs >= SLOW_ENTITIES_RENDER_MS && sceneWithoutEntitiesMs <= FAST_SCENE_WITHOUT_ENTITIES_MS
 
-    const hasKnownCause =
-      longRenderTime ||
-      constantLongRenderTime ||
-      tooManyEntities ||
-      tooManyTextures
+    const hasKnownCause = longRenderTime || constantLongRenderTime || tooManyEntities || tooManyTextures
 
     const unknownReason = lowFps && !hasKnownCause
 

package/src/performanceMonitor/formatPerformanceFactorsDebug.ts

@@ -1,12 +1,12 @@
 //@ts-nocheck
 import type { PerformanceInstabilityFactors } from './types'
 
-const FACTOR_CODES: Array<{ key: keyof PerformanceInstabilityFactors, code: string }> = [
+const FACTOR_CODES: Array<{ key: keyof PerformanceInstabilityFactors; code: string }> = [
   { key: 'longRenderTime', code: 'LR' },
   { key: 'constantLongRenderTime', code: 'CLR' },
   { key: 'tooManyEntities', code: 'ENT' },
   { key: 'tooManyTextures', code: 'TEX' },
-  { key: 'unknownReason', code: 'UNK' },
+  { key: 'unknownReason', code: 'UNK' }
 ]
 
 /** Compact debug overlay fragment, e.g. `LR+ENT` or empty string. */

package/src/performanceMonitor/index.ts

@@ -1,10 +1,6 @@
 //@ts-nocheck
 export type { FramePerformanceSample, PerformanceInstabilityFactors } from './types'
 export { defaultPerformanceInstabilityFactors } from './types'
-export {
-  LONG_RENDER_TIME_MS,
-  LOW_FPS_THRESHOLD,
-  HIGH_TEXTURE_COUNT,
-} from './constants'
+export { LONG_RENDER_TIME_MS, LOW_FPS_THRESHOLD, HIGH_TEXTURE_COUNT } from './constants'
 export { PerformanceMonitor } from './PerformanceMonitor'
 export { formatPerformanceFactorsDebug } from './formatPerformanceFactorsDebug'

package/src/performanceMonitor/types.ts

@@ -13,7 +13,7 @@ export const defaultPerformanceInstabilityFactors = (): PerformanceInstabilityFa
   constantLongRenderTime: false,
   tooManyEntities: false,
   tooManyTextures: false,
-  unknownReason: false,
+  unknownReason: false
 })
 
 export interface FramePerformanceSample {