minecraft-renderer 0.1.0

package/src/mesher/test/tests.test.ts

@@ -0,0 +1,56 @@
+import { test, expect } from 'vitest'
+import supportedVersions from '../../../../../src/supportedVersions.mjs'
+import { INVISIBLE_BLOCKS } from '../worldConstants'
+import { setup } from './mesherTester'
+
+const lastVersion = supportedVersions.at(-1)
+
+const addPositions = [
+  // [[0, 0, 0], 'diamond_block'],
+  // [[1, 0, 0], 'stone'],
+  // [[-1, 0, 0], 'stone'],
+  // [[0, 1, 0], 'stone'],
+  // [[0, -1, 0], 'stone'],
+  // [[0, 0, 1], 'stone'],
+  // [[0, 0, -1], 'stone'],
+] as const
+
+test('Known blocks are not rendered', () => {
+  const { mesherWorld, getGeometry, pos, mcData } = setup(lastVersion, addPositions as any)
+  const ignoreAsExpected = new Set([...INVISIBLE_BLOCKS, 'water', 'lava'])
+
+  let time = 0
+  let times = 0
+  const missingBlocks = {}/*  as {[number, number]} */
+  const erroredBlocks = {}/*  as {[number, number]} */
+  for (const block of mcData.blocksArray) {
+    if (ignoreAsExpected.has(block.name)) continue
+    // if (block.maxStateId! - block.minStateId! > 100) continue
+    // for (let i = block.minStateId!; i <= block.maxStateId!; i++) {
+    for (let i = block.defaultState; i <= block.defaultState; i++) {
+      // if (block.transparent) continue
+      mesherWorld.setBlockStateId(pos, i)
+      const start = performance.now()
+      const { centerFaces, totalTiles, centerTileNeighbors, attr } = getGeometry()
+      time += performance.now() - start
+      times++
+      if (centerFaces === 0) {
+        const objAdd = attr.hadErrors ? erroredBlocks : missingBlocks
+        if (objAdd[block.name]) continue
+        objAdd[block.name] = true
+        // invalidBlocks[block.name] = [i - block.defaultState!, centerTileNeighbors]
+        // console.log('INVALID', block.name, centerTileNeighbors, i - block.minStateId)
+      }
+    }
+  }
+  console.log('Checking blocks of version', lastVersion)
+  console.log('Average time', time / times)
+  // should be fixed, but to avoid regressions & for visibility
+  // TODO resolve creaking_heart issue (1.21.3)
+  expect(missingBlocks).toMatchInlineSnapshot(`
+    {
+      "structure_void": true,
+    }
+  `)
+  expect(erroredBlocks).toMatchInlineSnapshot('{}')
+})

package/src/mesher/world.ts

