448 lines
18 KiB
Python
448 lines
18 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""
|
||
CameraOrbitController
|
||
---------------------
|
||
通用的轨道/平移/缩放 + WASD/QE 漫游控制器，操作习惯贴近 Unity：
|
||
|
||
- Alt + 左键拖动：围绕目标轨道旋转。
|
||
- 中键（滚轮按下）拖动：平移。
|
||
- Alt + 右键拖动或滚轮滚动：缩放/推拉。
|
||
- 右键按住：自由视角旋转；右键按住时 WASD/QE/Space 飞行移动。
|
||
|
||
用法：
|
||
from camera_orbit_controller import CameraOrbitController
|
||
controller = CameraOrbitController(base) # base 为 ShowBase 实例
|
||
"""
|
||
import importlib
|
||
import importlib.util
|
||
|
||
HAS_IMGUI = False
|
||
if importlib.util.find_spec("imgui_bundle"):
|
||
from imgui_bundle import imgui
|
||
HAS_IMGUI = True
|
||
|
||
import math
|
||
from typing import Optional
|
||
|
||
from panda3d.core import LPoint3, Vec3, KeyboardButton, NodePath
|
||
from direct.showbase.ShowBaseGlobal import globalClock
|
||
from direct.showbase.ShowBase import ShowBase
|
||
from panda3d.core import MouseButton,MouseWatcher
|
||
import panda3d.core as p3d
|
||
from direct.task import Task
|
||
|
||
|
||
class CameraOrbitController:
|
||
def __init__(
|
||
self,
|
||
base:ShowBase,
|
||
target: Optional[LPoint3] = None,
|
||
target_model: Optional[NodePath] = None,
|
||
distance: float = 12.0,
|
||
yaw: float = 30.0,
|
||
pitch: float = -20.0,
|
||
move_speed: float = 12.0,
|
||
orbit_sensitivity: float = 0.3,
|
||
orbit_requires_alt: bool = True,
|
||
pan_factor: float = 0.002,
|
||
zoom_factor: float = 0.001,
|
||
block_io = None
|
||
):
|
||
# 传入的 ShowBase 实例（含渲染节点、相机、窗口、任务管理器）
|
||
self.base = base
|
||
# 关闭 Panda3D 默认 TrackballController，避免它同时改动相机姿态导致绕轨时角度怪异
|
||
if hasattr(self.base, "disableMouse"):
|
||
self.base.disableMouse()
|
||
self.render: Optional[ShowBase] = base.render
|
||
self.cam: Optional[NodePath] = getattr(base, "camera", base.cam)
|
||
self.win = base.win
|
||
self.mouseWatcher:MouseWatcher = getattr(base, "mouseWatcherNode", None)
|
||
self.block_io = block_io
|
||
|
||
# 相机围绕的目标点与初始距离/角度
|
||
if target_model and (target_model.children or not target_model.isEmpty):
|
||
bounds = target_model.getTightBounds()
|
||
min_pt, max_pt = bounds
|
||
self.cam_target = (min_pt + max_pt) * 0.5
|
||
extent = (max_pt - min_pt)
|
||
self.distance = extent.length() * distance
|
||
|
||
else:
|
||
self.cam_target = target or LPoint3(0, 0, 0)
|
||
self.distance = distance
|
||
|
||
self.focus_target_node: Optional[NodePath] = target_model
|
||
self.yaw = yaw
|
||
self.pitch = pitch
|
||
|
||
# 运动与灵敏度参数
|
||
self.move_speed = move_speed
|
||
self.orbit_sensitivity = orbit_sensitivity
|
||
self.orbit_requires_alt = orbit_requires_alt
|
||
self.pan_factor = pan_factor
|
||
self.zoom_factor = zoom_factor
|
||
|
||
# 鼠标状态缓存
|
||
self.lmb_down = False # 左键
|
||
self.mmb_down = False # 中键（滚轮）
|
||
self.rmb_down = False # 右键
|
||
self.mods = [] # 修饰键（来自 Qt 事件的 alt/shift/control）
|
||
self.base.accept("alt-lalt", lambda: self._set_mod("alt", True))
|
||
self.base.accept("lalt-up", lambda: self._set_mod("alt", False))
|
||
# self.base.accept("alt-mouse1", self._alt_mouse1)
|
||
# self.base.accept("alt-mouse1-up", self._alt_mouse1_up)
|
||
|
||
self._last_pointer = None
|
||
|
||
# 键盘移动状态
|
||
self.move_state = {"w": False, "a": False, "s": False, "d": False, "q": False, "e": False, "space": False}
|
||
|
||
# 事件注册与任务添加
|
||
self.using_mousewatcher = self.mouseWatcher is not None
|
||
self.pointer_xy = None # 记录 Qt 事件传入的鼠标位置
|
||
|
||
self._update_camera()
|
||
self._mouse_task = None
|
||
self._focus_task = None
|
||
if self.using_mousewatcher:
|
||
self._mouse_task = base.taskMgr.add(self._poll_mouse, "camera-orbit-mouse")
|
||
# print("Using mouseWatcher")
|
||
else:
|
||
# print("Not Using mouseWatcher")
|
||
pass
|
||
|
||
self._register_events()
|
||
|
||
self._move_task = base.taskMgr.add(self._update_task, "camera-orbit-update")
|
||
|
||
def _alt_mouse1(self, evt):
|
||
self._set_mod("alt", True)
|
||
self._set_button_state("lmb", True, evt)
|
||
|
||
def _alt_mouse1_up(self, evt):
|
||
self._set_mod("alt", False)
|
||
self._set_button_state("lmb", False, evt)
|
||
|
||
def _set_mod(self, mod: str, state: bool):
|
||
if state and mod not in self.mods:
|
||
self.mods.append(mod)
|
||
elif not state and mod in self.mods:
|
||
self.mods.remove(mod)
|
||
|
||
# 公共接口 -----------------------------------------------------------
|
||
def set_target(self, target: NodePath|None):
|
||
"""设置新的注视点并立即更新相机。"""
|
||
if target:
|
||
self.cam_target = target.get_pos(self.render)
|
||
self.focus_target_node = target
|
||
|
||
def set_focus_target(self, focus_node: Optional[NodePath]):
|
||
"""设置按 F 聚焦时使用的目标 NodePath。"""
|
||
self.focus_target_node = focus_node
|
||
|
||
def destroy(self):
|
||
"""清理事件与任务，便于在销毁/切换场景时释放。"""
|
||
if self._mouse_task:
|
||
self.base.taskMgr.remove(self._mouse_task)
|
||
if self._move_task:
|
||
self.base.taskMgr.remove(self._move_task)
|
||
if self._focus_task:
|
||
self.base.taskMgr.remove(self._focus_task)
|
||
for key in list(self.move_state.keys()):
|
||
self.base.ignore(key)
|
||
self.base.ignore(f"{key}-up")
|
||
for ev in [
|
||
"wheel_up",
|
||
"wheel_down",
|
||
"wheel",
|
||
"mouse1",
|
||
"mouse1-up",
|
||
"mouse2",
|
||
"mouse2-up",
|
||
"mouse3",
|
||
"mouse3-up",
|
||
"mouse-move",
|
||
]:
|
||
self.base.ignore(ev)
|
||
self.base.ignore("f")
|
||
|
||
# 内部逻辑 -----------------------------------------------------------
|
||
def _register_events(self):
|
||
"""注册鼠标与键盘事件。"""
|
||
# 滚轮（Qt 侧会发 'wheel' 事件，常规 Panda3D 为 wheel_up/down）
|
||
self.base.accept("wheel_up", lambda: self._on_wheel(120))
|
||
self.base.accept("wheel_down", lambda: self._on_wheel(-120))
|
||
self.base.accept("wheel", lambda evt: self._on_wheel(evt.get("delta", 0) if isinstance(evt, dict) else 0))
|
||
|
||
for key in self.move_state:
|
||
self.base.accept(key, self._set_key, [key, True])
|
||
self.base.accept(f"{key}-up", self._set_key, [key, False])
|
||
|
||
# 对嵌入 Qt 的 offscreen，mouseWatcher 常为空，改用事件驱动
|
||
self.base.accept("mouse1", lambda evt=None: self._set_button_state("lmb", True, evt))
|
||
self.base.accept("mouse1-up", lambda evt=None: self._set_button_state("lmb", False, evt))
|
||
self.base.accept("mouse2", lambda evt=None: self._set_button_state("rmb", True, evt))
|
||
self.base.accept("mouse2-up", lambda evt=None: self._set_button_state("rmb", False, evt))
|
||
self.base.accept("mouse3", lambda evt=None: self._set_button_state("mmb", True, evt))
|
||
self.base.accept("mouse3-up", lambda evt=None: self._set_button_state("mmb", False, evt))
|
||
self.base.accept("mouse-move", self._on_mouse_move_event)
|
||
# Unity 风格：按 F 聚焦当前选中物体
|
||
self.base.accept("f", self.focus_on_node)
|
||
|
||
def _on_wheel(self, delta: float):
|
||
"""滚轮缩放，按距离比例调整。"""
|
||
zoom = 1.0 - (delta * self.zoom_factor)
|
||
zoom = max(0.2, min(5.0, zoom))
|
||
self.distance = max(0.5, self.distance * zoom)
|
||
self._update_camera()
|
||
|
||
def _set_key(self, key, pressed):
|
||
# print(f"{key} {pressed}")
|
||
"""更新键盘按下/抬起状态。"""
|
||
self.move_state[key] = pressed
|
||
|
||
def _set_button_state(self, name: str, down: bool, evt=None):
|
||
"""Qt 嵌入时由 messenger 事件更新按键状态。"""
|
||
if name == "lmb":
|
||
self.lmb_down = down
|
||
elif name == "mmb":
|
||
self.mmb_down = down
|
||
elif name == "rmb":
|
||
self.rmb_down = down
|
||
if isinstance(evt, dict) and "x" in evt and "y" in evt:
|
||
self.pointer_xy = (evt["x"], evt["y"])
|
||
self._last_pointer = None
|
||
|
||
def _on_mouse_move_event(self, evt: dict):
|
||
"""Qt 嵌入时的鼠标移动事件处理（evt: {'x':..,'y':..}）。"""
|
||
if not isinstance(evt, dict):
|
||
return
|
||
x, y = evt.get("x"), evt.get("y")
|
||
if x is None or y is None:
|
||
return
|
||
if self._last_pointer is None:
|
||
self._last_pointer = (x, y)
|
||
return
|
||
dx = x - self._last_pointer[0]
|
||
dy = y - self._last_pointer[1]
|
||
self._last_pointer = (x, y)
|
||
|
||
alt_down = ("alt" in self.mods)
|
||
if self.lmb_down and (alt_down or not self.orbit_requires_alt):
|
||
self.yaw += dx * self.orbit_sensitivity
|
||
self.pitch = max(-89.0, min(89.0, self.pitch -
|
||
dy * self.orbit_sensitivity))
|
||
self._update_camera()
|
||
elif self.mmb_down:
|
||
quat = self.cam.getQuat(self.render)
|
||
right = quat.getRight()
|
||
up = quat.getUp()
|
||
pan_speed = self.distance * self.pan_factor
|
||
self.cam_target += right * (-dx * pan_speed)
|
||
self.cam_target += up * (dy * pan_speed)
|
||
self._update_camera()
|
||
elif self.rmb_down:
|
||
self.yaw += dx * self.orbit_sensitivity
|
||
self.pitch = max(-89.0, min(89.0, self.pitch -
|
||
dy * self.orbit_sensitivity))
|
||
self._update_camera()
|
||
|
||
def _poll_mouse(self, task):
|
||
"""轮询鼠标指针，计算 dx/dy 并执行轨道或平移。"""
|
||
if self.mouseWatcher and self.mouseWatcher.hasMouse():
|
||
# 使用即时按钮状态，避免按 Alt 后再按键导致的事件缺失
|
||
current_lmb = self.mouseWatcher.isButtonDown(MouseButton.one())
|
||
current_mmb = self.mouseWatcher.isButtonDown(MouseButton.two())
|
||
current_rmb = self.mouseWatcher.isButtonDown(MouseButton.three())
|
||
if (current_lmb != self.lmb_down
|
||
or current_mmb != self.mmb_down
|
||
or current_rmb != self.rmb_down):
|
||
self._last_pointer = None
|
||
self.lmb_down = current_lmb
|
||
self.mmb_down = current_mmb
|
||
self.rmb_down = current_rmb
|
||
|
||
x = self.win.getPointer(0).getX()
|
||
y = self.win.getPointer(0).getY()
|
||
if self._last_pointer is None:
|
||
self._last_pointer = (x, y)
|
||
return task.cont
|
||
|
||
dx = x - self._last_pointer[0]
|
||
dy = y - self._last_pointer[1]
|
||
self._last_pointer = (x, y)
|
||
|
||
# Alt 检测兼容左右 Alt（部分系统/窗口管理器会屏蔽 Alt+LMB，可将 orbit_requires_alt 设为 False 仅用 LMB 轨道）
|
||
alt_down = (
|
||
self.mouseWatcher.isButtonDown(KeyboardButton.alt())
|
||
or self.mouseWatcher.isButtonDown(KeyboardButton.lalt())
|
||
or self.mouseWatcher.isButtonDown(KeyboardButton.ralt())
|
||
)
|
||
|
||
# Alt + 左键：轨道旋转
|
||
# print(f"alt_down->{alt_down} lmb_down->{self.lmb_down} lmb_down->{self.lmb_down}")
|
||
if self.lmb_down and (alt_down or not self.orbit_requires_alt):
|
||
self.yaw += dx * self.orbit_sensitivity
|
||
self.pitch = max(-89.0, min(89.0, self.pitch -dy * self.orbit_sensitivity))
|
||
self._update_camera()
|
||
|
||
# 中键：平移
|
||
elif self.mmb_down:
|
||
quat = self.cam.getQuat(self.render)
|
||
right = quat.getRight()
|
||
up = quat.getUp()
|
||
pan_speed = self.distance * self.pan_factor
|
||
self.cam_target += right * (-dx * pan_speed)
|
||
self.cam_target += up * (dy * pan_speed)
|
||
self._update_camera()
|
||
|
||
# Alt + 右键：推拉（缩放）
|
||
elif alt_down and self.rmb_down:
|
||
dolly = 1.0 - (dy * self.zoom_factor)
|
||
dolly = max(0.2, min(5.0, dolly))
|
||
self.distance = max(0.5, self.distance * dolly)
|
||
self._update_camera()
|
||
|
||
# 右键：自由视角旋转
|
||
elif self.rmb_down:
|
||
self.yaw += dx * self.orbit_sensitivity
|
||
self.pitch = max(-89.0, min(89.0, self.pitch -dy * self.orbit_sensitivity))
|
||
self._update_camera()
|
||
return task.cont
|
||
|
||
def _update_task(self, task:Task):
|
||
if HAS_IMGUI:
|
||
io = imgui.get_io()
|
||
if io.want_capture_mouse: return task.cont
|
||
|
||
"""每帧根据键盘状态推动摄像机目标点。"""
|
||
dt = globalClock.getDt()
|
||
move_vec = Vec3(0, 0, 0)
|
||
|
||
quat = self.cam.getQuat(self.render)
|
||
forward = quat.getForward()
|
||
right = quat.getRight()
|
||
up = Vec3(0, 0, 1)
|
||
|
||
# 只有右键按住时启用 WASD/QE（符合 Unity 右键飞行视角）
|
||
if self.rmb_down:
|
||
if self.move_state["w"]:
|
||
move_vec += forward
|
||
if self.move_state["s"]:
|
||
move_vec -= forward
|
||
if self.move_state["a"]:
|
||
move_vec -= right
|
||
if self.move_state["d"]:
|
||
move_vec += right
|
||
if self.move_state["q"]:
|
||
move_vec -= up
|
||
if self.move_state["e"] or self.move_state["space"]:
|
||
move_vec += up
|
||
|
||
if move_vec.length_squared() > 0:
|
||
move_vec.normalize()
|
||
move_vec *= self.move_speed * dt
|
||
self.cam_target += move_vec
|
||
self._update_camera()
|
||
|
||
return task.cont
|
||
|
||
def _update_camera(self, look_at: bool = True):
|
||
if HAS_IMGUI:
|
||
io = imgui.get_io()
|
||
if io.want_capture_mouse: return
|
||
|
||
"""根据 yaw/pitch/距离刷新相机位置并朝向目标。"""
|
||
rad_yaw = math.radians(self.yaw)
|
||
rad_pitch = math.radians(self.pitch)
|
||
|
||
dir_vec = Vec3(
|
||
math.sin(rad_yaw) * math.cos(rad_pitch),
|
||
math.cos(rad_yaw) * math.cos(rad_pitch),
|
||
math.sin(rad_pitch),
|
||
)
|
||
|
||
cam_pos = self.cam_target - dir_vec * self.distance
|
||
self.cam.setPos(cam_pos)
|
||
if (look_at):
|
||
self.cam.lookAt(self.cam_target)
|
||
|
||
# 聚焦 ---------------------------------------------------------------
|
||
def focus_on_node(self, node: Optional[NodePath] = None, duration: float = 0.2, padding: float = 1.2):
|
||
"""
|
||
按 F 聚焦到指定物体或最近一次设置的 focus_target_node。
|
||
会根据包围盒调整距离，空物体则只平移到其位置。
|
||
"""
|
||
target_node = node or self.focus_target_node
|
||
if target_node is None:
|
||
return
|
||
if hasattr(target_node, "is_empty") and target_node.is_empty():
|
||
return
|
||
|
||
center, target_distance, has_bounds = self._compute_focus_goal(target_node, padding)
|
||
if not has_bounds:
|
||
# 空物体或无包围盒：仅移动到位置，距离保持当前的一个合理值
|
||
target_distance = max(self.distance, 3.0)
|
||
if abs(p3d.LPoint3f(center-self.cam.get_pos()).length() - target_distance) < 0.1:
|
||
target_distance = max(target_distance / 3.0 , 1.0)
|
||
|
||
self._start_focus_lerp(center, target_distance, duration)
|
||
|
||
def _compute_focus_goal(self, node: NodePath, padding: float) -> tuple[LPoint3, float, bool]:
|
||
"""返回聚焦中心、距离以及是否使用了有效包围盒。"""
|
||
try:
|
||
bounds = node.get_tight_bounds(self.render) if hasattr(node, "get_tight_bounds") else node.getTightBounds(self.render)
|
||
except Exception:
|
||
bounds = None
|
||
|
||
if bounds and len(bounds) >= 2 and bounds[0] is not None and bounds[1] is not None:
|
||
bmin, bmax = bounds
|
||
extent = bmax - bmin
|
||
if extent.length_squared() > 1e-6:
|
||
center = (bmin + bmax) * 0.5
|
||
radius = extent.length() * 0.5 * padding
|
||
lens = self.base.cam.node().getLens() if self.cam else None
|
||
if lens:
|
||
fov = lens.getFov()
|
||
half_fov_x = max(1e-3, math.radians(float(fov[0])) * 0.5)
|
||
half_fov_y = max(1e-3, math.radians(float(fov[1])) * 0.5)
|
||
dist_x = radius / math.tan(half_fov_x)
|
||
dist_y = radius / math.tan(half_fov_y)
|
||
distance = max(dist_x, dist_y)
|
||
near = getattr(lens, "getNear", lambda: 0.0)()
|
||
distance = max(distance, near + radius * 0.5)
|
||
else:
|
||
distance = radius / math.tan(math.radians(30))
|
||
return center, max(distance, 0.5), True
|
||
|
||
# 无有效包围盒：使用节点位置作为聚焦中心
|
||
try:
|
||
center = node.get_pos(self.render)
|
||
except Exception:
|
||
center = self.cam_target
|
||
return center, max(self.distance, 0.5), False
|
||
|
||
def _start_focus_lerp(self, target_center: LPoint3, target_distance: float, duration: float):
|
||
"""平滑插值到新的目标与距离。"""
|
||
if self._focus_task:
|
||
self.base.taskMgr.remove(self._focus_task)
|
||
self._focus_task = None
|
||
|
||
start_target = LPoint3(self.cam_target)
|
||
start_distance = float(self.distance)
|
||
duration = max(0.01, duration)
|
||
|
||
def _lerp(task):
|
||
t = min(task.time / duration, 1.0)
|
||
# smoothstep
|
||
t = t * t * (3 - 2 * t)
|
||
self.cam_target = start_target * (1.0 - t) + target_center * t
|
||
self.distance = start_distance + (target_distance - start_distance) * t
|
||
self._update_camera()
|
||
if t >= 1.0:
|
||
self._focus_task = None
|
||
return task.done
|
||
return task.cont
|
||
|
||
self._focus_task = self.base.taskMgr.add(_lerp, "camera-focus-lerp")
|