minecraft-renderer 0.1.92 → 0.1.94

package/src/three/entity/vehiclePassengerUpdate.ts

@@ -0,0 +1,82 @@
+//@ts-nocheck
+import { isBoatEntityName } from './boatModelRotation'
+import {
+  getBoatPassengerWorldPosition,
+  getHorsePassengerWorldPosition,
+  getMinecartPassengerWorldPosition,
+  isRideableHorseEntityName,
+  isRideableMinecartEntityName,
+  type EntityRenderHints,
+  type Vec3Like
+} from './interpolationPolicy'
+import {
+  anchorVehiclePassengerPosition,
+  isFiniteVec3,
+  releaseVehiclePassengerPosition,
+  shouldSkipLocalPassengerAnchoring,
+  type VehiclePassengerRenderState
+} from './vehiclePassengerRendering'
+
+export type VehiclePassengerSceneEntity = VehiclePassengerRenderState & {
+  playerObject?: unknown
+  originalEntity: { id: number }
+}
+
+export type VehiclePassengerVehicle = {
+  originalEntity: { id: number | string; name: string; height?: number }
+  userData: { renderHints?: EntityRenderHints }
+  rotation: { y: number }
+  realName?: string
+}
+
+export function updateVehiclePassengerPositions(args: {
+  entities: Record<string, VehiclePassengerSceneEntity | VehiclePassengerVehicle>
+  localPlayer: VehiclePassengerSceneEntity | null
+  getWorldPosition: (target: unknown) => Vec3Like | undefined
+}): Set<VehiclePassengerSceneEntity> {
+  const attachedPassengers = new Set<VehiclePassengerSceneEntity>()
+
+  for (const entity of Object.values(args.entities)) {
+    const vehicle = entity as VehiclePassengerVehicle
+    const renderHints = vehicle.userData.renderHints
+    const passengerIds = renderHints?.passengerIds ?? renderHints?.boatPassengerIds
+    if (!Array.isArray(passengerIds) || passengerIds.length === 0) continue
+
+    const vehicleName = vehicle.realName ?? vehicle.originalEntity.name
+    const layout = renderHints?.passengerLayout ?? (isBoatEntityName(vehicleName) ? 'boat' : undefined)
+    if (layout !== 'boat' && layout !== 'minecart' && layout !== 'horse') continue
+    if (layout === 'boat' && !isBoatEntityName(vehicleName)) continue
+    if (layout === 'minecart' && !isRideableMinecartEntityName(vehicleName)) continue
+    if (layout === 'horse' && !isRideableHorseEntityName(vehicleName)) continue
+
+    const vehicleWorldPos = args.getWorldPosition(vehicle)
+    if (!isFiniteVec3(vehicleWorldPos)) continue
+    const vehicleId = String(vehicle.originalEntity.id)
+
+    for (const [passengerIndex, passengerId] of passengerIds.entries()) {
+      const isLocalPassenger = passengerId === args.localPlayer?.originalEntity.id
+      const passenger = isLocalPassenger ? args.localPlayer : (args.entities[passengerId] as VehiclePassengerSceneEntity | undefined)
+      if (!passenger?.playerObject) continue
+      if (passenger === args.localPlayer && shouldSkipLocalPassengerAnchoring(layout)) continue
+
+      const passengerWorldPos =
+        layout === 'minecart'
+          ? getMinecartPassengerWorldPosition(vehicleWorldPos)
+          : layout === 'horse'
+            ? getHorsePassengerWorldPosition(vehicleWorldPos, vehicleName, vehicle.originalEntity.height ?? 1.6)
+            : getBoatPassengerWorldPosition(vehicleWorldPos, vehicle.rotation.y, passengerIndex, passengerIds.length)
+
+      if (!isFiniteVec3(passengerWorldPos)) continue
+      anchorVehiclePassengerPosition(passenger, passengerWorldPos, vehicleId)
+      attachedPassengers.add(passenger)
+    }
+  }
+
+  for (const passenger of [...Object.values(args.entities), ...(args.localPlayer ? [args.localPlayer] : [])] as VehiclePassengerSceneEntity[]) {
+    const vehicleId = passenger.userData._passengerVehicleId ?? (passenger.userData._boatPassengerVehicleId as string | undefined)
+    if (vehicleId === undefined || attachedPassengers.has(passenger)) continue
+    releaseVehiclePassengerPosition(passenger, vehicleId, args.getWorldPosition(passenger))
+  }
+
+  return attachedPassengers
+}

package/src/three/graphicsBackendBase.ts

@@ -8,7 +8,7 @@
 
 import * as THREE from 'three'
 import { Vec3 } from 'vec3'
-import type { GraphicsBackend, GraphicsInitOptions, DisplayWorldOptions } from '../graphicsBackend'
+import type { GraphicsBackend, GraphicsInitOptions, DisplayWorldOptions, UpdateCameraOptions } from '../graphicsBackend'
 import { createWorkerProxy, restoreTransferred } from '../lib/workerProxy'
 import { ResourcesManager } from '../resourcesManager'
 import { FrameTimingCollector } from '../lib/frameTimingCollector'