@@ -0,0 +1,294 @@
+import Chunks from 'prismarine-chunk'
+import mcData from 'minecraft-data'
+import { Block } from 'prismarine-block'
+import { Vec3 } from 'vec3'
+import { WorldBlockProvider } from 'mc-assets/dist/worldBlockProvider'
+import moreBlockDataGeneratedJson from '../lib/moreBlockDataGenerated.json'
+import legacyJson from '../lib/preflatMap.json'
+import { getBlockPosKey } from '../lib/simpleUtils'
+import { defaultMesherConfig, CustomBlockModels, BlockStateModelInfo, getBlockAssetsCacheKey, MesherGeometryOutput } from './shared'
+import { INVISIBLE_BLOCKS } from './worldConstants'
+import { buildRotationMatrix, elemFaces, matmul3, matmulmat3, vecadd3, vecsub3 } from './modelsGeometryCommon'
+
+const ignoreAoBlocks = Object.keys(moreBlockDataGeneratedJson.noOcclusions)
+
+export function worldColumnKey(x, z) {
+  return `${x},${z}`
+}
+
+function isCube(shapes) {
+  if (!shapes || shapes.length !== 1) return false
+  const shape = shapes[0]
+  return shape[0] === 0 && shape[1] === 0 && shape[2] === 0 && shape[3] === 1 && shape[4] === 1 && shape[5] === 1
+}
+
+export type ElementPrecomputed = {
+  faces: {
+    [face: string]: {
+      dir: [number, number, number]
+      corners: Array<{
+        pos: number[]
+        vertex: number[]
+        uvs: number[]
+
+        side1Dir: [number, number, number]
+        side2Dir: [number, number, number]
+        cornerDir: [number, number, number]
+      }>
+    }
+  }
+}
+
+type BlockDataPrecomputed = {
+  initialMatrix?: any
+  initialShift?: any
+  elementsPrecomputed?: ElementPrecomputed[]
+}
+
+export type BlockModelPartsResolved = Array<Array<ReturnType<WorldBlockProvider['getAllResolvedModels0_1']>[number][number] & BlockDataPrecomputed>>
+
+export type WorldBlock = Omit<Block, 'position'> & {
+  // todo
+  isCube: boolean
+  /** cache */
+  models?: BlockModelPartsResolved | null
+  _originalProperties?: Record<string, any>
+  _properties?: Record<string, any>
+}
+
+export class World {
+  config = defaultMesherConfig
+  Chunk: typeof import('prismarine-chunk/types/index').PCChunk
+  columns = {} as { [key: string]: import('prismarine-chunk/types/index').PCChunk }
+  blockCache = {}
+  biomeCache: { [id: number]: mcData.Biome }
+  preflat: boolean
+  erroredBlockModel?: BlockModelPartsResolved
+  customBlockModels = new Map<string, CustomBlockModels>() // chunkKey -> blockModels
+  sentBlockStateModels = new Set<string>()
+  blockStateModelInfo = new Map<string, BlockStateModelInfo>()
+
+  constructor(version) {
+    this.Chunk = Chunks(version) as any
+    this.biomeCache = mcData(version).biomes
+    this.preflat = !mcData(version).supportFeature('blockStateId')
+    this.config.version = version
+  }
+
+  getLight(pos: Vec3, isNeighbor = false, skipMoreChecks = false, curBlockName = '') {
+    // for easier testing
+    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
+    )
+    // 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
+      const lights = [
+        this.getLight(pos.offset(0, 1, 0), undefined, true),
+        this.getLight(pos.offset(0, -1, 0), undefined, true),
+        this.getLight(pos.offset(0, 0, 1), undefined, true),
+        this.getLight(pos.offset(0, 0, -1), undefined, true),
+        this.getLight(pos.offset(1, 0, 0), undefined, true),
+        this.getLight(pos.offset(-1, 0, 0), undefined, true)
+      ].filter(x => x !== 2)
+      if (lights.length) {
+        const min = Math.min(...lights)
+        result = min
+      }
+    }
+    if (isNeighbor && result === 2) result = 15 // TODO
+    return result
+  }
+
+  addColumn(x, z, json) {
+    const chunk = this.Chunk.fromJson(json)
+    this.columns[worldColumnKey(x, z)] = chunk as any
+    return chunk
+  }
+
+  removeColumn(x, z) {
+    delete this.columns[worldColumnKey(x, z)]
+  }
+
+  getColumn(x, z) {
+    return this.columns[worldColumnKey(x, z)]
+  }
+
+  setBlockStateId(pos: Vec3, stateId) {
+    if (stateId === undefined) throw new Error('stateId is undefined')
+    const key = worldColumnKey(Math.floor(pos.x / 16) * 16, Math.floor(pos.z / 16) * 16)
+
+    const column = this.columns[key]
+    // null column means chunk not loaded
+    if (!column) return false
+
+    column.setBlockStateId(posInChunk(pos.floored()), stateId)
+
+    return true
+  }
+
+  getColumnByPos(pos: Vec3) {
+    return this.getColumn(Math.floor(pos.x / 16) * 16, Math.floor(pos.z / 16) * 16)
+  }
+
+  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])
+    const chunkKey = worldColumnKey(Math.floor(pos.x / 16) * 16, Math.floor(pos.z / 16) * 16)
+    const modelOverride = this.customBlockModels.get(chunkKey)?.[getBlockPosKey(pos)]
+
+    const column = this.columns[chunkKey]
+    // null column means chunk not loaded
+    if (!column) return null
+
+    const loc = pos.floored()
+    const locInChunk = posInChunk(loc)
+    const stateId = column.getBlockStateId(locInChunk)
+
+    const cacheKey = getBlockAssetsCacheKey(stateId, modelOverride)
+
+    if (!this.blockCache[cacheKey]) {
+      const b = column.getBlock(locInChunk) as unknown as WorldBlock
+      if (modelOverride) {
+        b.name = modelOverride
+      }
+      b.isCube = isCube(b.shapes)
+      this.blockCache[cacheKey] = b
+      Object.defineProperty(b, 'position', {
+        get() {
+          throw new Error('position is not reliable, use pos parameter instead of block.position')
+        }
+      })
+      if (this.preflat) {
+        b._properties = {}
+
+        const namePropsStr = legacyJson.blocks[b.type + ':' + b.metadata] || findClosestLegacyBlockFallback(b.type, b.metadata, pos)
+        if (namePropsStr) {
+          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]
+            }))
+            b._properties = newProperties
+          }
+        }
+      }
+    }
+
+    const block: WorldBlock = this.blockCache[cacheKey]
+
+    if (block.models === undefined && blockProvider) {
+      if (!attr) throw new Error('attr is required')
+      const props = block.getProperties()
+
+      try {
+        // fixme
+        if (this.preflat) {
+          if (block.name === 'cobblestone_wall') {
+            props.up = 'true'
+            for (const key of ['north', 'south', 'east', 'west']) {
+              const val = props[key]
+              if (val === 'false' || val === 'true') {
+                props[key] = val === 'true' ? 'low' : 'none'
+              }
+            }
+          }
+        }
+
+        const useFallbackModel = !!(this.preflat || modelOverride)
+        const issues = [] as string[]
+        const resolvedModelNames = [] as string[]
+        const resolvedConditions = [] as string[]
+        block.models = blockProvider.getAllResolvedModels0_1(
+          {
+            name: block.name,
+            properties: props,
+          },
+          useFallbackModel,
+          issues,
+          resolvedModelNames,
+          resolvedConditions
+        )!
+
+        // Track block state model info
+        if (!this.sentBlockStateModels.has(cacheKey)) {
+          this.blockStateModelInfo.set(cacheKey, {
+            cacheKey,
+            issues,
+            modelNames: resolvedModelNames,
+            conditions: resolvedConditions
+          })
+        }
+
+        if (!block.models.length) {
+          if (block.name !== 'water' && block.name !== 'lava' && !INVISIBLE_BLOCKS.has(block.name)) {
+            console.debug('[mesher] block to render not found', block.name, props)
+          }
+          block.models = null
+        }
+
+        if (block.models && modelOverride) {
+          const model = block.models[0]
+          block.transparent = model[0]?.['transparent'] ?? block.transparent
+        }
+      } catch (err) {
+        this.erroredBlockModel ??= blockProvider.getAllResolvedModels0_1({ name: 'errored', properties: {} })
+        block.models ??= this.erroredBlockModel
+        console.error(`Critical assets error. Unable to get block model for ${block.name}[${JSON.stringify(props)}]: ` + err.message, err.stack)
+        attr.hadErrors = true
+      }
+    }
+
+    if (block.name === 'flowing_water') block.name = 'water'
+    if (block.name === 'flowing_lava') block.name = 'lava'
+    if (block.name === 'bubble_column') block.name = 'water' // TODO need to distinguish between water and bubble column
+    // block.position = loc // it overrides position of all currently loaded blocks
+    //@ts-expect-error
+    block.biome = this.biomeCache[column.getBiome(locInChunk)] ?? this.biomeCache[1] ?? this.biomeCache[0]
+    if (block.name === 'redstone_ore') block.transparent = false
+    return block
+  }
+
+  shouldMakeAo(block: WorldBlock | null) {
+    return block?.isCube && !ignoreAoBlocks.includes(block.name) && block.boundingBox !== 'empty'
+  }
+}
+
+const findClosestLegacyBlockFallback = (id, metadata, pos) => {
+  console.warn(`[mesher] Unknown block with ${id}:${metadata} at ${pos}, falling back`) // todo has known issues
+  for (const [key, value] of Object.entries(legacyJson.blocks)) {
+    const [idKey, meta] = key.split(':')
+    if (idKey === id) return value
+  }
+  return null
+}
+
+// todo export in chunk instead
+const hasChunkSection = (column, pos) => {
+  if (column._getSection) return column._getSection(pos)
+  if (column.skyLightSections) {
+    return column.skyLightSections[getLightSectionIndex(pos, column.minY)] || column.blockLightSections[getLightSectionIndex(pos, column.minY)]
+  }
+  if (column.sections) return column.sections[pos.y >> 4]
+}
+
+function posInChunk(pos) {
+  return new Vec3(Math.floor(pos.x) & 15, Math.floor(pos.y), Math.floor(pos.z) & 15)
+}
+
+function getLightSectionIndex(pos, minY = 0) {
+  return Math.floor((pos.y - minY) / 16) + 1
+}

