minecraft-renderer 0.1.0

package/src/lib/guiRenderer.ts

@@ -0,0 +1,283 @@
+// Import placeholders - replace with actual imports for your environment
+import { ItemRenderer, Identifier, ItemStack, NbtString, Structure, StructureRenderer, ItemRendererResources, BlockDefinition, BlockModel, TextureAtlas, Resources, ItemModel } from 'deepslate'
+import { AssetsParser } from 'mc-assets/dist/assetsParser'
+import { getLoadedImage, versionToNumber } from 'mc-assets/dist/utils'
+import { BlockModel as BlockModelMcAssets, AtlasParser } from 'mc-assets'
+import { getLoadedBlockstatesStore, getLoadedModelsStore } from 'mc-assets/dist/stores'
+import { makeTextureAtlas } from 'mc-assets/dist/atlasCreator'
+import { proxy, ref } from 'valtio'
+import { getItemDefinition } from 'mc-assets/dist/itemDefinitions'
+import { AppViewer } from '@/graphicsBackend/appViewer'
+
+export const getNonFullBlocksModels = (appViewer: AppViewer) => {
+  let version = appViewer.resourcesManager.currentResources!.version ?? 'latest'
+  if (versionToNumber(version) < versionToNumber('1.13')) version = '1.13'
+  const itemsDefinitions = appViewer.resourcesManager.currentResources!.itemsDefinitionsStore.data.latest
+  const blockModelsResolved = {} as Record<string, any>
+  const itemsModelsResolved = {} as Record<string, any>
+  const fullBlocksWithNonStandardDisplay = [] as string[]
+  const handledItemsWithDefinitions = new Set()
+  const assetsParser = new AssetsParser(version, getLoadedBlockstatesStore(appViewer.resourcesManager.currentResources!.blockstatesModels), getLoadedModelsStore(appViewer.resourcesManager.currentResources!.blockstatesModels))
+
+  const standardGuiDisplay = {
+    'rotation': [
+      30,
+      225,
+      0
+    ],
+    'translation': [
+      0,
+      0,
+      0
+    ],
+    'scale': [
+      0.625,
+      0.625,
+      0.625
+    ]
+  }
+
+  const arrEqual = (a: number[], b: number[]) => a.length === b.length && a.every((x, i) => x === b[i])
+  const addModelIfNotFullblock = (name: string, model: BlockModelMcAssets) => {
+    if (blockModelsResolved[name]) return
+    if (!model?.elements?.length) return
+    const isFullBlock = model.elements.length === 1 && arrEqual(model.elements[0].from, [0, 0, 0]) && arrEqual(model.elements[0].to, [16, 16, 16])
+    if (isFullBlock) return
+    const hasBetterPrerender = assetsParser.blockModelsStore.data.latest[`item/${name}`]?.textures?.['layer0']?.startsWith('invsprite_')
+    if (hasBetterPrerender) return
+    model['display'] ??= {}
+    model['display']['gui'] ??= standardGuiDisplay
+    blockModelsResolved[name] = model
+  }
+
+  for (const [name, definition] of Object.entries(itemsDefinitions)) {
+    const item = getItemDefinition(appViewer.resourcesManager.currentResources!.itemsDefinitionsStore, {
+      version,
+      name,
+      properties: {
+        'minecraft:display_context': 'gui',
+      },
+    })
+    if (item) {
+      const { resolvedModel } = assetsParser.getResolvedModelsByModel((item.special ? name : item.model).replace('minecraft:', '')) ?? {}
+      if (resolvedModel) {
+        handledItemsWithDefinitions.add(name)
+      }
+      if (resolvedModel?.elements) {
+        let hasStandardDisplay = true
+        if (resolvedModel['display']?.gui) {
+          hasStandardDisplay =
+            arrEqual(resolvedModel['display'].gui.rotation, standardGuiDisplay.rotation)
+            && arrEqual(resolvedModel['display'].gui.translation, standardGuiDisplay.translation)
+            && arrEqual(resolvedModel['display'].gui.scale, standardGuiDisplay.scale)
+        }
+
+        addModelIfNotFullblock(name, resolvedModel)
+
+        if (!blockModelsResolved[name] && !hasStandardDisplay) {
+          fullBlocksWithNonStandardDisplay.push(name)
+        }
+        const notSideLight = resolvedModel['gui_light'] && resolvedModel['gui_light'] !== 'side'
+        if (!hasStandardDisplay || notSideLight) {
+          blockModelsResolved[name] = resolvedModel
+        }
+      }
+      if (!blockModelsResolved[name] && item.tints && resolvedModel) {
+        resolvedModel['tints'] = item.tints
+        if (resolvedModel.elements) {
+          blockModelsResolved[name] = resolvedModel
+        } else {
+          itemsModelsResolved[name] = resolvedModel
+        }
+      }
+    }
+  }
+
+  for (const [name, blockstate] of Object.entries(appViewer.resourcesManager.currentResources!.blockstatesModels.blockstates.latest)) {
+    if (handledItemsWithDefinitions.has(name)) {
+      continue
+    }
+    const resolvedModel = assetsParser.getResolvedModelFirst({ name: name.replace('minecraft:', ''), properties: {} }, true)
+    if (resolvedModel) {
+      addModelIfNotFullblock(name, resolvedModel[0])
+    }
+  }
+
+  return {
+    blockModelsResolved,
+    itemsModelsResolved
+  }
+}
+
+// customEvents.on('gameLoaded', () => {
+//   const res = getNonFullBlocksModels()
+// })
+
+const RENDER_SIZE = 64
+
+const generateItemsGui = async (models: Record<string, BlockModelMcAssets>, isItems = false) => {
+  const { currentResources } = appViewer.resourcesManager
+  const imgBitmap = isItems ? currentResources!.itemsAtlasImage : currentResources!.blocksAtlasImage
+  const canvasTemp = document.createElement('canvas')
+  canvasTemp.width = imgBitmap.width
+  canvasTemp.height = imgBitmap.height
+  canvasTemp.style.imageRendering = 'pixelated'
+  const ctx = canvasTemp.getContext('2d')!
+  ctx.imageSmoothingEnabled = false
+  ctx.drawImage(imgBitmap, 0, 0)
+
+  const atlasParser = isItems ? appViewer.resourcesManager.itemsAtlasParser : appViewer.resourcesManager.blocksAtlasParser
+  const textureAtlas = new TextureAtlas(
+    ctx.getImageData(0, 0, imgBitmap.width, imgBitmap.height),
+    Object.fromEntries(Object.entries(atlasParser.atlas.latest.textures).map(([key, value]) => {
+      return [key, [
+        value.u,
+        value.v,
+        (value.u + (value.su ?? atlasParser.atlas.latest.suSv)),
+        (value.v + (value.sv ?? atlasParser.atlas.latest.suSv)),
+      ]] as [string, [number, number, number, number]]
+    }))
+  )
+
+  const PREVIEW_ID = Identifier.parse('preview:preview')
+  const PREVIEW_DEFINITION = new BlockDefinition({ '': { model: PREVIEW_ID.toString() } }, undefined)
+
+  let textureWasRequested = false
+  let modelData: any
+  let currentModelName: string | undefined
+  const resources: ItemRendererResources = {
+    getBlockModel(id) {
+      if (id.equals(PREVIEW_ID)) {
+        return BlockModel.fromJson(modelData ?? {})
+      }
+      return null
+    },
+    getTextureUV(texture) {
+      textureWasRequested = true
+      return textureAtlas.getTextureUV(texture.toString().replace('minecraft:', '').replace('block/', '').replace('item/', '').replace('blocks/', '').replace('items/', '') as any)
+    },
+    getTextureAtlas() {
+      return textureAtlas.getTextureAtlas()
+    },
+    getItemComponents(id) {
+      return new Map()
+    },
+    getItemModel(id) {
+      // const isSpecial = currentModelName === 'shield' || currentModelName === 'conduit' || currentModelName === 'trident'
+      const isSpecial = false
+      if (id.equals(PREVIEW_ID)) {
+        return ItemModel.fromJson({
+          type: isSpecial ? 'minecraft:special' : 'minecraft:model',
+          model: isSpecial ? {
+            type: currentModelName,
+          } : PREVIEW_ID.toString(),
+          base: PREVIEW_ID.toString(),
+          tints: modelData?.tints,
+        })
+      }
+      return null
+    },
+  }
+
+  const canvas = document.createElement('canvas')
+  canvas.width = RENDER_SIZE
+  canvas.height = RENDER_SIZE
+  const gl = canvas.getContext('webgl2', { preserveDrawingBuffer: true })
+  if (!gl) {
+    throw new Error('Cannot get WebGL2 context')
+  }
+
+  function resetGLContext(gl) {
+    gl.clearColor(0, 0, 0, 0)
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)
+  }
+
+  // const includeOnly = ['powered_repeater', 'wooden_door']
+  const includeOnly = [] as string[]
+
+  const images: Record<string, HTMLImageElement> = {}
+  const item = new ItemStack(PREVIEW_ID, 1, new Map(Object.entries({
+    'minecraft:item_model': new NbtString(PREVIEW_ID.toString()),
+  })))
+  const renderer = new ItemRenderer(gl, item, resources, { display_context: 'gui' })
+  const missingTextures = new Set()
+  for (const [modelName, model] of Object.entries(models)) {
+    textureWasRequested = false
+    if (includeOnly.length && !includeOnly.includes(modelName)) continue
+
+    const patchMissingTextures = () => {
+      for (const element of model.elements ?? []) {
+        for (const [faceName, face] of Object.entries(element.faces)) {
+          if (face.texture.startsWith('#')) {
+            missingTextures.add(`${modelName} ${faceName}: ${face.texture}`)
+            face.texture = 'block/unknown'
+          }
+        }
+      }
+    }
+    patchMissingTextures()
+    // TODO eggs
+
+    modelData = model
+    currentModelName = modelName
+    resetGLContext(gl)
+    if (!modelData) continue
+    renderer.setItem(item, { display_context: 'gui' })
+    renderer.drawItem()
+    if (!textureWasRequested) continue
+    const url = canvas.toDataURL()
+    // eslint-disable-next-line no-await-in-loop
+    const img = await getLoadedImage(url)
+    images[modelName] = img
+  }
+
+  if (missingTextures.size) {
+    console.warn(`[guiRenderer] Missing textures in ${[...missingTextures].join(', ')}`)
+  }
+
+  return images
+}
+
+/**
+ * @mainThread
+ */
+const generateAtlas = async (images: Record<string, HTMLImageElement>) => {
+  const atlas = makeTextureAtlas({
+    input: Object.keys(images),
+    tileSize: RENDER_SIZE,
+    getLoadedImage(name) {
+      return {
+        image: images[name],
+      }
+    },
+  })
+
+  // const atlasParser = new AtlasParser({ latest: atlas.json }, atlas.canvas.toDataURL())
+  // const a = document.createElement('a')
+  // a.href = await atlasParser.createDebugImage(true)
+  // a.download = 'blocks_atlas.png'
+  // a.click()
+
+  appViewer.resourcesManager.currentResources!.guiAtlas = {
+    json: atlas.json,
+    image: await createImageBitmap(atlas.canvas),
+  }
+
+  return atlas
+}
+
+export const generateGuiAtlas = async () => {
+  console.trace('generateGuiAtlas')
+  const { blockModelsResolved, itemsModelsResolved } = getNonFullBlocksModels()
+
+  // Generate blocks atlas
+  console.time('generate blocks gui atlas')
+  const blockImages = await generateItemsGui(blockModelsResolved, false)
+  console.timeEnd('generate blocks gui atlas')
+  console.time('generate items gui atlas')
+  const itemImages = await generateItemsGui(itemsModelsResolved, true)
+  console.timeEnd('generate items gui atlas')
+  await generateAtlas({ ...blockImages, ...itemImages })
+  appViewer.resourcesManager.currentResources!.guiAtlasVersion++
+  // await generateAtlas(blockImages)
+}