@@ -280,10 +280,10 @@ export const createGraphicsBackendBase = () => {
         }
       }
     }),
-    updateCamera(pos: Vec3 | null, yaw: number, pitch: number) {
+    updateCamera(pos: Vec3 | null, yaw: number, pitch: number, options?: UpdateCameraOptions) {
       // Mark camera update event for frame timing visualization
       frameTimingCollector?.markCameraUpdate(!pos)
-      worldRenderer?.setFirstPersonCamera(pos, yaw, pitch)
+      worldRenderer?.setFirstPersonCamera(pos, yaw, pitch, options)
     },
     get soundSystem() {
       return worldRenderer?.soundSystem
@@ -311,10 +311,10 @@ export const createGraphicsBackendBase = () => {
         startWorld,
         disconnect,
         setRendering: backend.setRendering,
-        updateCamera(pos, yaw, pitch) {
+        updateCamera(pos, yaw, pitch, options?: UpdateCameraOptions) {
           const posVec = pos ? new Vec3(pos.x, pos.y, pos.z) : null
           frameTimingCollector?.markCameraUpdate(!posVec)
-          backend.updateCamera(posVec, yaw, pitch)
+          backend.updateCamera(posVec, yaw, pitch, options)
         },
         async callBackendMethod<K extends keyof ThreeJsBackendMethods>(
           method: K,

package/src/three/graphicsBackendOffThread.ts

@@ -154,8 +154,8 @@ export const createGraphicsBackendOffThread: GraphicsBackendLoader = async initO
     setRendering(rendering) {
       proxy.setRendering(rendering)
     },
-    updateCamera(pos, yaw, pitch) {
-      proxy.updateCamera(pos ? { x: pos.x, y: pos.y, z: pos.z } : null, yaw, pitch)
+    updateCamera(pos, yaw, pitch, options) {
+      proxy.updateCamera(pos ? { x: pos.x, y: pos.y, z: pos.z } : null, yaw, pitch, options)
     },
     soundSystem: undefined,
     backendMethods: backendMethodsProxy

package/src/three/worldRendererThree.ts

@@ -16,11 +16,18 @@ import { getMyHand } from './hand'
 import { createHoldingBlock } from './holdingBlockFactory'
 import type { IHoldingBlock } from './holdingBlockTypes'
 import { getMesh } from './entity/EntityMesh'
+import { resolveEntityHeadPose } from './entity/entityHeadPose'
 import { armorModel } from './entity/armorModels'
 import { disposeObject, loadThreeJsTextureFromBitmap } from './threeJsUtils'
 import { CursorBlock } from './world/cursorBlock'
 import { getItemUv } from './appShared'
 import { Entities } from './entities'
+import {
+  getCameraMovementTweenDurationMs,
+  shouldRestartCameraPositionTween,
+  type CameraMovementMode,
+  type UpdateCameraOptions
+} from './entity/interpolationPolicy'
 import { ThreeJsSound } from './threeJsSound'
 import { CameraShake } from './cameraShake'
 import { ThreeJsMedia } from './threeJsMedia'
@@ -160,6 +167,8 @@ export class WorldRendererThree extends WorldRendererCommon {
 
   private currentPosTween?: tweenJs.Tween<{ x: number; y: number; z: number }>
   private currentRotTween?: tweenJs.Tween<{ pitch: number; yaw: number }>
+  private currentCameraTarget: { x: number; y: number; z: number } | null = null
+  private currentCameraMovementMode: CameraMovementMode | null = null
 
   // Pre-allocated objects for getThirdPersonCamera (avoid per-frame allocs)
   private readonly _tpDirection = new THREE.Vector3()
@@ -492,17 +501,18 @@ export class WorldRendererThree extends WorldRendererCommon {
   }
 
   updateEntity(e, isPosUpdate = false) {
+    const headPose = resolveEntityHeadPose(e)
     const overrides = {
       rotation: {
         head: {
-          x: e.headPitch ?? e.pitch,
-          y: e.headYaw,
+          x: headPose.pitch,
+          y: headPose.headYaw,
           z: 0
         }
       }
     }
     if (isPosUpdate) {
-      this.entities.updateEntityPosition(e, false, overrides)
+      this.entities.updateEntityPosition(e, false, overrides, e.headRotationOnly === true)
     } else {
       this.entities.update(e, overrides)
     }
@@ -584,6 +594,9 @@ export class WorldRendererThree extends WorldRendererCommon {
     this.onReactiveConfigUpdated('futuristicReveal', () => {
       this.updateModulesFromConfig()
     })
+    this.onReactiveDebugUpdated('disableEntities', () => {
+      this.entities.syncSceneAttachment()
+    })
 
     let currentHandRenderer = this.displayOptions.inWorldRenderingConfig.handRenderer
     this.onReactiveConfigUpdated('handRenderer', value => {
@@ -990,10 +1003,10 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
   }
 
-  setFirstPersonCamera(pos: Vec3 | null, yaw: number, pitch: number) {
+  setFirstPersonCamera(pos: Vec3 | null, yaw: number, pitch: number, options?: UpdateCameraOptions) {
     const yOffset = this.playerStateReactive.eyeHeight
 
-    this.updateCamera(pos?.offset(0, yOffset, 0) ?? null, yaw, pitch)
+    this.updateCamera(pos?.offset(0, yOffset, 0) ?? null, yaw, pitch, options)
     // this.media.tryIntersectMedia()
     this.updateCameraSectionPos()
   }
@@ -1149,34 +1162,50 @@ export class WorldRendererThree extends WorldRendererCommon {
     }
   }
 
-  updateCamera(pos: Vec3 | null, yaw: number, pitch: number): void {
+  updateCamera(pos: Vec3 | null, yaw: number, pitch: number, options?: UpdateCameraOptions): void {
     // Skip position/rotation updates if cinematic script is running
     if (this.cinimaticScript.running) {
       return
     }
 
-    // if (this.freeFlyMode) {
-    //   pos = this.freeFlyState.position
-    //   pitch = this.freeFlyState.pitch
-    //   yaw = this.freeFlyState.yaw
-    // }
-
     if (pos) {
       if (this.renderer.xr.isPresenting) {
         pos.y -= this.camera.position.y // Fix Y position of camera in world
       }
 
-      this.currentPosTween?.stop()
-      // Use instant camera updates (0 delay) in playground mode when camera controls are enabled
-      const tweenDelay = this.displayOptions.inWorldRenderingConfig.instantCameraUpdate ? 0 : this.playerStateUtils.isSpectatingEntity() ? 150 : 50
-      this.currentPosTween = new tweenJs.Tween(this.cameraWorldPos)
-        .to({ x: pos.x, y: pos.y, z: pos.z }, tweenDelay)
-        .onUpdate(() => {
-          this.sceneOrigin.update(this.cameraWorldPos.x, this.cameraWorldPos.y, this.cameraWorldPos.z)
+      const movementMode: CameraMovementMode = this.playerStateUtils.isSpectatingEntity() ? 'spectating' : (options?.movementMode ?? 'local-player')
+      const instant = options?.instant === true || this.displayOptions.inWorldRenderingConfig.instantCameraUpdate === true
+      const target = { x: pos.x, y: pos.y, z: pos.z }
+      const restartTween = shouldRestartCameraPositionTween({
+        target,
+        currentTarget: this.currentCameraTarget,
+        movementMode,
+        previousMovementMode: this.currentCameraMovementMode,
+        instant
+      })
+      const tweenDelay = getCameraMovementTweenDurationMs(movementMode, instant)
+
+      if (restartTween) {
+        this.currentCameraTarget = { ...target }
+        this.currentCameraMovementMode = movementMode
+        this.currentPosTween?.stop()
+        if (instant || tweenDelay === 0) {
+          this.cameraWorldPos.x = target.x
+          this.cameraWorldPos.y = target.y
+          this.cameraWorldPos.z = target.z
+          this.sceneOrigin.update(target.x, target.y, target.z)
           this.cameraObject.position.set(0, 0, 0)
-        })
-        .start()
-      // this.freeFlyState.position = pos
+          this.currentPosTween = undefined
+        } else {
+          this.currentPosTween = new tweenJs.Tween(this.cameraWorldPos)
+            .to(target, tweenDelay)
+            .onUpdate(() => {
+              this.sceneOrigin.update(this.cameraWorldPos.x, this.cameraWorldPos.y, this.cameraWorldPos.z)
+              this.cameraObject.position.set(0, 0, 0)
+            })
+            .start()
+        }
+      }
     }
 
     if (this.playerStateUtils.isSpectatingEntity()) {
@@ -1363,11 +1392,9 @@ export class WorldRendererThree extends WorldRendererCommon {
       this.chunkMeshManager.clearCullDirty()
     }
     this.chunkMeshManager.updateCaveCullingDebug(this.reactiveDebugParams.caveCullingDebug, smartCull)
-    if (!this.reactiveDebugParams.disableEntities) {
-      const entitiesStart = performance.now()
-      this.entities.render()
-      entitiesRenderMs = performance.now() - entitiesStart
-    }
+    const entitiesStart = performance.now()
+    this.entities.render()
+    entitiesRenderMs = performance.now() - entitiesStart
     this.chunkMeshManager.sortVisibleBlendSections(camX, camY, camZ)
     if (!didBlendAllAttrUpload && globalLegacyBlendBuffer?.hasPendingIndexUploads()) {
       globalLegacyBlendBuffer.uploadDirtyIndexRange()