minecraft-renderer 0.1.79 → 0.1.81

package/src/mesher-shared/models.ts

@@ -10,12 +10,13 @@ import { INVISIBLE_BLOCKS } from './worldConstants'
 import { MesherGeometryOutput, HighestBlockInfo } from './shared'
 import { collectBlockEntityMetadata } from './blockEntityMetadata'
 import { preflatBlockCalculation, resolveBlockPropertiesForMeshing } from './blockPropertiesForMeshing'
+import { faceIsCulled, roundCardinalDir } from './faceOcclusion'
 
 export { preflatBlockCalculation, resolveBlockPropertiesForMeshing } from './blockPropertiesForMeshing'
 
 // Log function disabled by default for zero overhead in production hot loops
 const ENABLE_TS_LOGS = false
-const tsLog = ENABLE_TS_LOGS ? console.log : () => { }
+const tsLog = ENABLE_TS_LOGS ? console.log : () => {}
 
 let blockProvider: WorldBlockProvider
 
@@ -35,12 +36,12 @@ export type MesherGeometryBucket = {
   indicesCount: number
 }
 
-function vertexTintAoColor (
+function vertexTintAoColor(
   tint: [number, number, number],
   ao: number,
   faceDir: [number, number, number],
   shadingTheme: 'vanilla' | 'high-contrast',
-  cardinalLight: string,
+  cardinalLight: string
 ): [number, number, number] {
   const sideShading = getSideShading(faceDir, shadingTheme, cardinalLight)
   if (shadingTheme === 'high-contrast') {
@@ -51,7 +52,7 @@ function vertexTintAoColor (
   return [tint[0] * f, tint[1] * f, tint[2] * f]
 }
 
-export function isSemiTransparentBlockName (name: string): boolean {
+export function isSemiTransparentBlockName(name: string): boolean {
   return semiTransparentBlocks.includes(name)
 }
 
@@ -95,7 +96,8 @@ function tintToGl(tint) {
 function getLiquidRenderHeight(world: World, block: WorldBlock | null, type: number, pos: Vec3, isWater: boolean, isRealWater: boolean) {
   if ((isWater && !isRealWater) || (block && isBlockWaterlogged(block))) return 8 / 9
   if (!block || block.type !== type) return 1 / 9
-  if (block.metadata === 0) { // source block
+  if (block.metadata === 0) {
+    // source block
     const blockAbove = world.getBlock(pos.offset(0, 1, 0))
     if (blockAbove && blockAbove.type === type) return 1
     return 8 / 9
@@ -103,15 +105,16 @@ function getLiquidRenderHeight(world: World, block: WorldBlock | null, type: num
   return ((block.metadata >= 8 ? 8 : 7 - block.metadata) + 1) / 9
 }
 
-
 const isCube = (block: Block) => {
   if (!block || block.transparent) return false
   if (block.isCube) return true
   if (!block.models?.length || block.models.length !== 1) return false
   // all variants
-  return block.models[0].every(v => v.elements.every(e => {
-    return e.from[0] === 0 && e.from[1] === 0 && e.from[2] === 0 && e.to[0] === 16 && e.to[1] === 16 && e.to[2] === 16
-  }))
+  return block.models[0].every(v =>
+    v.elements.every(e => {
+      return e.from[0] === 0 && e.from[1] === 0 && e.from[2] === 0 && e.to[0] === 16 && e.to[1] === 16 && e.to[2] === 16
+    })
+  )
 }
 
 const getVec = (v: Vec3, dir: Vec3) => {
@@ -121,7 +124,17 @@ const getVec = (v: Vec3, dir: Vec3) => {
   return v.plus(dir)
 }
 
-function renderLiquid(world: World, cursor: Vec3, texture: any | undefined, type: number, biome: string, water: boolean, bucket: MesherGeometryBucket, attr: MesherGeometryOutput, isRealWater: boolean) {
+function renderLiquid(
+  world: World,
+  cursor: Vec3,
+  texture: any | undefined,
+  type: number,
+  biome: string,
+  water: boolean,
+  bucket: MesherGeometryBucket,
+  attr: MesherGeometryOutput,
+  isRealWater: boolean
+) {
   const heights: number[] = []
   for (let z = -1; z <= 1; z++) {
     for (let x = -1; x <= 1; x++) {
@@ -141,7 +154,7 @@ function renderLiquid(world: World, cursor: Vec3, texture: any | undefined, type
     const { dir, corners, mask1, mask2 } = elemFaces[face]
     const isUp = dir[1] === 1
 
-    const neighborPos = cursor.offset(...dir as [number, number, number])
+    const neighborPos = cursor.offset(...(dir as [number, number, number]))
     const neighbor = world.getBlock(neighborPos)
     if (!neighbor) continue
     if (neighbor.type === type || (water && (neighbor.name === 'water' || isBlockWaterlogged(neighbor)))) continue
@@ -160,13 +173,13 @@ function renderLiquid(world: World, cursor: Vec3, texture: any | undefined, type
       const tiles = attr.tiles as Tiles
       tiles[`${cursor.x},${cursor.y},${cursor.z}`] ??= {
         block: 'water',
-        faces: [],
+        faces: []
       }
       tiles[`${cursor.x},${cursor.y},${cursor.z}`].faces.push({
         face,
         neighbor: `${neighborPos.x},${neighborPos.y},${neighborPos.z}`,
         side: 0, // todo
-        textureIndex: 0,
+        textureIndex: 0
         // texture: eFace.texture.name,
       })
     }
@@ -201,7 +214,7 @@ function renderLiquid(world: World, cursor: Vec3, texture: any | undefined, type
         const side1Dir: [number, number, number] = [dx * mask1[0], dy * mask1[1], dz * mask1[2]]
         const side2Dir: [number, number, number] = [dx * mask2[0], dy * mask2[1], dz * mask2[2]]
 
-        const dirVec = new Vec3(...dir as [number, number, number])
+        const dirVec = new Vec3(...(dir as [number, number, number]))
 
         const side1LightDir = getVec(new Vec3(...side1Dir), dirVec)
         const side2DirLight = getVec(new Vec3(...side2Dir), dirVec)
@@ -249,65 +262,36 @@ function renderLiquid(world: World, cursor: Vec3, texture: any | undefined, type
   }
 }
 
-const identicalCull = (currentElement: BlockElement, neighbor: Block, direction: Vec3) => {
-  const dirStr = `${direction.x},${direction.y},${direction.z}`
-  const lookForOppositeSide = {
-    '0,1,0': 'down',
-    '0,-1,0': 'up',
-    '1,0,0': 'east',
-    '-1,0,0': 'west',
-    '0,0,1': 'south',
-    '0,0,-1': 'north',
-  }[dirStr]!
-  const elemCompareForm = {
-    '0,1,0': (e: BlockElement) => `${e.from[0]},${e.from[2]}:${e.to[0]},${e.to[2]}`,
-    '0,-1,0': (e: BlockElement) => `${e.to[0]},${e.to[2]}:${e.from[0]},${e.from[2]}`,
-    '1,0,0': (e: BlockElement) => `${e.from[2]},${e.from[1]}:${e.to[2]},${e.to[1]}`,
-    '-1,0,0': (e: BlockElement) => `${e.to[2]},${e.to[1]}:${e.from[2]},${e.from[1]}`,
-    '0,0,1': (e: BlockElement) => `${e.from[1]},${e.from[2]}:${e.to[1]},${e.to[2]}`,
-    '0,0,-1': (e: BlockElement) => `${e.to[1]},${e.to[2]}:${e.from[1]},${e.from[2]}`,
-  }[dirStr]!
-  const elementEdgeValidator = {
-    '0,1,0': (e: BlockElement) => currentElement.from[1] === 0 && e.to[2] === 16,
-    '0,-1,0': (e: BlockElement) => currentElement.from[1] === 0 && e.to[2] === 16,
-    '1,0,0': (e: BlockElement) => currentElement.from[0] === 0 && e.to[1] === 16,
-    '-1,0,0': (e: BlockElement) => currentElement.from[0] === 0 && e.to[1] === 16,
-    '0,0,1': (e: BlockElement) => currentElement.from[2] === 0 && e.to[0] === 16,
-    '0,0,-1': (e: BlockElement) => currentElement.from[2] === 0 && e.to[0] === 16,
-  }[dirStr]!
-  const useVar = 0
-  const models = neighbor.models?.map(m => m[useVar] ?? m[0]) ?? []
-  // TODO we should support it! rewrite with optimizing general pipeline
-  if (models.some(m => m.x || m.y || m.z)) return
-  return models.every(model => {
-    return (model.elements ?? []).every(element => {
-      // todo check alfa on texture
-      return !!(element.faces[lookForOppositeSide]?.cullface && elemCompareForm(currentElement) === elemCompareForm(element) && elementEdgeValidator(element))
-    })
-  })
-}
-
 let needSectionRecomputeOnChange = false
 
-function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO: boolean, bucket: MesherGeometryBucket, attr: MesherGeometryOutput, globalMatrix: any, globalShift: any, block: Block, biome: string) {
+function renderElement(
+  world: World,
+  cursor: Vec3,
+  element: BlockElement,
+  doAO: boolean,
+  bucket: MesherGeometryBucket,
+  attr: MesherGeometryOutput,
+  globalMatrix: any,
+  globalShift: any,
+  block: Block,
+  biome: string
+) {
   const position = cursor
   // const key = `${position.x},${position.y},${position.z}`
   // if (!globalThis.allowedBlocks.includes(key)) return
-  const cullIfIdentical = block.name.includes('glass') || block.name.includes('ice')
-
   // eslint-disable-next-line guard-for-in
   for (const face in element.faces) {
     const eFace = element.faces[face]
     const { corners, mask1, mask2, side } = elemFaces[face]
     const dir = matmul3(globalMatrix, elemFaces[face].dir)
+    const worldDir = roundCardinalDir(dir)
 
-    tsLog(`[TS] Processing face ${face} at (${cursor.x}, ${cursor.y}, ${cursor.z}), dir=[${dir.join(',')}]`)
+    tsLog(`[TS] Processing face ${face} at (${cursor.x}, ${cursor.y}, ${cursor.z}), dir=[${worldDir.join(',')}]`)
 
     if (eFace.cullface) {
-      const neighbor = world.getBlock(cursor.plus(new Vec3(...dir)), blockProvider, {})
+      const neighbor = world.getBlock(cursor.plus(new Vec3(...worldDir)), blockProvider, {})
       if (neighbor) {
-        if (cullIfIdentical && neighbor.stateId === block.stateId) continue
-        if (!neighbor.transparent && (isCube(neighbor) || identicalCull(element, neighbor, new Vec3(...dir)))) continue
+        if (faceIsCulled(world.config.version, element, face, neighbor.stateId, block, blockProvider, worldDir, globalMatrix)) continue
       } else {
         needSectionRecomputeOnChange = true
         // continue
@@ -336,9 +320,7 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
       if (eFace.tintindex === 0) {
         if (block.name === 'redstone_wire') {
           tint = tints.redstone[`${block.getProperties().power}`]
-        } else if (block.name === 'birch_leaves' ||
-          block.name === 'spruce_leaves' ||
-          block.name === 'lily_pad') {
+        } else if (block.name === 'birch_leaves' || block.name === 'spruce_leaves' || block.name === 'lily_pad') {
           tint = tints.constant[block.name]
         } else if (block.name.includes('leaves') || block.name === 'vine') {
           tint = tints.foliage[biome]
@@ -353,31 +335,22 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
     if (face === 'down') {
       r += 180
     }
-    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 && !needTiles) {
       // Rescale support for block model rotations
-      localMatrix = buildRotationMatrix(
-        element.rotation.axis,
-        element.rotation.angle
-      )
+      localMatrix = buildRotationMatrix(element.rotation.axis, element.rotation.angle)
 
-      localShift = vecsub3(
-        element.rotation.origin,
-        matmul3(
-          localMatrix,
-          element.rotation.origin
-        )
-      )
+      localShift = vecsub3(element.rotation.origin, matmul3(localMatrix, element.rotation.origin))
 
       // Apply rescale if specified
       if (element.rotation.rescale) {
         const FIT_TO_BLOCK_SCALE_MULTIPLIER = 2 - Math.sqrt(2)
-        const angleRad = element.rotation.angle * Math.PI / 180
+        const angleRad = (element.rotation.angle * Math.PI) / 180
         const scale = Math.abs(Math.sin(angleRad)) * FIT_TO_BLOCK_SCALE_MULTIPLIER
 
         // Get axis vector components (1 for the rotation axis, 0 for others)
@@ -396,13 +369,7 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
         localMatrix = matmulmat3(localMatrix, scaleMatrix)
 
         // Recalculate shift with the new matrix
-        localShift = vecsub3(
-          element.rotation.origin,
-          matmul3(
-            localMatrix,
-            element.rotation.origin
-          )
-        )
+        localShift = vecsub3(element.rotation.origin, matmul3(localMatrix, element.rotation.origin))
       }
     }
 
@@ -412,22 +379,15 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
     const baseChannels = world.getChannelLightNorm(neighborPos)
     const faceDir = dir as [number, number, number]
     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]
 
-      if (!needTiles) { // 10%
+      if (!needTiles) {
+        // 10%
         vertex = vecadd3(matmul3(localMatrix, vertex), localShift)
         vertex = vecadd3(matmul3(globalMatrix, vertex), globalShift)
         vertex = vertex.map(v => v / 16)
 
-        const worldPos = [
-          vertex[0] + (cursor.x & 15) - 8,
-          vertex[1] + (cursor.y & 15) - 8,
-          vertex[2] + (cursor.z & 15) - 8
-        ]
+        const worldPos = [vertex[0] + (cursor.x & 15) - 8, vertex[1] + (cursor.y & 15) - 8, vertex[2] + (cursor.z & 15) - 8]
 
         tsLog(`[TS]     Corner ${pos.join(',')}: vertex=[${vertex.map(v => v.toFixed(3)).join(',')}], worldPos=[${worldPos.map(v => v.toFixed(3)).join(',')}]`)
 
@@ -439,7 +399,9 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
         const basev = (pos[3] - 0.5) * uvsn + (pos[4] - 0.5) * uvcs + 0.5
         const finalU = baseu * su + u
         const finalV = basev * sv + v
-        tsLog(`[TS]       UV: cornerUV=[${pos[3]},${pos[4]}], baseUV=[${baseu.toFixed(6)},${basev.toFixed(6)}], finalUV=[${finalU.toFixed(6)},${finalV.toFixed(6)}], texture=[u=${u},v=${v},su=${su},sv=${sv}], rotation=${r}`)
+        tsLog(
+          `[TS]       UV: cornerUV=[${pos[3]},${pos[4]}], baseUV=[${baseu.toFixed(6)},${basev.toFixed(6)}], finalUV=[${finalU.toFixed(6)},${finalV.toFixed(6)}], texture=[u=${u},v=${v},su=${su},sv=${sv}], rotation=${r}`
+        )
         bucket.uvs.push(finalU, finalV)
       }
 
@@ -479,7 +441,7 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
         const side2Block = world.shouldMakeAo(side2) ? 1 : 0
         const cornerBlock = world.shouldMakeAo(corner) ? 1 : 0
 
-        ao = (side1Block && side2Block) ? 0 : (3 - (side1Block + side2Block + cornerBlock))
+        ao = side1Block && side2Block ? 0 : 3 - (side1Block + side2Block + cornerBlock)
         aos.push(ao)
 
         const cornerIdx = aos.length - 1
@@ -500,7 +462,7 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
       const tiles = attr.tiles as Tiles
       tiles[`${cursor.x},${cursor.y},${cursor.z}`] ??= {
         block: block.name,
-        faces: [],
+        faces: []
       }
       const needsOnlyOneFace = false
       const isTilesEmpty = tiles[`${cursor.x},${cursor.y},${cursor.z}`].faces.length < 1
@@ -513,7 +475,7 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
           light: Math.max(baseChannels.block, baseChannels.sky),
           tint: lightWithColor,
           //@ts-expect-error debug prop
-          texture: eFace.texture.debugName || block.name,
+          texture: eFace.texture.debugName || block.name
         } satisfies BlockType['faces'][number])
       }
     }
@@ -545,13 +507,7 @@ function renderElement(world: World, cursor: Vec3, element: BlockElement, doAO:
   }
 }
 
-const ALWAYS_WATERLOGGED = new Set([
-  'seagrass',
-  'tall_seagrass',
-  'kelp',
-  'kelp_plant',
-  'bubble_column'
-])
+const ALWAYS_WATERLOGGED = new Set(['seagrass', 'tall_seagrass', 'kelp', 'kelp_plant', 'bubble_column'])
 const isBlockWaterlogged = (block: Block) => {
   return block.getProperties().waterlogged === true || block.getProperties().waterlogged === 'true' || ALWAYS_WATERLOGGED.has(block.name)
 }
@@ -599,7 +555,7 @@ export function getSectionGeometry(sx: number, sy: number, sz: number, world: Wo
     blockLights: attr.blockLights as number[],
     uvs: attr.uvs as number[],
     indices: attr.indices as number[],
-    indicesCount: attr.indicesCount,
+    indicesCount: attr.indicesCount
   }
   const blendBucket: MesherGeometryBucket = {
     positions: [],
@@ -609,7 +565,7 @@ export function getSectionGeometry(sx: number, sy: number, sz: number, world: Wo
     blockLights: [],
     uvs: [],
     indices: [],
-    indicesCount: 0,
+    indicesCount: 0
   }
 
   const cursor = new Vec3(0, 0, 0)
@@ -621,7 +577,8 @@ export function getSectionGeometry(sx: number, sy: number, sz: number, world: Wo
         collectBlockEntityMetadata(block, cursor.x, cursor.y, cursor.z, attr, { disableBlockEntityTextures: world.config.disableBlockEntityTextures }, world)
         const biome = block.biome.name
 
-        if (world.preflat) { // 10% perf
+        if (world.preflat) {
+          // 10% perf
           const patchProperties = preflatBlockCalculation(block, world, cursor)
           if (patchProperties) {
             block._originalProperties ??= block._properties
@@ -673,9 +630,9 @@ export function getSectionGeometry(sx: number, sy: number, sz: number, world: Wo
             let globalShift = null as any
             for (const axis of ['x', 'y', 'z'] as const) {
               if (axis in model) {
-                globalMatrix = globalMatrix ?
-                  matmulmat3(globalMatrix, buildRotationMatrix(axis, -(model[axis] ?? 0))) :
-                  buildRotationMatrix(axis, -(model[axis] ?? 0))
+                globalMatrix = globalMatrix
+                  ? matmulmat3(globalMatrix, buildRotationMatrix(axis, -(model[axis] ?? 0)))
+                  : buildRotationMatrix(axis, -(model[axis] ?? 0))
               }
             }
             if (globalMatrix) {
@@ -732,9 +689,7 @@ export function getSectionGeometry(sx: number, sy: number, sz: number, world: Wo
       skyLights: new Float32Array(blendBucket.skyLights),
       blockLights: new Float32Array(blendBucket.blockLights),
       uvs: new Float32Array(blendBucket.uvs),
-      indices: blendUsing32
-        ? new Uint32Array(blendBucket.indices)
-        : new Uint16Array(blendBucket.indices),
+      indices: blendUsing32 ? new Uint32Array(blendBucket.indices) : new Uint16Array(blendBucket.indices)
     }
   }
 
@@ -758,20 +713,23 @@ export function getSectionGeometry(sx: number, sy: number, sz: number, world: Wo
 
 // copied from three.js
 function arrayNeedsUint32(array) {
-
   // assumes larger values usually on last
 
   for (let i = array.length - 1; i >= 0; --i) {
-
     if (array[i] >= 65_535) return true // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565
-
   }
 
   return false
-
 }
 
-export const setBlockStatesData = (blockstatesModels, blocksAtlas: any, _needTiles = false, useUnknownBlockModel = true, version = 'latest', mcData = (globalThis as any).mcData) => {
+export const setBlockStatesData = (
+  blockstatesModels,
+  blocksAtlas: any,
+  _needTiles = false,
+  useUnknownBlockModel = true,
+  version = 'latest',
+  mcData = (globalThis as any).mcData
+) => {
   blockProvider = worldBlockProvider(blockstatesModels, blocksAtlas, version)
   globalThis.blockProvider = blockProvider
   if (useUnknownBlockModel) {
@@ -807,7 +765,7 @@ export const setBlockStatesData = (blockstatesModels, blocksAtlas: any, _needTil
 
 export function computeWireframeEdgesJS(positions: Float32Array | number[], indices: Uint32Array | Uint16Array | number[]): Float32Array {
   const pos = positions instanceof Float32Array ? positions : new Float32Array(positions as number[])
-  const idx = indices instanceof Uint32Array ? indices : (indices instanceof Uint16Array ? new Uint32Array(indices) : new Uint32Array(indices as number[]))
+  const idx = indices instanceof Uint32Array ? indices : indices instanceof Uint16Array ? new Uint32Array(indices) : new Uint32Array(indices as number[])
 
   const linePositions: number[] = []
   const edgeSet = new Set<number>()
@@ -825,13 +783,7 @@ export function computeWireframeEdgesJS(positions: Float32Array | number[], indi
   return new Float32Array(linePositions)
 }
 
-function addEdgeJS(
-  positions: Float32Array,
-  i0: number,
-  i1: number,
-  linePositions: number[],
-  edgeSet: Set<number>
-): void {
+function addEdgeJS(positions: Float32Array, i0: number, i1: number, linePositions: number[], edgeSet: Set<number>): void {
   const minI = i0 < i1 ? i0 : i1
   const maxI = i0 < i1 ? i1 : i0
   // Pack two indices into a single number (safe while indices < 2^24 — far above per-section vertex counts).
@@ -840,8 +792,5 @@ function addEdgeJS(
   if (edgeSet.has(key)) return
   edgeSet.add(key)
 
-  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]!)
 }

package/src/mesher-shared/modelsGeometryCommon.ts

@@ -3,9 +3,8 @@ import { BlockModelPartsResolved } from './world'
 
 export type BlockElement = NonNullable<BlockModelPartsResolved[0][0]['elements']>[0]
 
-
-export function buildRotationMatrix (axis, degree) {
-  const radians = degree / 180 * Math.PI
+export function buildRotationMatrix(axis, degree) {
+  const radians = (degree / 180) * Math.PI
   const cos = Math.cos(radians)
   const sin = Math.sin(radians)
 
@@ -28,17 +27,17 @@ export function buildRotationMatrix (axis, degree) {
   return matrix
 }
 
-export function vecadd3 (a, b) {
+export function vecadd3(a, b) {
   if (!b) return a
   return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]
 }
 
-export function vecsub3 (a, b) {
+export function vecsub3(a, b) {
   if (!b) return a
   return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]
 }
 
-export function matmul3 (matrix, vector): [number, number, number] {
+export function matmul3(matrix, vector): [number, number, number] {
   if (!matrix) return vector
   return [
     matrix[0][0] * vector[0] + matrix[0][1] * vector[1] + matrix[0][2] * vector[2],
@@ -47,16 +46,32 @@ export function matmul3 (matrix, vector): [number, number, number] {
   ]
 }
 
-export function matmulmat3 (a, b) {
-  const te = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
-
-  const a11 = a[0][0]; const a12 = a[1][0]; const a13 = a[2][0]
-  const a21 = a[0][1]; const a22 = a[1][1]; const a23 = a[2][1]
-  const a31 = a[0][2]; const a32 = a[1][2]; const a33 = a[2][2]
+export function matmulmat3(a, b) {
+  const te = [
+    [0, 0, 0],
+    [0, 0, 0],
+    [0, 0, 0]
+  ]
 
-  const b11 = b[0][0]; const b12 = b[1][0]; const b13 = b[2][0]
-  const b21 = b[0][1]; const b22 = b[1][1]; const b23 = b[2][1]
-  const b31 = b[0][2]; const b32 = b[1][2]; const b33 = b[2][2]
+  const a11 = a[0][0]
+  const a12 = a[1][0]
+  const a13 = a[2][0]
+  const a21 = a[0][1]
+  const a22 = a[1][1]
+  const a23 = a[2][1]
+  const a31 = a[0][2]
+  const a32 = a[1][2]
+  const a33 = a[2][2]
+
+  const b11 = b[0][0]
+  const b12 = b[1][0]
+  const b13 = b[2][0]
+  const b21 = b[0][1]
+  const b22 = b[1][1]
+  const b23 = b[2][1]
+  const b31 = b[0][2]
+  const b32 = b[1][2]
+  const b33 = b[2][2]
 
   te[0][0] = a11 * b11 + a12 * b21 + a13 * b31
   te[1][0] = a11 * b12 + a12 * b22 + a13 * b32

package/src/mesher-shared/shared.ts

@@ -21,7 +21,7 @@ export const defaultMesherConfig = {
   disableConversionCache: false,
   computeWireframeEdges: false,
   /** Pack eligible full-cube faces as GPU-instanced shader words during WASM post-processing. */
-  shaderCubeBlocks: false,
+  shaderCubeBlocks: false
 }
 
 export type CustomBlockModels = {
@@ -42,35 +42,35 @@ export type MesherGeometryBucketData = {
 }
 
 export type MesherGeometryOutput = {
-  sectionYNumber: number,
-  chunkKey: string,
-  sectionStartY: number,
-  sectionEndY: number,
-  sectionStartX: number,
-  sectionEndX: number,
-  sectionStartZ: number,
-  sectionEndZ: number,
+  sectionYNumber: number
+  chunkKey: string
+  sectionStartY: number
+  sectionEndY: number
+  sectionStartX: number
+  sectionEndX: number
+  sectionStartZ: number
+  sectionEndZ: number
   // three.js
-  sx: number,
-  sy: number,
-  sz: number,
+  sx: number
+  sy: number
+  sz: number
   // resulting: float32array
-  positions: any,
-  normals: any,
-  colors: any,
-  skyLights: any,
-  blockLights: any,
-  uvs: any,
+  positions: any
+  normals: any
+  colors: any
+  skyLights: any
+  blockLights: any
+  uvs: any
   /** Per-section blend geometry (water, lava, stained glass, ice, etc.). */
-  blend?: MesherGeometryBucketData,
+  blend?: MesherGeometryBucketData
 
-  indices: Uint32Array | Uint16Array | number[],
-  indicesCount: number,
-  using32Array: boolean,
-  tiles: Record<string, BlockType>,
-  heads: Record<string, any>,
-  signs: Record<string, any>,
-  banners: Record<string, any>,
+  indices: Uint32Array | Uint16Array | number[]
+  indicesCount: number
+  using32Array: boolean
+  tiles: Record<string, BlockType>
+  heads: Record<string, any>
+  signs: Record<string, any>
+  banners: Record<string, any>
   // isFull: boolean
   hadErrors: boolean
   blocksCount: number
@@ -85,36 +85,36 @@ export type MesherGeometryOutput = {
 }
 
 export interface MesherMainEvents {
-  geometry: { type: 'geometry'; key: string; geometry: MesherGeometryOutput; workerIndex: number };
+  geometry: { type: 'geometry'; key: string; geometry: MesherGeometryOutput; workerIndex: number }
   sectionFinished: {
-    type: 'sectionFinished';
-    key: string;
-    workerIndex: number;
-    processTime?: number;
-    pre?: number;
-    wasm?: number;
-    post?: number;
+    type: 'sectionFinished'
+    key: string
+    workerIndex: number
+    processTime?: number
+    pre?: number
+    wasm?: number
+    post?: number
     // Pre-stage substages (added for column-mode perf instrumentation).
     // All times in ms. `preNeighborConvert` is a SUM across neighbors;
     // divide by `preNeighborCount` for per-neighbor average.
-    preTargetConvert?: number;
-    preNeighborConvert?: number;
-    preNeighborCount?: number;
-    preTypedArrayBuild?: number;
-    preOther?: number;
+    preTargetConvert?: number
+    preNeighborConvert?: number
+    preNeighborCount?: number
+    preTypedArrayBuild?: number
+    preOther?: number
     // Per-event counts for the column-mode conversion cache.
-    preCacheHits?: number;
-    preCacheMisses?: number;
-  };
-  blockStateModelInfo: { type: 'blockStateModelInfo'; info: Record<string, BlockStateModelInfo> };
-  heightmap: { type: 'heightmap'; key: string; heightmap: Int16Array };
+    preCacheHits?: number
+    preCacheMisses?: number
+  }
+  blockStateModelInfo: { type: 'blockStateModelInfo'; info: Record<string, BlockStateModelInfo> }
+  heightmap: { type: 'heightmap'; key: string; heightmap: Int16Array }
   /** Reply to `{ type: 'mc-web-ping', t?, workerIndex? }` from the main thread (not batched in worker). */
-  mcWebPong: { type: 'mc-web-pong'; workerIndex: number; t?: number; recvAt?: number };
+  mcWebPong: { type: 'mc-web-pong'; workerIndex: number; t?: number; recvAt?: number }
 }
 
 export type MesherMainEvent = MesherMainEvents[keyof MesherMainEvents]
 
-export type HighestBlockInfo = { y: number, stateId: number | undefined, biomeId: number | undefined }
+export type HighestBlockInfo = { y: number; stateId: number | undefined; biomeId: number | undefined }
 
 export type BlockStateModelInfo = {
   cacheKey: string