minecraft-renderer 0.1.103 → 0.1.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-renderer",
-  "version": "0.1.103",
+  "version": "0.1.104",
   "description": "The most Modular Minecraft world renderer with Three.js WebGL backend",
   "type": "module",
   "main": "./dist/index.js",

package/src/lib/mesherMcDataSupply.ts

@@ -0,0 +1,41 @@
+//@ts-nocheck
+import MinecraftData, { IndexedData } from 'minecraft-data'
+import pcFeatures from 'minecraft-data/minecraft-data/data/pc/common/features.json'
+
+/**
+ * Version tables the mesher workers need to behave like `minecraft-data`.
+ * The worker bundles don't contain any (see src/mesher-shared/mcDataWorkerShim.cjs), they are supplied with the `mcData` message
+ * so the workers support every version the main thread's `minecraft-data` supports.
+ */
+export type MesherVersionTables = {
+  /** pc protocolVersions, newest first (same order as minecraft-data); only the fields needed for comparisons */
+  protocolVersions: Array<{ minecraftVersion: string; majorVersion: string; dataVersion?: number; version?: number }>
+  /** `supportFeature(name)` resolved for the current version */
+  features: Record<string, unknown>
+}
+
+let protocolVersionsCache: MesherVersionTables['protocolVersions'] | undefined
+const featuresCache = new WeakMap<object, MesherVersionTables['features']>()
+
+export const getMesherVersionTables = (mcDataFull: IndexedData): MesherVersionTables => {
+  protocolVersionsCache ??= MinecraftData.versions.pc.map(({ minecraftVersion, majorVersion, dataVersion, version }: any) => ({
+    minecraftVersion,
+    majorVersion,
+    dataVersion,
+    version
+  }))
+
+  let features = featuresCache.get(mcDataFull)
+  if (!features) {
+    features = {}
+    // bedrock features are not used by the mesher
+    if (mcDataFull.type === 'pc') {
+      for (const { name } of pcFeatures as Array<{ name: string }>) {
+        features[name] = mcDataFull.supportFeature(name as any)
+      }
+    }
+    featuresCache.set(mcDataFull, features)
+  }
+
+  return { protocolVersions: protocolVersionsCache, features }
+}

package/src/lib/worldrendererCommon.ts

@@ -8,6 +8,7 @@ import { subscribeKey } from 'valtio/utils'
 import { proxy, subscribe } from 'valtio'
 import type { ResourcesManagerTransferred } from '../resourcesManager/resourcesManager'
 import { dynamicMcDataFiles } from './buildSharedConfig.mjs'
