minecraft-renderer 0.1.0

package/src/modules/types.ts

@@ -0,0 +1,110 @@
+/**
+ * Renderer Module System Types
+ *
+ * Modules are self-contained renderer extensions that can be enabled/disabled
+ * and configured through a standardized interface.
+ */
+
+import * as THREE from 'three'
+
+/**
+ * Setting value types supported by modules.
+ */
+export type SettingValue = boolean | number | string | number[]
+
+/**
+ * Setting definition for a module.
+ */
+export interface ModuleSetting<T extends SettingValue = SettingValue> {
+  /** Default value for the setting */
+  default: T
+  /** Human-readable label for UI */
+  label?: string
+  /** Description of the setting */
+  description?: string
+  /** Minimum value (for number settings) */
+  min?: number
+  /** Maximum value (for number settings) */
+  max?: number
+  /** Step value (for number settings) */
+  step?: number
+  /** Available options (for string settings) */
+  options?: string[]
+}
+
+/**
+ * Module settings schema.
+ */
+export type ModuleSettingsSchema = Record<string, ModuleSetting>
+
+/**
+ * Infer settings object type from schema.
+ */
+export type InferSettings<T extends ModuleSettingsSchema> = {
+  [K in keyof T]: T[K]['default']
+}
+
+/**
+ * Module manifest - describes a renderer module's identity and configuration.
+ */
+export interface ModuleManifest<TSettings extends ModuleSettingsSchema = ModuleSettingsSchema> {
+  /** Unique identifier for the module */
+  id: string
+  /** Human-readable name */
+  name: string
+  /** Brief description */
+  description?: string
+  /** Module version */
+  version?: string
+  /** Settings schema for this module */
+  settings: TSettings
+}
+
+/**
+ * Module context provided to modules during initialization.
+ */
+export interface ModuleContext {
+  /** The Three.js scene */
+  scene: THREE.Scene
+  /** Get the current camera position */
+  getCameraPosition: () => THREE.Vector3
+  /** Register a callback to be called each frame */
+  onRender: (callback: () => void) => void
+  /** Unregister a render callback */
+  offRender: (callback: () => void) => void
+}
+
+/**
+ * Base interface for renderer modules.
+ */
+export interface RendererModule<TSettings extends ModuleSettingsSchema = ModuleSettingsSchema> {
+  /** Module manifest */
+  readonly manifest: ModuleManifest<TSettings>
+
+  /** Current settings values */
+  readonly settings: InferSettings<TSettings>
+
+  /** Whether the module is currently enabled */
+  enabled: boolean
+
+  /** Initialize the module with context */
+  init(context: ModuleContext): void
+
+  /** Update a setting value */
+  setSetting<K extends keyof TSettings>(key: K, value: TSettings[K]['default']): void
+
+  /** Called when module is enabled */
+  onEnable?(): void
+
+  /** Called when module is disabled */
+  onDisable?(): void
+
+  /** Cleanup and dispose resources */
+  dispose(): void
+}
+
+/**
+ * Module factory function type.
+ */
+export type ModuleFactory<TSettings extends ModuleSettingsSchema = ModuleSettingsSchema> =
+  () => RendererModule<TSettings>

package/src/playerState/playerState.ts

