minecraft-renderer 0.1.79 → 0.1.81

package/src/sign-renderer/playground.ts

@@ -5,31 +5,38 @@ import { renderSign } from '.'
 const PrismarineChat = PrismarineChatLoader({ language: {} } as any)
 
 const img = new Image()
-img.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAABbElEQVR4AY3BQY6cMBBA0Q+yQZZVi+ndcJVcKGfMgegdvShKVtuokzGSWwwiUd7rfv388Vst0UgMXCobmgsSA5VaQmKgUks0EgNHji8SA9W8GJCQwVNpLhzJ4KFs4B1HEgPVvBiQkMFTaS44tYTEQDXdIkfiHbuyobmguaDPFzIWGrWExEA13SJH4h1uzS/WbPyvroM1v6jWbFRrNv7GfX5EdmXjzTvUEjJ4zjQXjiQGdmXjzTvUEjJ4HF/UEt/kQqW5UEkMzIshY08jg6dRS3yTC5XmgpsXY7pFztQSEgPNJCNv3lGpJVSfTLfImVpCYsB1HdwfxpU1G9eeNF0H94dxZc2G+/yI7MoG3vEv82LI2NNIDLyVDbzjzFE2mnkxZOy5IoNnkpFGc2FXNpp5MWTsOXJ4h1qikrGnkhjYlY1m1icy9lQSA+TCzjvUEpWMPZXEwK5suPvDOFuzcdZ1sOYX1ZqNas3GlTUbzR+jQbEAcs8ZQAAAAABJRU5ErkJggg=='
+img.src =
+  'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAMCAYAAAB4MH11AAABbElEQVR4AY3BQY6cMBBA0Q+yQZZVi+ndcJVcKGfMgegdvShKVtuokzGSWwwiUd7rfv388Vst0UgMXCobmgsSA5VaQmKgUks0EgNHji8SA9W8GJCQwVNpLhzJ4KFs4B1HEgPVvBiQkMFTaS44tYTEQDXdIkfiHbuyobmguaDPFzIWGrWExEA13SJH4h1uzS/WbPyvroM1v6jWbFRrNv7GfX5EdmXjzTvUEjJ4zjQXjiQGdmXjzTvUEjJ4HF/UEt/kQqW5UEkMzIshY08jg6dRS3yTC5XmgpsXY7pFztQSEgPNJCNv3lGpJVSfTLfImVpCYsB1HdwfxpU1G9eeNF0H94dxZc2G+/yI7MoG3vEv82LI2NNIDLyVDbzjzFE2mnkxZOy5IoNnkpFGc2FXNpp5MWTsOXJ4h1qikrGnkhjYlY1m1icy9lQSA+TCzjvUEpWMPZXEwK5suPvDOFuzcdZ1sOYX1ZqNas3GlTUbzR+jQbEAcs8ZQAAAAABJRU5ErkJggg=='
 
 await new Promise<void>(resolve => {
   img.onload = () => resolve()
 })
 
 const blockEntity = {
-  'GlowingText': 0,
-  'Color': 'black',
-  'Text4': '{"text":""}',
-  'Text3': '{"text":""}',
-  'Text2': '{"text":""}',
-  'Text1': '{"extra":[{"color":"dark_green","text":"Minecraft "},{"text":"Tools"}],"text":""}'
+  GlowingText: 0,
+  Color: 'black',
+  Text4: '{"text":""}',
+  Text3: '{"text":""}',
+  Text2: '{"text":""}',
+  Text1: '{"extra":[{"color":"dark_green","text":"Minecraft "},{"text":"Tools"}],"text":""}'
 } as const
 
 await document.fonts.load('1em mojangles')
 