+import { getMesherVersionTables } from './mesherMcDataSupply'
 import { DisplayWorldOptions, GraphicsInitOptions, RendererReactiveState, SoundSystem, UpdateCameraOptions } from '../graphicsBackend/types'
 import {
   HighestBlockInfo,
@@ -1587,7 +1588,8 @@ let mesherMcDataTintsMissingWarned = false
 
 export const meshersSendMcData = (workers: Worker[], version: string, mcDataKeys = dynamicMcDataFiles, mcDataFull: IndexedData) => {
   const mcData: { version: IndexedData['version']; tints?: unknown; [key: string]: unknown } = {
-    version: JSON.parse(JSON.stringify(mcDataFull.version))
+    version: JSON.parse(JSON.stringify(mcDataFull.version)),
+    ...getMesherVersionTables(mcDataFull)
   }
   for (const [finalKey, sourceKey] of Object.entries(mcDataKeys)) {
     mcData[finalKey] = mcDataFull[sourceKey]

package/src/mesher-shared/mcDataWorkerShim.cjs

@@ -0,0 +1,74 @@
+// Version-agnostic replacement for `minecraft-data` inside the mesher worker bundles (see scripts/buildWorkerShared.mjs).
+//
+// The real package would bake its version tables (data.js, protocolVersions.json, features.json) into the bundle at build
+// time, so a worker could only ever load versions that the renderer's devDependency knew about. Nothing version-specific is
+// bundled here: everything is read lazily from `globalThis.mcData`, which the main thread supplies with the `mcData`
+// message (see `meshersSendMcData`):
+//   - `version`          IndexedData['version'] of the current version
+//   - `protocolVersions` pc protocolVersions list (used for version comparisons)
+//   - `features`         `supportFeature(name)` already resolved for the current version
+//   - everything else    data files (blocks, biomes, blockCollisionShapes, tints, ...)
+const mcDataToNode = require('minecraft-data/lib/loader')
+const indexer = require('minecraft-data/lib/indexer.js')
+
+function createVersion (type, suppliedVersion, protocolVersions) {
+  const versions = indexer.buildIndexFromArray(protocolVersions, 'minecraftVersion') ?? {}
+  // Allows comparisons against majorVersion even if `other` is not present in the versions list (e.g. 1.17.0 exists but not 1.17)
+  for (const key in versions) {
+    const versionObj = versions[key]
+    if (versionObj.minecraftVersion.endsWith('.0')) versions[versionObj.majorVersion] = versionObj
+  }
+
+  const self = {}
+  // the supplied dataVersion is authoritative: the current version doesn't have to be present in the supplied list
+  self.dataVersion = suppliedVersion.dataVersion ?? versions[suppliedVersion.minecraftVersion]?.dataVersion
+  const v1 = self.dataVersion ?? 0
+  const raise = other => { throw new RangeError(`Version '${other}' not found in protocolVersions supplied by the main thread for ${type}`) }
+  self['>='] = other => versions[other] ? v1 >= versions[other].dataVersion : raise(other)
+  self['>'] = other => versions[other] ? v1 > versions[other].dataVersion : raise(other)
+  self['<'] = other => versions[other] ? v1 < versions[other].dataVersion : raise(other)
+  self['<='] = other => versions[other] ? v1 <= versions[other].dataVersion : raise(other)
+  self['=='] = other => versions[other] ? v1 === versions[other].dataVersion : raise(other)
+  self.type = type
+  self.majorVersion = suppliedVersion.majorVersion
+  return self
+}
+
+let cache = null
+
+module.exports = function (mcVersion) {
+  const supplied = globalThis.mcData
+  const suppliedVersion = supplied?.version
+  if (!suppliedVersion) return null // not supplied (yet)
+
+  const requested = String(mcVersion)
+  // a worker only ever works with the single version it was supplied data for
+  if (requested !== suppliedVersion.minecraftVersion && requested !== suppliedVersion.majorVersion && requested !== String(suppliedVersion.version)) return null
+
+  if (cache?.src === supplied) return cache.value
+
+  const type = suppliedVersion.type ?? 'pc'
+  const protocolVersions = supplied.protocolVersions ?? []
+  protocolVersions.forEach((entry, i) => {
+    // same as minecraft-data: bottom entries are lower
+    if (!entry.dataVersion) entry.dataVersion = -i
+  })
+
+  const { version: _version, protocolVersions: _protocolVersions, features: _features, ...files } = supplied
+  const nmcData = mcDataToNode({ ...files, version: suppliedVersion })
+  nmcData.type = type
+  nmcData.isNewerOrEqualTo = version => nmcData.version['>='](version)
+  nmcData.isOlderThan = version => nmcData.version['<'](version)
+  nmcData.version = Object.assign(createVersion(type, suppliedVersion, protocolVersions), nmcData.version)
+  const features = supplied.features ?? {}
+  nmcData.supportFeature = featureName => features[featureName] || false
+
+  cache = { src: supplied, value: nmcData }
+  return nmcData
+}
+
+// Used eagerly by prismarine-block (preflat id mapping), static and version independent
+module.exports.legacy = {
+  pc: require('minecraft-data/minecraft-data/data/pc/common/legacy.json'),
+  bedrock: {}
+}

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

@@ -0,0 +1,87 @@
+//@ts-nocheck
+import { createRequire } from 'module'
+import { afterEach, describe, expect, it } from 'vitest'
+import MinecraftData from 'minecraft-data'
+import { getMesherVersionTables } from '../lib/mesherMcDataSupply'
+
+const require = createRequire(import.meta.url)
+const loadShim = () => {
+  delete require.cache[require.resolve('./mcDataWorkerShim.cjs')]
+  return require('./mcDataWorkerShim.cjs') as (version: string) => any
+}
+
+/** What `meshersSendMcData` sends to the workers */
+const supplyFor = (version: string) => {
+  const full = MinecraftData(version)
+  return {
+    full,
+    mcData: {
+      version: JSON.parse(JSON.stringify(full.version)),
+      ...getMesherVersionTables(full),
+      blocks: full.blocksArray,
+      biomes: full.biomesArray,
+      blockCollisionShapes: full.blockCollisionShapes
+    }
+  }
+}
+
+describe('mesher worker minecraft-data shim', () => {
+  afterEach(() => {
+    delete (globalThis as any).mcData
+  })
+
+  it('returns null until data is supplied', () => {
+    expect(loadShim()('1.20.4')).toBeNull()
+  })
+
+  it.each(['1.8.8', '1.16.5', '1.20.4', '1.21.8'])('behaves like minecraft-data for %s', version => {
+    const { full, mcData } = supplyFor(version)
+    ;(globalThis as any).mcData = mcData
+    const shimmed = loadShim()(version)
+
+    expect(shimmed.version.minecraftVersion).toBe(version)
+    expect(shimmed.type).toBe('pc')
+    expect(shimmed.blocksByName.stone.id).toBe(full.blocksByName.stone.id)
+    expect(shimmed.blocksByStateId[full.blocksByName.stone.defaultState].name).toBe('stone')
+    expect(shimmed.biomes[full.biomesArray[0].id].name).toBe(full.biomesArray[0].name)
+    for (const feature of ['blockStateId', 'theFlattening', 'usesBlockStates', 'itemsAreNotBlocks', 'sendsClientTickEndPacket']) {
+      expect(shimmed.supportFeature(feature)).toBe(full.supportFeature(feature as any))
+    }
+    for (const other of ['1.8', '1.12.2', '1.16.5', '1.21.1']) {
+      expect(shimmed.isNewerOrEqualTo(other)).toBe(full.isNewerOrEqualTo(other))
+      expect(shimmed.isOlderThan(other)).toBe(full.isOlderThan(other))
+    }
+    expect(shimmed.supportFeature('unknownFeature')).toBe(false)
+  })
+
+  it('works with a version that is not in anything bundled with the worker', () => {
+    const { mcData } = supplyFor('1.21.8')
+    const newest = mcData.protocolVersions[0]
+    // a version from the future: only the main thread knows it
+    const future = { ...mcData.version, minecraftVersion: '99.9', majorVersion: '99', dataVersion: newest.dataVersion + 1000, version: 9999 }
+    ;(globalThis as any).mcData = {
+      ...mcData,
+      version: future,
+      protocolVersions: [{ ...future }, ...mcData.protocolVersions],
+      features: { ...mcData.features, someFutureFeature: true }
+    }
+    const shimmed = loadShim()('99.9')
+
+    expect(shimmed).not.toBeNull()
+    expect(shimmed.version.minecraftVersion).toBe('99.9')
+    expect(shimmed.isNewerOrEqualTo('1.21.8')).toBe(true)
+    expect(shimmed.isOlderThan('1.21.8')).toBe(false)
+    expect(shimmed.supportFeature('someFutureFeature')).toBe(true)
+    // the worker only knows the version it was supplied
+    expect(loadShim()('1.21.8')).toBeNull()
+  })
+
+  it('picks up newly supplied data (worker reconfigure)', () => {
+    ;(globalThis as any).mcData = supplyFor('1.16.5').mcData
+    const shim = loadShim()
+    expect(shim('1.16.5').version.minecraftVersion).toBe('1.16.5')
+    ;(globalThis as any).mcData = supplyFor('1.20.4').mcData
+    expect(shim('1.20.4').version.minecraftVersion).toBe('1.20.4')
+    expect(shim('1.16.5')).toBeNull()
+  })
+})