package/src/lib/items.ts

@@ -0,0 +1,140 @@
+import mojangson from 'mojangson'
+import nbt from 'prismarine-nbt'
+import { fromFormattedString } from '@xmcl/text-component'
+import { getItemSelector } from '@/playerState/playerState'
+import { getItemDefinition } from 'mc-assets/dist/itemDefinitions'
+import { ResourcesManagerCommon } from '@/resourcesManager'
+import { ItemSpecificContextProperties } from '@/playerState/types'
+import { PlayerStateRenderer } from '@/playerState/playerState'
+
+type RenderSlotComponent = {
+  type: string,
+  data: any
+  // example
+  // {
+  //   "type": "item_model",
+  //   "data": "aa:ss"
+  // }
+}
+export type RenderItem = Pick<import('prismarine-item').Item, 'name' | 'displayName' | 'durabilityUsed' | 'maxDurability' | 'enchants' | 'nbt'> & {
+  components?: RenderSlotComponent[],
+  // componentMap?: Map<string, RenderSlotComponent>
+}
+export type GeneralInputItem = Pick<import('prismarine-item').Item, 'name' | 'nbt'> & {
+  components?: RenderSlotComponent[],
+  displayName?: string
+  modelResolved?: boolean
+}
+
+type JsonString = string
+type PossibleItemProps = {
+  CustomModelData?: number
+  Damage?: number
+  display?: { Name?: JsonString } // {"text":"Knife","color":"white","italic":"true"}
+}
+
+export const getItemMetadata = (item: GeneralInputItem, resourcesManager: ResourcesManagerCommon) => {
+  let customText = undefined as string | any | undefined
+  let customModel = undefined as string | undefined
+
+  let itemId = item.name
+  if (!itemId.includes(':')) {
+    itemId = `minecraft:${itemId}`
+  }
+  const customModelDataDefinitions = resourcesManager.currentResources?.customItemModelNames[itemId]
+
+  if (item.components) {
+    const componentMap = new Map<string, RenderSlotComponent>()
+    for (const component of item.components) {
+      componentMap.set(component.type, component)
+    }
+
+    const customTextComponent = componentMap.get('custom_name') || componentMap.get('item_name')
+    if (customTextComponent) {
+      customText = typeof customTextComponent.data === 'string' ? customTextComponent.data : nbt.simplify(customTextComponent.data)
+    }
+    const customModelComponent = componentMap.get('item_model')
+    if (customModelComponent) {
+      customModel = customModelComponent.data
+    }
+    if (customModelDataDefinitions) {
+      const customModelDataComponent: any = componentMap.get('custom_model_data')
+      if (customModelDataComponent?.data) {
+        let customModelData: number | undefined
+        if (typeof customModelDataComponent.data === 'number') {
+          customModelData = customModelDataComponent.data
+        } else if (typeof customModelDataComponent.data === 'object'
+          && 'floats' in customModelDataComponent.data
+          && Array.isArray(customModelDataComponent.data.floats)
+          && customModelDataComponent.data.floats.length > 0) {
+          customModelData = customModelDataComponent.data.floats[0]
+        }
+        if (customModelData && customModelDataDefinitions[customModelData]) {
+          customModel = customModelDataDefinitions[customModelData]
+        }
+      }
+    }
+    const loreComponent = componentMap.get('lore')
+    if (loreComponent) {
+      customText ??= item.displayName ?? item.name
+      // todo test
+      customText += `\n${JSON.stringify(loreComponent.data)}`
+    }
+  }
+  if (item.nbt) {
+    const itemNbt: PossibleItemProps = nbt.simplify(item.nbt)
+    const customName = itemNbt.display?.Name
+    if (customName) {
+      customText = customName
+    }
+    if (customModelDataDefinitions && itemNbt.CustomModelData && customModelDataDefinitions[itemNbt.CustomModelData]) {
+      customModel = customModelDataDefinitions[itemNbt.CustomModelData]
+    }
+  }
+
+  return {
+    customText,
+    customModel
+  }
+}
+
+
+export const getItemNameRaw = (item: Pick<import('prismarine-item').Item, 'nbt'> | null, resourcesManager: ResourcesManagerCommon) => {
+  if (!item) return ''
+  const { customText } = getItemMetadata(item as GeneralInputItem, resourcesManager)
+  if (!customText) return
+  try {
+    if (typeof customText === 'object') {
+      return customText
+    }
+    const parsed = customText.startsWith('{') && customText.endsWith('}') ? mojangson.simplify(mojangson.parse(customText)) : fromFormattedString(customText)
+    if (parsed.extra) {
+      return parsed as Record<string, any>
+    } else {
+      return parsed as any
+    }
+  } catch (err) {
+    return {
+      text: JSON.stringify(customText)
+    }
+  }
+}
+
+export const getItemModelName = (item: GeneralInputItem, specificProps: ItemSpecificContextProperties, resourcesManager: ResourcesManagerCommon, playerState: PlayerStateRenderer) => {
+  let itemModelName = item.name
+  const { customModel } = getItemMetadata(item, resourcesManager)
+  if (customModel) {
+    itemModelName = customModel
+  }
+
+  const itemSelector = getItemSelector(playerState, {
+    ...specificProps
+  })
+  const modelFromDef = getItemDefinition(resourcesManager.currentResources!.itemsDefinitionsStore, {
+    name: itemModelName,
+    version: resourcesManager.currentResources!.version,
+    properties: itemSelector
+  })?.model
+  const model = (modelFromDef === 'minecraft:special' ? undefined : modelFromDef) ?? itemModelName
+  return model
+}