-const canvas = renderSign(blockEntity, false, PrismarineChat, (ctx) => {
-  ctx.drawImage(img, 0, 0, ctx.canvas.width, ctx.canvas.height)
-}, (width, height) => {
-  const canvas = document.createElement('canvas')
-  canvas.width = width
-  canvas.height = height
-  return canvas as unknown as OffscreenCanvas
-}) as unknown as HTMLCanvasElement
+const canvas = renderSign(
+  blockEntity,
+  false,
+  PrismarineChat,
+  ctx => {
+    ctx.drawImage(img, 0, 0, ctx.canvas.width, ctx.canvas.height)
+  },
+  (width, height) => {
+    const canvas = document.createElement('canvas')
+    canvas.width = width
+    canvas.height = height
+    return canvas as unknown as OffscreenCanvas
+  }
+) as unknown as HTMLCanvasElement
 
 if (canvas) {
   canvas.style.imageRendering = 'pixelated'

package/src/sign-renderer/tests.test.ts

@@ -14,14 +14,16 @@ globalThis.document = {
           fillText(text, x, y) {
             ctxTexts.push({ text, x, y })
           },
-          measureText() { return 0 }
+          measureText() {
+            return 0
+          }
         }
       }
     }
   }
 } as any
 
-const render = (entity) => {
+const render = entity => {
   ctxTexts = []
   renderSign(entity, true, PrismarineChat)
   return ctxTexts.map(({ text, y }) => [y / 64, text])
@@ -29,12 +31,12 @@ const render = (entity) => {
 
 test('sign renderer', () => {
   let blockEntity = {
-    'GlowingText': 0,
-    'Color': 'black',
-    'Text4': '{"text":""}',
-    'Text3': '{"text":""}',
-    'Text2': '{"text":""}',
-    'Text1': '{"extra":[{"color":"dark_green","text":"Minecraft "},{"text":"Tools"}],"text":""}'
+    GlowingText: 0,
+    Color: 'black',
+    Text4: '{"text":""}',
+    Text3: '{"text":""}',
+    Text2: '{"text":""}',
+    Text1: '{"extra":[{"color":"dark_green","text":"Minecraft "},{"text":"Tools"}],"text":""}'
   } as any
   expect(render(blockEntity)).toMatchInlineSnapshot(`
     [
@@ -49,11 +51,12 @@ test('sign renderer', () => {
     ]
   `)
 
-  blockEntity = { // pre flatenning
-    'Text1': 'Welcome to',
-    'Text2': '',
-    'Text3': 'null',
-    'Text4': '"Version 2.1"',
+  blockEntity = {
+    // pre flatenning
+    Text1: 'Welcome to',
+    Text2: '',
+    Text3: 'null',
+    Text4: '"Version 2.1"'
   } as const
   expect(render(blockEntity)).toMatchInlineSnapshot(`
     [

package/src/sign-renderer/vite.config.ts

@@ -6,6 +6,6 @@ export default defineConfig({
     alias: {
       'prismarine-registry': './noop.js',
       'prismarine-nbt': './noop.js'
-    },
-  },
+    }
+  }
 })

package/src/three/appShared.ts

@@ -6,37 +6,55 @@ import { GeneralInputItem, getItemModelName } from '../lib/items'
 import { ResourcesManagerTransferred } from '../resourcesManager'
 import { renderSlot } from './renderSlot'
 
-export const getItemUv = (item: Record<string, any>, specificProps: ItemSpecificContextProperties, resourcesManager: ResourcesManagerTransferred, playerState: PlayerStateRenderer): {
-  u: number
-  v: number
-  su: number
-  sv: number
-  renderInfo?: ReturnType<typeof renderSlot>
-  // texture: ImageBitmap
-  modelName: string
-} | {
-  resolvedModel: BlockModel
-  modelName: string
-} => {
+export const getItemUv = (
+  item: Record<string, any>,
+  specificProps: ItemSpecificContextProperties,
+  resourcesManager: ResourcesManagerTransferred,
+  playerState: PlayerStateRenderer
+):
+  | {
+      u: number
+      v: number
+      su: number
+      sv: number
+      renderInfo?: ReturnType<typeof renderSlot>
+      // texture: ImageBitmap
+      modelName: string
+    }
+  | {
+      resolvedModel: BlockModel
+      modelName: string
+    } => {
   const resources = resourcesManager.currentResources
   if (!resources) throw new Error('Resources not loaded')
   const idOrName = item.itemId ?? item.blockId ?? item.name
   const { blockState } = item
   try {
-    const name =
-      blockState
-        ? globalThis.loadedData.blocksByStateId[blockState]?.name
-        : typeof idOrName === 'number' ? globalThis.loadedData.items[idOrName]?.name : idOrName
+    const name = blockState
+      ? globalThis.loadedData.blocksByStateId[blockState]?.name
+      : typeof idOrName === 'number'
+        ? globalThis.loadedData.items[idOrName]?.name
+        : idOrName
     if (!name) throw new Error(`Item not found: ${idOrName}`)
 
-    const model = getItemModelName({
-      ...item,
-      name,
-    } as GeneralInputItem, specificProps, resourcesManager, playerState)
+    const model = getItemModelName(
+      {
+        ...item,
+        name
+      } as GeneralInputItem,
+      specificProps,
+      resourcesManager,
+      playerState
+    )
 
-    const renderInfo = renderSlot({
-      modelName: model,
-    }, resourcesManager, false, true)
+    const renderInfo = renderSlot(
+      {
+        modelName: model
+      },
+      resourcesManager,
+      false,
+      true
+    )
 
     if (!renderInfo) throw new Error(`Failed to get render info for item ${name}`)
 
@@ -51,9 +69,12 @@ export const getItemUv = (item: Record<string, any>, specificProps: ItemSpecific
     if (renderInfo.slice) {
       // Get slice coordinates from either block or item texture
       const [x, y, w, h] = renderInfo.slice
-      const [u, v, su, sv] = [x / img.width, y / img.height, (w / img.width), (h / img.height)]
+      const [u, v, su, sv] = [x / img.width, y / img.height, w / img.width, h / img.height]
       return {
-        u, v, su, sv,
+        u,
+        v,
+        su,
+        sv,
         renderInfo,
         // texture: img,
         modelName: renderInfo.modelName!

package/src/three/bannerRenderer.ts

@@ -18,22 +18,22 @@ const BANNER_HEIGHT = 40
 
 // Map banner block names to base color IDs
 const BANNER_NAME_TO_COLOR: Record<string, number> = {
-  'white_banner': 15,
-  'orange_banner': 14,
-  'magenta_banner': 13,
-  'light_blue_banner': 12,
-  'yellow_banner': 11,
-  'lime_banner': 10,
-  'pink_banner': 9,
-  'gray_banner': 8,
-  'light_gray_banner': 7,
-  'cyan_banner': 6,
-  'purple_banner': 5,
-  'blue_banner': 4,
-  'brown_banner': 3,
-  'green_banner': 2,
-  'red_banner': 1,
-  'black_banner': 0,
+  white_banner: 15,
+  orange_banner: 14,
+  magenta_banner: 13,
+  light_blue_banner: 12,
+  yellow_banner: 11,
+  lime_banner: 10,
+  pink_banner: 9,
+  gray_banner: 8,
+  light_gray_banner: 7,
+  cyan_banner: 6,
+  purple_banner: 5,
+  blue_banner: 4,
+  brown_banner: 3,
+  green_banner: 2,
+  red_banner: 1,
+  black_banner: 0
 }
 
 // Basic Minecraft banner colors (DyeColor enum values)
@@ -53,7 +53,7 @@ const BANNER_COLORS: Record<number, string> = {
   12: '#3ab3da', // light_blue
   13: '#c74ebd', // magenta
   14: '#f9801d', // orange
-  15: '#f9fffe', // white
+  15: '#f9fffe' // white
 }
 
 // Extract base color from banner block name
@@ -64,15 +64,7 @@ function getBannerBaseColor(blockName: string): number {
 }
 
 // Basic pattern rendering (simplified - just solid colors for now)
-const renderPattern = (
-  ctx: OffscreenCanvasRenderingContext2D,
-  pattern: string,
-  color: string,
-  x: number,
-  y: number,
-  width: number,
-  height: number
-) => {
+const renderPattern = (ctx: OffscreenCanvasRenderingContext2D, pattern: string, color: string, x: number, y: number, width: number, height: number) => {
   ctx.fillStyle = color
   // For now, just render basic patterns as solid colors
   // TODO: Implement actual pattern shapes (stripes, crosses, etc.)
@@ -84,19 +76,19 @@ const renderPattern = (
       ctx.fillRect(x, y, width / 3, height)
       break
     case 'rs': // Right stripe
-      ctx.fillRect(x + (width * 2 / 3), y, width / 3, height)
+      ctx.fillRect(x + (width * 2) / 3, y, width / 3, height)
       break
     case 'ts': // Top stripe
       ctx.fillRect(x, y, width, height / 3)
       break
     case 'ms': // Middle stripe
-      ctx.fillRect(x, y + (height / 3), width, height / 3)
+      ctx.fillRect(x, y + height / 3, width, height / 3)
       break
     case 'drs': // Down-right stripe
       ctx.fillRect(x, y, width / 2, height / 2)
       break
     case 'dls': // Down-left stripe
-      ctx.fillRect(x + (width / 2), y, width / 2, height / 2)
+      ctx.fillRect(x + width / 2, y, width / 2, height / 2)
       break
     case 'ss': // Small stripes
       for (let i = 0; i < width; i += 2) {
@@ -104,12 +96,12 @@ const renderPattern = (
       }
       break
     case 'cr': // Cross
-      ctx.fillRect(x, y + (height / 3), width, height / 3)
-      ctx.fillRect(x + (width / 3), y, width / 3, height)
+      ctx.fillRect(x, y + height / 3, width, height / 3)
+      ctx.fillRect(x + width / 3, y, width / 3, height)
       break
     case 'sc': // Straight cross
-      ctx.fillRect(x, y + (height / 2) - 1, width, 2)
-      ctx.fillRect(x + (width / 2) - 1, y, 2, height)
+      ctx.fillRect(x, y + height / 2 - 1, width, 2)
+      ctx.fillRect(x + width / 2 - 1, y, 2, height)
       break
     default:
       // Default: fill entire area
@@ -118,7 +110,7 @@ const renderPattern = (
 }
 
 // Create a cache key from banner content (base color + patterns)
-function createBannerCacheKey(baseColor: number, patterns: Array<{ Color?: number, Pattern?: string }> | undefined): string {
+function createBannerCacheKey(baseColor: number, patterns: Array<{ Color?: number; Pattern?: string }> | undefined): string {
   if (!patterns || patterns.length === 0) {
     return `banner_${baseColor}_empty`
   }
@@ -159,30 +151,17 @@ export const renderBanner = (
       const color = BANNER_COLORS[colorId] || BANNER_COLORS[0]
 
       // Render each pattern on top of previous ones
-      renderPattern(
-        ctx,
-        pattern,
-        color,
-        0,
-        0,
-        BANNER_WIDTH * scale,
-        BANNER_HEIGHT * scale
-      )
+      renderPattern(ctx, pattern, color, 0, 0, BANNER_WIDTH * scale, BANNER_HEIGHT * scale)
     }
   }
 
   return canvas
 }
 
-
 // Banner texture cache with reference counting
-const bannerTextureCache = new Map<string, { texture: THREE.Texture, refCount: number }>()
+const bannerTextureCache = new Map<string, { texture: THREE.Texture; refCount: number }>()
 
-export function getBannerTexture(
-  worldRenderer: WorldRendererThree,
-  blockName: string,
-  blockEntity: any
-): THREE.Texture | undefined {
+export function getBannerTexture(worldRenderer: WorldRendererThree, blockName: string, blockEntity: any): THREE.Texture | undefined {
   // Extract base color from block name
   const baseColor = getBannerBaseColor(blockName)
 
@@ -232,8 +211,8 @@ export function createBannerMesh(
   texture: THREE.Texture,
   blockLightNorm = 0,
   skyLightNorm = 1,
-  skyLevel = 1,
-): THREE.Group & { bannerTexture?: THREE.Texture, bannerMaterial?: THREE.MeshBasicMaterial } {
+  skyLevel = 1
+): THREE.Group & { bannerTexture?: THREE.Texture; bannerMaterial?: THREE.MeshBasicMaterial } {
   const bannerWidth = 13.6 / 16
   const bannerHeight = 28 / 16
   const clothXOffset = 0
@@ -256,10 +235,7 @@ export function createBannerMesh(
 
   const material = new THREE.MeshBasicMaterial({ map: texture, transparent: true })
   tintBannerMaterial(material, blockLightNorm, skyLightNorm, skyLevel)
-  const mesh = new THREE.Mesh(
-    new THREE.PlaneGeometry(bannerWidth, bannerHeight),
-    material,
-  )
+  const mesh = new THREE.Mesh(new THREE.PlaneGeometry(bannerWidth, bannerHeight), material)
   mesh.renderOrder = 999
 
   const thickness = 0.5 / 16
@@ -274,11 +250,7 @@ export function createBannerMesh(
     bannerTexture?: THREE.Texture
     bannerMaterial?: THREE.MeshBasicMaterial
   }
-  group.rotation.set(
-    0,
-    -THREE.MathUtils.degToRad(rotation * (isWall ? 90 : 45 / 2)),
-    0
-  )
+  group.rotation.set(0, -THREE.MathUtils.degToRad(rotation * (isWall ? 90 : 45 / 2)), 0)
   group.add(mesh)
   group.bannerTexture = texture
   group.bannerMaterial = material

package/src/three/cameraCollisionBlockCache.ts

@@ -0,0 +1,156 @@
+//@ts-nocheck
+import Chunks from 'prismarine-chunk'
+import { Vec3 } from 'vec3'
+import { getCameraCollisionSolidityTable, isStateIdSolidForCameraCollision } from './cameraCollisionSolidity'
+
+/** 16³ blocks per section; 1 bit per block. */
+const WORDS_PER_SECTION = 128
+export const CAMERA_COLLISION_BYTES_PER_SECTION = WORDS_PER_SECTION * 4
+
+type SectionBitset = Uint32Array
+
+const sectionKey = (sx: number, sy: number, sz: number) => `${sx},${sy},${sz}`
+
+const alignSection = (coord: number) => Math.floor(coord / 16) * 16
+
+const localCoord = (coord: number) => ((coord % 16) + 16) % 16
+
+const blockBitIndex = (lx: number, ly: number, lz: number) => lx + lz * 16 + ly * 256
+
+const getBit = (bits: SectionBitset, idx: number) => {
+  const word = idx >>> 5
+  return (bits[word]! & (1 << (idx & 31))) !== 0
+}
+
+const setBit = (bits: SectionBitset, idx: number, value: boolean) => {
+  const word = idx >>> 5
+  const mask = 1 << (idx & 31)
+  if (value) bits[word]! |= mask
+  else bits[word]! &= ~mask
+}
+
+const isBitsetEmpty = (bits: SectionBitset) => {
+  for (let i = 0; i < WORDS_PER_SECTION; i++) {
+    if (bits[i]!) return false
+  }
+  return true
+}
+
+/**
+ * Sparse 1-bit-per-block solidity cache for third-person voxel DDA.
+ * Allocates a 512-byte section bitset only when it contains ≥1 solid block.
+ */
+export class CameraCollisionBlockCache {
+  private readonly sections = new Map<string, SectionBitset>()
+  private Chunk: ReturnType<typeof Chunks>
+  private solidityTable: Uint8Array
+  private worldMinY = 0
+  private worldMaxY = 256
+
+  constructor(version: string) {
+    this.Chunk = Chunks(version) as ReturnType<typeof Chunks>
+    this.solidityTable = getCameraCollisionSolidityTable(version)
+  }
+
+  setVersion(version: string) {
+    this.Chunk = Chunks(version) as ReturnType<typeof Chunks>
+    this.solidityTable = getCameraCollisionSolidityTable(version)
+    this.sections.clear()
+  }
+
+  setWorldBounds(minY: number, worldHeight: number) {
+    if (this.worldMinY === minY && this.worldMaxY === worldHeight) return
+    this.worldMinY = minY
+    this.worldMaxY = worldHeight
+    this.sections.clear()
+  }
+
+  clear() {
+    this.sections.clear()
+  }
+
+  /** Allocated 16³ section bitsets (512 bytes each). */
+  getAllocatedSectionCount(): number {
+    return this.sections.size
+  }
+
+  getAllocatedBytes(): number {
+    return this.sections.size * CAMERA_COLLISION_BYTES_PER_SECTION
+  }
+
+  removeColumn(chunkX: number, chunkZ: number) {
+    const syStart = alignSection(this.worldMinY)
+    for (let sy = syStart; sy < this.worldMaxY; sy += 16) {
+      this.sections.delete(sectionKey(chunkX, sy, chunkZ))
+    }
+  }
+
+  ingestColumn(chunkX: number, chunkZ: number, chunkJson: unknown) {
+    const chunk = this.Chunk.fromJson(chunkJson as Parameters<ReturnType<typeof Chunks>['fromJson']>[0]) as unknown as {
+      getBlockStateId: (pos: Vec3) => number
+    }
+    const pos = new Vec3(0, 0, 0)
+
+    for (let y = this.worldMinY; y < this.worldMaxY; y++) {
+      pos.y = y
+      const sy = alignSection(y)
+      const ly = y - sy
+      for (let lz = 0; lz < 16; lz++) {
+        pos.z = lz
+        const wz = chunkZ + lz
+        const sz = alignSection(wz)
+        const lzLocal = wz - sz
+        for (let lx = 0; lx < 16; lx++) {
+          pos.x = lx
+          const stateId = chunk.getBlockStateId(pos) || 0
+          if (!isStateIdSolidForCameraCollision(stateId, this.solidityTable)) continue
+
+          const wx = chunkX + lx
+          const sx = alignSection(wx)
+          const key = sectionKey(sx, sy, sz)
+          let bits = this.sections.get(key)
+          if (!bits) {
+            bits = new Uint32Array(WORDS_PER_SECTION)
+            this.sections.set(key, bits)
+          }
+          setBit(bits, blockBitIndex(wx - sx, ly, lzLocal), true)
+        }
+      }
+    }
+  }
+
+  setBlockStateId(x: number, y: number, z: number, stateId: number) {
+    if (y < this.worldMinY || y >= this.worldMaxY) return
+
+    const sx = alignSection(x)
+    const sy = alignSection(y)
+    const sz = alignSection(z)
+    const key = sectionKey(sx, sy, sz)
+    const idx = blockBitIndex(localCoord(x), y - sy, localCoord(z))
+    const solid = isStateIdSolidForCameraCollision(stateId, this.solidityTable)
+
+    if (solid) {
+      let bits = this.sections.get(key)
+      if (!bits) {
+        bits = new Uint32Array(WORDS_PER_SECTION)
+        this.sections.set(key, bits)
+      }
+      setBit(bits, idx, true)
+      return
+    }
+
+    const bits = this.sections.get(key)
+    if (!bits) return
+    setBit(bits, idx, false)
+    if (isBitsetEmpty(bits)) this.sections.delete(key)
+  }
+
+  isSolidBlock(x: number, y: number, z: number): boolean {
+    if (y < this.worldMinY || y >= this.worldMaxY) return false
+
+    const bits = this.sections.get(sectionKey(alignSection(x), alignSection(y), alignSection(z)))
+    if (!bits) return false
+
+    return getBit(bits, blockBitIndex(localCoord(x), y - alignSection(y), localCoord(z)))
+  }
+}

package/src/three/cameraCollisionSolidity.ts

@@ -0,0 +1,50 @@
+//@ts-nocheck
+import MinecraftData from 'minecraft-data'
+import PrismarineBlockLoader from 'prismarine-block'
+import moreBlockDataGeneratedJson from '../lib/moreBlockDataGenerated.json'
+
+const solidityCache = new Map<string, Uint8Array>()
+
+const PASS_THROUGH_NAMES = new Set(['water', 'flowing_water', 'lava', 'flowing_lava', 'grass', 'short_grass', 'tall_grass'])
+
+/** 1 = blocks third-person camera DDA; 0 = pass-through (air, plants, fluids). */
+export function getCameraCollisionSolidityTable(version: string): Uint8Array {
+  const cached = solidityCache.get(version)
+  if (cached) return cached
+
+  const mcData = MinecraftData(version)
+  const Block = PrismarineBlockLoader(version)
+  const noOcclusionsSet = new Set(Object.keys(moreBlockDataGeneratedJson.noOcclusions))
+  const invisibleNames = new Set(mcData.blocksArray.filter(b => moreBlockDataGeneratedJson.invisibleBlocks[b.name]).map(b => b.name))
+
+  let maxStateId = 0
+  for (const idStr of Object.keys((mcData as { blocksByStateId: Record<string, unknown> }).blocksByStateId)) {
+    maxStateId = Math.max(maxStateId, Number(idStr))
+  }
+
+  const table = new Uint8Array(maxStateId + 1)
+  for (const idStr of Object.keys((mcData as { blocksByStateId: Record<string, unknown> }).blocksByStateId)) {
+    const stateId = Number(idStr)
+    if (!stateId) continue
+
+    const block = (
+      Block as { fromStateId: (id: number, y: number) => { name: string; transparent: boolean; boundingBox: string; shapes?: number[][] } | null }
+    ).fromStateId(stateId, 0)
+    if (!block) continue
+    if (invisibleNames.has(block.name)) continue
+    if (noOcclusionsSet.has(block.name)) continue
+    if (PASS_THROUGH_NAMES.has(block.name)) continue
+    if (block.boundingBox === 'empty') continue
+    if (block.transparent && block.boundingBox !== 'block') continue
+    if (!block.shapes || block.shapes.length === 0) continue
+
+    table[stateId] = 1
+  }
+
+  solidityCache.set(version, table)
+  return table
+}
+
+export function isStateIdSolidForCameraCollision(stateId: number, solidityTable: Uint8Array): boolean {
+  return stateId > 0 && stateId < solidityTable.length && solidityTable[stateId] === 1
+}

package/src/three/cameraShake.ts

@@ -5,9 +5,13 @@ import { WorldRendererThree } from './worldRendererThree'
 
 export class CameraShake {
   private rollAngle = 0
-  private get damageRollAmount() { return 5 }
-  private get damageAnimDuration() { return 200 }
-  private rollAnimation?: { startTime: number, startRoll: number, targetRoll: number, duration: number, returnToZero?: boolean }
+  private get damageRollAmount() {
+    return 5
+  }
+  private get damageAnimDuration() {
+    return 200
+  }
+  private rollAnimation?: { startTime: number; startRoll: number; targetRoll: number; duration: number; returnToZero?: boolean }
   private basePitch = 0
   private baseYaw = 0
   private cameraBobInput: CameraBobInput | null = null
@@ -16,7 +20,10 @@ export class CameraShake {
     this.cameraBobInput = input
   }
 
-  constructor(public worldRenderer: WorldRendererThree, public onRenderCallbacks: Array<(deltaTime: number) => void>) {
+  constructor(
+    public worldRenderer: WorldRendererThree,
+    public onRenderCallbacks: Array<(deltaTime: number) => void>
+  ) {
     onRenderCallbacks.push(() => {
       this.update()
     })
@@ -133,10 +140,12 @@ export class CameraShake {
     const normalizedAngle = ((angle % (Math.PI * 2)) + Math.PI * 2) % (Math.PI * 2)
     const tolerance = 0.01 // Tolerance for considering an angle "ideal"
 
-    if (Math.abs(normalizedAngle) < tolerance ||
+    if (
+      Math.abs(normalizedAngle) < tolerance ||
       Math.abs(normalizedAngle - Math.PI / 2) < tolerance ||
       Math.abs(normalizedAngle - Math.PI) < tolerance ||
-      Math.abs(normalizedAngle - 3 * Math.PI / 2) < tolerance) {
+      Math.abs(normalizedAngle - (3 * Math.PI) / 2) < tolerance
+    ) {
       return angle + offset
     }