@@ -0,0 +1,78 @@
+import { proxy } from 'valtio'
+import type { GameMode, HandItemBlock, BlocksShapes, BlockShape, MovementState, CameraPerspective, Team, ItemSpecificContextProperties } from './types'
+
+// edit src/mineflayer/playerState.ts for implementation of player state from mineflayer
+export const getInitialPlayerState = () => proxy({
+  playerSkin: undefined as string | undefined,
+  inWater: false,
+  waterBreathing: false,
+  backgroundColor: [0, 0, 0] as [number, number, number],
+  ambientLight: 0,
+  directionalLight: 0,
+  eyeHeight: 0,
+  gameMode: undefined as GameMode | undefined,
+  lookingAtBlock: undefined as {
+    x: number
+    y: number
+    z: number
+    face?: number
+    shapes: BlocksShapes
+  } | undefined,
+  diggingBlock: undefined as {
+    x: number
+    y: number
+    z: number
+    stage: number
+    face?: number
+    mergedShape: BlockShape | undefined
+  } | undefined,
+  movementState: 'NOT_MOVING' as MovementState,
+  onGround: true,
+  sneaking: false,
+  flying: false,
+  sprinting: false,
+  itemUsageTicks: 0,
+  username: '',
+  onlineMode: false,
+  lightingDisabled: false,
+  shouldHideHand: false,
+  heldItemMain: undefined as HandItemBlock | undefined,
+  heldItemOff: undefined as HandItemBlock | undefined,
+  perspective: 'first_person' as CameraPerspective,
+  onFire: false,
+
+  cameraSpectatingEntity: undefined as number | undefined,
+
+  team: undefined as Team | undefined,
+})
+
+export const getPlayerStateUtils = (reactive: PlayerStateReactive) => ({
+  isSpectator() {
+    return reactive.gameMode === 'spectator'
+  },
+  isSpectatingEntity() {
+    return reactive.cameraSpectatingEntity !== undefined && reactive.gameMode === 'spectator'
+  },
+  isThirdPerson() {
+    if ((this as PlayerStateUtils).isSpectatingEntity()) return false
+    return reactive.perspective === 'third_person_back' || reactive.perspective === 'third_person_front'
+  }
+})
+
+export const getInitialPlayerStateRenderer = () => ({
+  reactive: getInitialPlayerState()
+})
+
+export type PlayerStateReactive = ReturnType<typeof getInitialPlayerState>
+export type PlayerStateUtils = ReturnType<typeof getPlayerStateUtils>
+
+export type PlayerStateRenderer = PlayerStateReactive
+
+export const getItemSelector = (playerState: PlayerStateRenderer, specificProperties: ItemSpecificContextProperties, item?: import('prismarine-item').Item) => {
+  return {
+    ...specificProperties,
+    'minecraft:date': new Date(),
+    // "minecraft:context_dimension": bot.entityp,
+    // 'minecraft:time': bot.time.timeOfDay / 24_000,
+  }
+}

package/src/playerState/types.ts

@@ -0,0 +1,36 @@
+import { ItemSelector } from 'mc-assets/dist/itemDefinitions'
+
+export type GameMode = 'survival' | 'creative' | 'adventure' | 'spectator'
+
+export interface Team {
+  team?: any
+  id: string
+  name: string
+  color: string
+  prefix: string
+  suffix: string
+  players: string[]
+}
+
+export interface HandItemBlock {
+  name?: string
+  properties?: Record<string, any>
+  fullItem?: any
+  type: 'block' | 'item' | 'hand'
+  id?: number
+}
+
+export type MovementState = 'NOT_MOVING' | 'WALKING' | 'SPRINTING' | 'SNEAKING'
+export type ItemSpecificContextProperties = Partial<
+  Pick<
+    ItemSelector['properties'],
+    | 'minecraft:using_item'
+    | 'minecraft:use_duration'
+    | 'minecraft:use_cycle'
+    | 'minecraft:display_context'
+  >
+>
+export type CameraPerspective = 'first_person' | 'third_person_back' | 'third_person_front'
+
+export type BlockShape = { position: { x: number, y: number, z: number }; width: number; height: number; depth: number; }
+export type BlocksShapes = BlockShape[]

package/src/playground/allEntitiesDebug.ts