package/src/lib/mesherlogReader.ts

@@ -0,0 +1,131 @@
+/* eslint-disable no-await-in-loop */
+import { Vec3 } from 'vec3'
+
+// import log from '../../../../../Downloads/mesher (2).log'
+import { WorldRendererCommon } from './worldrendererCommon'
+const log = ''
+
+
+export class MesherLogReader {
+  chunksToReceive: Array<{
+    x: number
+    z: number
+    chunkLength: number
+  }> = []
+  messagesQueue: Array<{
+    fromWorker: boolean
+    workerIndex: number
+    message: any
+  }> = []
+
+  sectionFinishedToReceive = null as {
+    messagesLeft: string[]
+    resolve: () => void
+  } | null
+  replayStarted = false
+
+  constructor (private readonly worldRenderer: WorldRendererCommon) {
+    this.parseMesherLog()
+  }
+
+  chunkReceived (x: number, z: number, chunkLength: number) {
+    // remove existing chunks with same x and z
+    const existingChunkIndex = this.chunksToReceive.findIndex(chunk => chunk.x === x && chunk.z === z)
+    if (existingChunkIndex === -1) {
+      // console.error('Chunk not found', x, z)
+    } else {
+      // warn if chunkLength is different
+      if (this.chunksToReceive[existingChunkIndex].chunkLength !== chunkLength) {
+        // console.warn('Chunk length mismatch', x, z, this.chunksToReceive[existingChunkIndex].chunkLength, chunkLength)
+      }
+      // remove chunk
+      this.chunksToReceive = this.chunksToReceive.filter((chunk, index) => chunk.x !== x || chunk.z !== z)
+    }
+    this.maybeStartReplay()
+  }
+
+  async maybeStartReplay () {
+    if (this.chunksToReceive.length !== 0 || this.replayStarted) return
+    const lines = log.split('\n')
+    console.log('starting replay')
+    this.replayStarted = true
+    const waitForWorkersMessages = async () => {
+      if (!this.sectionFinishedToReceive) return
+      await new Promise<void>(resolve => {
+        this.sectionFinishedToReceive!.resolve = resolve
+      })
+    }
+
+    for (const line of lines) {
+      if (line.includes('dispatchMessages dirty')) {
+        await waitForWorkersMessages()
+        this.worldRenderer.stopMesherMessagesProcessing = true
+        const message = JSON.parse(line.slice(line.indexOf('{'), line.lastIndexOf('}') + 1))
+        if (!message.value) continue
+        const index = line.split(' ')[1]
+        const type = line.split(' ')[3]
+        // console.log('sending message', message.x, message.y, message.z)
+        this.worldRenderer.forceCallFromMesherReplayer = true
+        this.worldRenderer.setSectionDirty(new Vec3(message.x, message.y, message.z), message.value)
+        this.worldRenderer.forceCallFromMesherReplayer = false
+      }
+      if (line.includes('-> blockUpdate')) {
+        await waitForWorkersMessages()
+        this.worldRenderer.stopMesherMessagesProcessing = true
+        const message = JSON.parse(line.slice(line.indexOf('{'), line.lastIndexOf('}') + 1))
+        this.worldRenderer.forceCallFromMesherReplayer = true
+        this.worldRenderer.setBlockStateIdInner(new Vec3(message.pos.x, message.pos.y, message.pos.z), message.stateId)
+        this.worldRenderer.forceCallFromMesherReplayer = false
+      }
+
+      if (line.includes(' sectionFinished ')) {
+        if (!this.sectionFinishedToReceive) {
+          console.log('starting worker message processing validating')
+          this.worldRenderer.stopMesherMessagesProcessing = false
+          this.sectionFinishedToReceive = {
+            messagesLeft: [],
+            resolve: () => {
+              this.sectionFinishedToReceive = null
+            }
+          }
+        }
+        const parts = line.split(' ')
+        const coordsPart = parts.find(part => part.split(',').length === 3)
+        if (!coordsPart) throw new Error(`no coords part found ${line}`)
+        const [x, y, z] = coordsPart.split(',').map(Number)
+        this.sectionFinishedToReceive.messagesLeft.push(`${x},${y},${z}`)
+      }
+    }
+  }
+
+  workerMessageReceived (type: string, message: any) {
+    if (type === 'sectionFinished') {
+      const { key } = message
+      if (!this.sectionFinishedToReceive) {
+        console.warn(`received sectionFinished message but no sectionFinishedToReceive ${key}`)
+        return
+      }
+
+      const idx = this.sectionFinishedToReceive.messagesLeft.indexOf(key)
+      if (idx === -1) {
+        console.warn(`received sectionFinished message for non-outstanding section ${key}`)
+        return
+      }
+      this.sectionFinishedToReceive.messagesLeft.splice(idx, 1)
+      if (this.sectionFinishedToReceive.messagesLeft.length === 0) {
+        this.sectionFinishedToReceive.resolve()
+      }
+    }
+  }
+
+  parseMesherLog () {
+    const lines = log.split('\n')
+    for (const line of lines) {
+      if (line.startsWith('-> chunk')) {
+        const chunk = JSON.parse(line.slice('-> chunk'.length))
+        this.chunksToReceive.push(chunk)
+        continue
+      }
+    }
+  }
+}