package/src/mesher/worldConstants.ts

@@ -0,0 +1 @@
+export const INVISIBLE_BLOCKS = new Set(['air', 'void_air', 'cave_air', 'barrier', 'light', 'moving_piston'])

package/src/modules/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Renderer Modules System
+ *
+ * Provides a standardized way to create and manage renderer extensions.
+ */
+
+// Types
+export * from './types'
+
+// Built-in modules
+export * from './starfield'

package/src/modules/starfield.ts

@@ -0,0 +1,313 @@
+/**
+ * StarField Module - Renders a twinkling star field effect for night sky.
+ *
+ * Uses Three.js Points with custom shader material for twinkling effect.
+ */
+
+import * as THREE from 'three'
+import type {
+  ModuleManifest,
+  ModuleContext,
+  RendererModule,
+  ModuleSettingsSchema,
+  InferSettings
+} from './types'
+
+// Get Three.js revision as integer
+const threeVersion = parseInt(THREE.REVISION.replaceAll(/\D+/g, ''), 10)
+
+// ============================================================================
+// Settings Schema
+// ============================================================================
+
+const starfieldSettingsSchema = {
+  radius: {
+    default: 80,
+    label: 'Radius',
+    description: 'Inner radius of the star sphere',
+    min: 20,
+    max: 200,
+  },
+  depth: {
+    default: 50,
+    label: 'Depth',
+    description: 'Thickness of the star sphere',
+    min: 10,
+    max: 100,
+  },
+  count: {
+    default: 7000,
+    label: 'Star Count',
+    description: 'Number of stars to render',
+    min: 1000,
+    max: 20000,
+    step: 1000,
+  },
+  factor: {
+    default: 7,
+    label: 'Size Factor',
+    description: 'Star size multiplier',
+    min: 1,
+    max: 20,
+  },
+  saturation: {
+    default: 10,
+    label: 'Saturation',
+    description: 'Color saturation of stars',
+    min: 0,
+    max: 100,
+  },
+  speed: {
+    default: 0.2,
+    label: 'Twinkle Speed',
+    description: 'Speed of twinkling animation',
+    min: 0,
+    max: 1,
+    step: 0.1,
+  },
+  autoTimeOfDay: {
+    default: true,
+    label: 'Auto Time-of-Day',
+    description: 'Automatically show/hide stars based on in-game time',
+  },
+} as const satisfies ModuleSettingsSchema
+
+export type StarfieldSettings = typeof starfieldSettingsSchema
+
+// ============================================================================
+// Custom Shader Material
+// ============================================================================
+
+class StarfieldMaterial extends THREE.ShaderMaterial {
+  constructor() {
+    super({
+      uniforms: { time: { value: 0 }, fade: { value: 1 } },
+      vertexShader: /* glsl */ `
+        uniform float time;
+        attribute float size;
+        varying vec3 vColor;
+        attribute vec3 color;
+        void main() {
+          vColor = color;
+          vec4 mvPosition = modelViewMatrix * vec4(position, 0.5);
+          gl_PointSize = 0.7 * size * (30.0 / -mvPosition.z) * (3.0 + sin(time + 100.0));
+          gl_Position = projectionMatrix * mvPosition;
+        }`,
+      fragmentShader: /* glsl */ `
+        uniform sampler2D pointTexture;
+        uniform float fade;
+        varying vec3 vColor;
+        void main() {
+          float opacity = 1.0;
+          gl_FragColor = vec4(vColor, 1.0);
+
+          #include <tonemapping_fragment>
+          #include <${threeVersion >= 154 ? 'colorspace_fragment' : 'encodings_fragment'}>
+        }`,
+    })
+  }
+}
+
+// ============================================================================
+// Module Manifest
+// ============================================================================
+
+export const starfieldManifest: ModuleManifest<StarfieldSettings> = {
+  id: 'starfield',
+  name: 'Star Field',
+  description: 'Renders a twinkling star field effect for the night sky',
+  version: '1.0.0',
+  settings: starfieldSettingsSchema,
+}
+
+// ============================================================================
+// Starfield Module Implementation
+// ============================================================================
+
+export class StarfieldModule implements RendererModule<StarfieldSettings> {
+  readonly manifest = starfieldManifest
+
+  // Current settings (mutable)
+  private _settings: InferSettings<StarfieldSettings>
+
+  // Module state
+  private _enabled = true
+  private context?: ModuleContext
+  private points?: THREE.Points
+  private readonly clock = new THREE.Clock()
+  private renderCallback?: () => void
+
+  constructor(initialSettings?: Partial<InferSettings<StarfieldSettings>>) {
+    // Initialize settings with defaults
+    this._settings = {
+      radius: starfieldSettingsSchema.radius.default,
+      depth: starfieldSettingsSchema.depth.default,
+      count: starfieldSettingsSchema.count.default,
+      factor: starfieldSettingsSchema.factor.default,
+      saturation: starfieldSettingsSchema.saturation.default,
+      speed: starfieldSettingsSchema.speed.default,
+      autoTimeOfDay: starfieldSettingsSchema.autoTimeOfDay.default,
+      ...initialSettings,
+    }
+  }
+
+  get settings(): InferSettings<StarfieldSettings> {
+    return this._settings
+  }
+
+  get enabled(): boolean {
+    return this._enabled
+  }
+
+  set enabled(value: boolean) {
+    if (this._enabled === value) return
+    this._enabled = value
+
+    if (value) {
+      this.onEnable?.()
+    } else {
+      this.onDisable?.()
+    }
+  }
+
+  init(context: ModuleContext): void {
+    this.context = context
+
+    // Create render callback
+    this.renderCallback = () => {
+      if (!this.points || !this.context) return
+      this.points.position.copy(this.context.getCameraPosition())
+        ; (this.points.material as StarfieldMaterial).uniforms.time.value =
+          this.clock.getElapsedTime() * this._settings.speed
+    }
+
+    if (this._enabled) {
+      this.createStars()
+      context.onRender(this.renderCallback)
+    }
+  }
+
+  setSetting<K extends keyof StarfieldSettings>(
+    key: K,
+    value: StarfieldSettings[K]['default']
+  ): void {
+    (this._settings as any)[key] = value
+
+    // Recreate stars if geometry-affecting settings change
+    if (['radius', 'depth', 'count', 'factor', 'saturation'].includes(key as string)) {
+      this.recreateStars()
+    }
+  }
+
+  onEnable(): void {
+    if (!this.context) return
+    this.createStars()
+    if (this.renderCallback) {
+      this.context.onRender(this.renderCallback)
+    }
+  }
+
+  onDisable(): void {
+    this.removeStars()
+    if (this.context && this.renderCallback) {
+      this.context.offRender(this.renderCallback)
+    }
+  }
+
+  /**
+   * Update visibility based on time of day (0-24000 Minecraft ticks).
+   */
+  updateTimeOfDay(time: number): void {
+    if (!this._settings.autoTimeOfDay) return
+
+    const nightTime = 13_500
+    const morningStart = 23_000
+    const displayStars = time > nightTime && time < morningStart
+
+    if (displayStars && !this.points) {
+      this.createStars()
+    } else if (!displayStars && this.points) {
+      this.removeStars()
+    }
+  }
+
+  private createStars(): void {
+    if (!this.context || this.points) return
+
+    const { radius, depth, count, factor, saturation } = this._settings
+
+    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
+        )
+      )
+
+    const positions: number[] = []
+    const colors: number[] = []
+    const sizes = Array.from({ length: count }, () => (0.5 + 0.5 * Math.random()) * factor)
+    const color = new THREE.Color()
+    let r = radius + depth
+    const increment = depth / count
+
+    for (let i = 0; i < count; i++) {
+      r -= increment * Math.random()
+      positions.push(...genStar(r).toArray())
+      color.setHSL(i / count, saturation, 0.9)
+      colors.push(color.r, color.g, color.b)
+    }
+
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3))
+    geometry.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3))
+    geometry.setAttribute('size', new THREE.Float32BufferAttribute(sizes, 1))
+
+    const material = new StarfieldMaterial()
+    material.blending = THREE.AdditiveBlending
+    material.depthTest = false
+    material.transparent = true
+
+    this.points = new THREE.Points(geometry, material)
+    this.points.renderOrder = -1
+    this.context.scene.add(this.points)
+  }
+
+  private removeStars(): void {
+    if (!this.context || !this.points) return
+
+    this.points.geometry.dispose()
+      ; (this.points.material as THREE.Material).dispose()
+    this.context.scene.remove(this.points)
+    this.points = undefined
+  }
+
+  private recreateStars(): void {
+    if (!this._enabled) return
+    this.removeStars()
+    this.createStars()
+  }
+
+  dispose(): void {
+    this.onDisable()
+    this.context = undefined
+  }
+}
+
+// ============================================================================
+// Module Factory
+// ============================================================================
+
+/**
+ * Create a new StarfieldModule instance.
+ */
+export const createStarfieldModule = (
+  initialSettings?: Partial<InferSettings<StarfieldSettings>>
+): StarfieldModule => {
+  return new StarfieldModule(initialSettings)
+}
+
+// Re-export the old class for backwards compatibility
+export { StarfieldModule as StarField }