@@ -0,0 +1,170 @@
+import { EntityMesh, rendererSpecialHandled, EntityDebugFlags } from '@/three/entity/EntityMesh'
+
+export const displayEntitiesDebugList = (version: string) => {
+  // Create results container
+  const container = document.createElement('div')
+  container.style.cssText = `
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    max-height: 90vh;
+    overflow-y: auto;
+    background: rgba(0,0,0,0.8);
+    color: white;
+    padding: 20px;
+    border-radius: 8px;
+    font-family: monospace;
+    min-width: 400px;
+    z-index: 1000;
+  `
+  document.body.appendChild(container)
+
+  // Add title
+  const title = document.createElement('h2')
+  title.textContent = 'Minecraft Entity Support'
+  title.style.cssText = 'margin-top: 0; text-align: center;'
+  container.appendChild(title)
+
+  // Test entities
+  const results: Array<{
+    entity: string;
+    supported: boolean;
+    type?: 'obj' | 'bedrock' | 'special';
+    mappedFrom?: string;
+    textureMap?: boolean;
+    errors?: string[];
+  }> = []
+  const { mcData } = window
+  const entityNames = Object.keys(mcData.entitiesArray.reduce((acc, entity) => {
+    acc[entity.name] = true
+    return acc
+  }, {}))
+
+  // Add loading indicator
+  const loading = document.createElement('div')
+  loading.textContent = 'Testing entities...'
+  loading.style.textAlign = 'center'
+  container.appendChild(loading)
+
+  for (const entity of entityNames) {
+    const debugFlags: EntityDebugFlags = {}
+
+    if (rendererSpecialHandled.includes(entity)) {
+      results.push({
+        entity,
+        supported: true,
+        type: 'special',
+      })
+      continue
+    }
+
+    try {
+
+      const { mesh: entityMesh } = new EntityMesh(version, entity, undefined, {}, debugFlags)
+      // find the most distant pos child
+      window.objects ??= {}
+      window.objects[entity] = entityMesh
+
+      results.push({
+        entity,
+        supported: !!debugFlags.type || rendererSpecialHandled.includes(entity),
+        type: debugFlags.type,
+        mappedFrom: debugFlags.tempMap,
+        textureMap: debugFlags.textureMap,
+        errors: debugFlags.errors
+      })
+    } catch (e) {
+      console.error(e)
+      results.push({
+        entity,
+        supported: false,
+        mappedFrom: debugFlags.tempMap
+      })
+    }
+  }
+
+  // Remove loading indicator
+  loading.remove()
+
+  const createSection = (title: string, items: any[], filter: (item: any) => boolean) => {
+    const section = document.createElement('div')
+    section.style.marginBottom = '20px'
+
+    const sectionTitle = document.createElement('h3')
+    sectionTitle.textContent = title
+    sectionTitle.style.textAlign = 'center'
+    section.appendChild(sectionTitle)
+
+    const list = document.createElement('ul')
+    list.style.cssText = 'padding-left: 20px; list-style-type: none; margin: 0;'
+
+    const filteredItems = items.filter(filter)
+    for (const item of filteredItems) {
+      const listItem = document.createElement('li')
+      listItem.style.cssText = 'line-height: 1.4; margin: 8px 0;'
+
+      const entityName = document.createElement('strong')
+      entityName.style.cssText = 'user-select: text;-webkit-user-select: text;'
+      entityName.textContent = item.entity
+      listItem.appendChild(entityName)
+
+      let text = ''
+      if (item.mappedFrom) {
+        text += ` -> ${item.mappedFrom}`
+      }
+      if (item.type) {
+        text += ` - ${item.type}`
+      }
+      if (item.textureMap) {
+        text += ' ⚠️'
+      }
+      if (item.errors) {
+        text += ' ❌'
+      }
+
+      listItem.appendChild(document.createTextNode(text))
+      list.appendChild(listItem)
+    }
+
+    section.appendChild(list)
+    return { section, count: filteredItems.length }
+  }
+
+  // Sort results - bedrock first
+  results.sort((a, b) => {
+    if (a.type === 'bedrock' && b.type !== 'bedrock') return -1
+    if (a.type !== 'bedrock' && b.type === 'bedrock') return 1
+    return a.entity.localeCompare(b.entity)
+  })
+
+  // Add sections
+  const sections = [
+    {
+      title: '❌ Unsupported Entities',
+      filter: (r: any) => !r.supported && !r.mappedFrom
+    },
+    {
+      title: '⚠️ Partially Supported Entities',
+      filter: (r: any) => r.mappedFrom
+    },
+    {
+      title: '✅ Supported Entities',
+      filter: (r: any) => r.supported && !r.mappedFrom
+    }
+  ]
+
+  for (const { title, filter } of sections) {
+    const { section, count } = createSection(title, results, filter)
+    if (count > 0) {
+      container.appendChild(section)
+    }
+  }
+
+  // log object with errors per entity
+  const errors = results.filter(r => r.errors).map(r => ({
+    entity: r.entity,
+    errors: r.errors
+  }))
+  console.log(errors)
+}