977 lines
36 KiB
Python
977 lines
36 KiB
Python
import math
|
||
from typing import Optional, Tuple, Callable, Dict, Any, List
|
||
|
||
from panda3d.core import (
|
||
NodePath,
|
||
Vec3,
|
||
Point3,
|
||
Point2,
|
||
Vec4,
|
||
Quat,
|
||
GeomNode,
|
||
GeomVertexFormat,
|
||
GeomVertexData,
|
||
GeomVertexWriter,
|
||
GeomTriangles,
|
||
GeomLines,
|
||
Geom,
|
||
CollisionNode,
|
||
CollisionRay,
|
||
CollisionHandlerQueue,
|
||
CollisionTraverser,
|
||
CollisionTube,
|
||
CollisionBox,
|
||
BitMask32,
|
||
PerspectiveLens,
|
||
Material,
|
||
LPoint2f
|
||
)
|
||
from direct.showbase.DirectObject import DirectObject
|
||
from direct.task import Task
|
||
from direct.task.TaskManagerGlobal import taskMgr
|
||
from direct.showbase.ShowBase import ShowBase
|
||
|
||
from .events import GizmoEvent
|
||
|
||
|
||
"""
|
||
缩放控制柄（Scale Gizmo）
|
||
=========================
|
||
|
||
功能概述：
|
||
- 模仿 Unity 的缩放控制柄，使用 3 个彩色轴线表示沿 X/Y/Z 轴缩放
|
||
- X 轴：红色线条 + 方块（沿局部 X 轴缩放）
|
||
- Y 轴：绿色线条 + 方块（沿局部 Y 轴缩放）
|
||
- Z 轴：蓝色线条 + 方块（沿局部 Z 轴缩放）
|
||
- 中心有一个白色小方块，用于均匀缩放（沿所有轴同时缩放）
|
||
- 使用 Panda3D 的碰撞系统进行鼠标拾取与拖拽
|
||
- 控件会根据摄像机距离自动缩放，屏幕大小保持近似不变
|
||
|
||
集成方式（示例）：
|
||
from direct.showbase.ShowBase import ShowBase
|
||
from TransformGizmo.scale_gizmo import ScaleGizmo
|
||
|
||
world = ShowBase()
|
||
model_np = world.render.attachNewNode("Box")
|
||
# ... 在 model_np 下加载模型
|
||
|
||
gizmo = ScaleGizmo(world) # 创建缩放 Gizmo
|
||
gizmo.attach(model_np) # 绑定到某个模型
|
||
|
||
# 当需要切换目标时：
|
||
gizmo.attach(another_np)
|
||
|
||
# 当不需要时，可隐藏：
|
||
gizmo.detach()
|
||
|
||
鼠标事件要求：
|
||
- 本类默认监听 Panda3D 的 "mouse1" / "mouse1-up" / "mouse-move" 事件
|
||
- 如果从外部 UI 传递鼠标像素坐标，可以在发送事件时传入 extra 字典：
|
||
messenger.send("mouse1", [{"x": mouse_x, "y": mouse_y}])
|
||
本类会自动将像素坐标转换到 [-1, 1] 的标准化设备坐标
|
||
"""
|
||
|
||
|
||
class ScaleGizmo(DirectObject):
|
||
"""
|
||
Unity 风格的缩放控制柄：
|
||
- 3 个轴线 + 方块分别代表沿局部 X/Y/Z 轴缩放
|
||
- 中心方块代表均匀缩放
|
||
- 左键点击并拖拽，可以缩放绑定的 NodePath
|
||
"""
|
||
|
||
def __init__(
|
||
self,
|
||
world:ShowBase,
|
||
camera_np: NodePath | None = None,
|
||
on_action_committed: Optional[Callable[[Dict[str, Any]], None]] = None,
|
||
event_hooks: Optional[Dict[str, List[Callable[[Dict[str, Any]], None]]]] = None
|
||
):
|
||
super().__init__()
|
||
|
||
self.world = world
|
||
self.is_local = True
|
||
self.debug: bool = False
|
||
self.is_hovering = False
|
||
self._picker_added: bool = False
|
||
self._debug_drag_counter: int = 0
|
||
self.on_action_committed = on_action_committed
|
||
# Event hooks: drag_start / drag_move / drag_end
|
||
self._event_hooks = self._normalize_event_hooks(event_hooks)
|
||
|
||
self.camera: Optional[NodePath] = camera_np or getattr(
|
||
world, "cam", None)
|
||
if not self.camera and hasattr(world, "base"):
|
||
self.camera = world.base.cam
|
||
if not self.camera:
|
||
self._log("No camera found for ScaleGizmo")
|
||
else:
|
||
self._log(f"Camera found for ScaleGizmo: {self.camera}")
|
||
|
||
self.root: NodePath = NodePath("ScaleGizmo")
|
||
self.color_higher = 0.05
|
||
self.color_normal = 0.01
|
||
self.last_mouse_pos = None
|
||
# self.root.setBin("fixed", 40)
|
||
# self.root.setDepthTest(False)
|
||
# self.root.setDepthWrite(False)
|
||
# self.root.setLightOff()
|
||
|
||
self.target_node: Optional[NodePath] = None
|
||
self.attached: bool = False
|
||
|
||
# 控制柄视觉参数
|
||
self.axis_length: float = 0.5
|
||
self.axis_thickness: float = 0.02
|
||
self.cube_size: float = 0.04
|
||
self.center_cube_size: float = 0.06
|
||
self.axis_alpha: float = 0.75
|
||
# 记录基准尺寸，用于拖拽时的可视放缩
|
||
self._axis_length0: float = self.axis_length
|
||
self._cube_size0: float = self.cube_size
|
||
self._center_cube_size0: float = self.center_cube_size
|
||
|
||
# 拾取射线与碰撞系统
|
||
self.picker_ray = CollisionRay()
|
||
self.picker_node = CollisionNode("scale_gizmo_picker_ray")
|
||
self.picker_node.addSolid(self.picker_ray)
|
||
self.picker_node.setFromCollideMask(BitMask32.bit(20))
|
||
self.picker_node.setIntoCollideMask(BitMask32.allOff())
|
||
self.picker_np: NodePath = NodePath(self.picker_node)
|
||
|
||
self.c_trav = CollisionTraverser()
|
||
self.c_queue = CollisionHandlerQueue()
|
||
|
||
# 拖拽状态
|
||
self.dragging: bool = False
|
||
self.drag_axis: Optional[int] = None # 0=X, 1=Y, 2=Z, 3=Uniform
|
||
self.start_mouse: Optional[Point2] = None
|
||
self.start_scale: Optional[Vec3] = None
|
||
self.drag_axis_dir: Vec3 = Vec3(0, 0, 0)
|
||
self.drag_axis_screen: Point2 = Point2(1, 0)
|
||
self.drag_base_dist: float = 1.0
|
||
self._start_param_on_ray: float = 0.0
|
||
|
||
# 撤销栈
|
||
self._scale_undo_stack: list[Tuple[NodePath, Vec3, Vec3]] = []
|
||
self._undo_scale_epsilon: float = 1e-4
|
||
|
||
# 轴和中心控制柄节点
|
||
self.axes: list[NodePath] = []
|
||
self.axes_colors: list[Tuple[NodePath,NodePath, Vec4]] = []
|
||
# 可视节点（线与端点立方体），与碰撞体分离，便于单独放缩
|
||
self.axis_visuals: list[Dict[str, NodePath]] = []
|
||
self.axis_visual_colors: list[Tuple[NodePath, Vec4]] = []
|
||
|
||
self.center_handle: Optional[NodePath] = None
|
||
self.center_handle_color = Vec4(1,1,1,1)
|
||
|
||
self._build_gizmo()
|
||
|
||
self.root.reparentTo(self.world.render)
|
||
self.root.setBin('fixed',40)
|
||
self.root.setDepthTest(False)
|
||
self.root.setDepthWrite(False)
|
||
self.root.setLightOff()
|
||
self.root.hide()
|
||
|
||
# taskMgr.add(self._update_task, "ScaleGizmoUpdateTask")
|
||
|
||
def _log(self, msg: str):
|
||
if self.debug:
|
||
print(f"[ScaleGizmo] {msg}")
|
||
|
||
def _normalize_event_hooks(self, hooks):
|
||
base = {name: [] for name in GizmoEvent.ALL}
|
||
if not hooks:
|
||
return base
|
||
for name in list(base.keys()):
|
||
cbs = hooks.get(name)
|
||
if cbs:
|
||
base[name] = list(cbs)
|
||
return base
|
||
|
||
def _emit_event(self, name: str, payload: Dict[str, Any]):
|
||
handlers = self._event_hooks.get(name, [])
|
||
for cb in handlers:
|
||
try:
|
||
cb(payload)
|
||
except Exception as exc:
|
||
self._log(f"event hook '{name}' error: {exc}")
|
||
|
||
def _build_gizmo(self):
|
||
"""构建三个轴控制柄和中心均匀缩放控制柄。"""
|
||
# X 轴（红）
|
||
axis_root, line_np, cube_np = self._create_axis(
|
||
axis_dir=Vec3(1, 0, 0),
|
||
color=Vec4(1, 0, 0, 1),
|
||
length=self.axis_length,
|
||
thickness=self.axis_thickness,
|
||
cube_size=self.cube_size,
|
||
axis_id=0,
|
||
)
|
||
self.axes.append(axis_root)
|
||
self.axis_visuals.append(
|
||
{"line": line_np, "cube": cube_np, "length": self.axis_length, "cube_size": self.cube_size}
|
||
)
|
||
# Y 轴（绿）
|
||
axis_root, line_np, cube_np = self._create_axis(
|
||
axis_dir=Vec3(0, 1, 0),
|
||
color=Vec4(0, 1, 0, 1),
|
||
length=self.axis_length,
|
||
thickness=self.axis_thickness,
|
||
cube_size=self.cube_size,
|
||
axis_id=1,
|
||
)
|
||
self.axes.append(axis_root)
|
||
self.axis_visuals.append(
|
||
{"line": line_np, "cube": cube_np, "length": self.axis_length, "cube_size": self.cube_size}
|
||
)
|
||
# Z 轴（蓝）
|
||
axis_root, line_np, cube_np = self._create_axis(
|
||
axis_dir=Vec3(0, 0, 1),
|
||
color=Vec4(0, 0, 1, 1),
|
||
length=self.axis_length,
|
||
thickness=self.axis_thickness,
|
||
cube_size=self.cube_size,
|
||
axis_id=2,
|
||
)
|
||
self.axes.append(axis_root)
|
||
self.axis_visuals.append({"line": line_np, "cube": cube_np, "length": self.axis_length, "cube_size": self.cube_size})
|
||
# 中心控制柄（白色方块，用于均匀缩放）
|
||
self.center_handle = self._create_center_handle(
|
||
size=self.center_cube_size,
|
||
color=Vec4(1, 1, 1, 1),
|
||
)
|
||
|
||
def _set_node_dept(self,node:NodePath,color:Vec4 = None):
|
||
if node is None or node.is_empty():return
|
||
mat = Material('default')
|
||
mat.set_emission((1,0,1,1))
|
||
if color: mat.base_color = color * self.color_normal
|
||
node.set_material(mat)
|
||
node.set_bin('fixed',40)
|
||
node.set_depth_test(False)
|
||
node.set_depth_write(False)
|
||
|
||
def _create_axis(
|
||
self,
|
||
axis_dir: Vec3,
|
||
color: Vec4,
|
||
length: float,
|
||
thickness: float,
|
||
cube_size: float,
|
||
axis_id: int,
|
||
) -> Tuple[NodePath, NodePath, NodePath]:
|
||
"""创建一个轴控制柄：线条 + 末端方块。"""
|
||
axis_root = self.root.attachNewNode(f"scale_axis_{axis_id}")
|
||
|
||
align_quat = self._quat_from_z(axis_dir)
|
||
axis_root.setQuat(align_quat)
|
||
|
||
# 几何：线条
|
||
line_geom = self._create_line_geom(length, color)
|
||
line_np: NodePath = axis_root.attachNewNode(line_geom)
|
||
line_np.setTransparency(True)
|
||
line_np.setAlphaScale(self.axis_alpha)
|
||
line_np_copy = line_np.copyTo(line_np)
|
||
line_np_copy.set_pos(0,0,0)
|
||
line_np_copy.set_hpr(0,0,0)
|
||
|
||
# 几何：末端方块
|
||
cube_geom = self._create_cube_geom(cube_size, color)
|
||
cube_np: NodePath = axis_root.attachNewNode(cube_geom)
|
||
cube_np.setPos(0, 0, length)
|
||
cube_np.setTransparency(True)
|
||
cube_np.setAlphaScale(self.axis_alpha)
|
||
cube_np_copy = cube_np.copy_to(cube_np)
|
||
cube_np_copy.set_pos(0,0,0)
|
||
cube_np_copy.set_hpr(0,0,0)
|
||
|
||
# 碰撞体：线条使用 Tube
|
||
c_node = CollisionNode(f"scale_axis_col_{axis_id}")
|
||
tube = CollisionTube(Point3(0, 0, 0), Point3(0, 0, length), thickness * 2)
|
||
c_node.addSolid(tube)
|
||
c_node.setIntoCollideMask(BitMask32.bit(20))
|
||
c_node.setFromCollideMask(BitMask32.allOff())
|
||
c_node.setTag("gizmo_axis", str(axis_id))
|
||
axis_root.attachNewNode(c_node)
|
||
|
||
# 碰撞体：末端方块
|
||
c_cube_node = CollisionNode(f"scale_cube_col_{axis_id}")
|
||
half = cube_size * 0.5
|
||
box = CollisionBox(Point3(0, 0, length), half, half, half)
|
||
c_cube_node.addSolid(box)
|
||
c_cube_node.setIntoCollideMask(BitMask32.bit(20))
|
||
c_cube_node.setFromCollideMask(BitMask32.allOff())
|
||
c_cube_node.setTag("gizmo_axis", str(axis_id))
|
||
axis_root.attachNewNode(c_cube_node)
|
||
|
||
return axis_root, line_np, cube_np
|
||
|
||
def _create_center_handle(self, size: float, color: Vec4) -> NodePath:
|
||
"""创建中心均匀缩放控制柄（方块）。"""
|
||
center_root = self.root.attachNewNode("scale_center")
|
||
|
||
cube_geom = self._create_cube_geom(size, color)
|
||
cube_np: NodePath = center_root.attachNewNode(cube_geom)
|
||
cube_np.setTransparency(True)
|
||
cube_np.setAlphaScale(self.axis_alpha)
|
||
|
||
c_node = CollisionNode("scale_center_col")
|
||
half = size * 0.5
|
||
box = CollisionBox(Point3(0, 0, 0), half, half, half)
|
||
c_node.addSolid(box)
|
||
c_node.setIntoCollideMask(BitMask32.bit(20))
|
||
c_node.setFromCollideMask(BitMask32.allOff())
|
||
c_node.setTag("gizmo_center", "1")
|
||
center_root.attachNewNode(c_node)
|
||
|
||
return center_root
|
||
|
||
def _create_line_geom(self, length: float, color: Vec4) -> GeomNode:
|
||
"""创建一条沿 +Z 方向的线段几何。"""
|
||
vdata = GeomVertexData(
|
||
"line", GeomVertexFormat.getV3c4(), Geom.UHStatic)
|
||
vertex = GeomVertexWriter(vdata, "vertex")
|
||
vcolor = GeomVertexWriter(vdata, "color")
|
||
|
||
vertex.addData3(0, 0, 0)
|
||
vcolor.addData4(color)
|
||
vertex.addData3(0, 0, length)
|
||
vcolor.addData4(color)
|
||
|
||
prim = GeomLines(Geom.UHStatic)
|
||
prim.addVertices(0, 1)
|
||
|
||
geom = Geom(vdata)
|
||
geom.addPrimitive(prim)
|
||
node = GeomNode("line_geom")
|
||
node.addGeom(geom)
|
||
return node
|
||
|
||
def _create_cube_geom(self, size: float, color: Vec4) -> GeomNode:
|
||
"""创建一个以原点为中心的立方体几何。"""
|
||
vdata = GeomVertexData(
|
||
"cube", GeomVertexFormat.getV3c4(), Geom.UHStatic)
|
||
vertex = GeomVertexWriter(vdata, "vertex")
|
||
vcolor = GeomVertexWriter(vdata, "color")
|
||
|
||
half = size * 0.5
|
||
|
||
# 8个顶点
|
||
vertices = [
|
||
Point3(-half, -half, -half), # 0
|
||
Point3(half, -half, -half), # 1
|
||
Point3(half, half, -half), # 2
|
||
Point3(-half, half, -half), # 3
|
||
Point3(-half, -half, half), # 4
|
||
Point3(half, -half, half), # 5
|
||
Point3(half, half, half), # 6
|
||
Point3(-half, half, half), # 7
|
||
]
|
||
|
||
for v in vertices:
|
||
vertex.addData3(v)
|
||
vcolor.addData4(color)
|
||
|
||
prim = GeomTriangles(Geom.UHStatic)
|
||
|
||
# 6个面，每个面2个三角形
|
||
faces = [
|
||
(0, 1, 2, 3), # 底面 -Z
|
||
(4, 7, 6, 5), # 顶面 +Z
|
||
(0, 4, 5, 1), # 前面 -Y
|
||
(2, 6, 7, 3), # 后面 +Y
|
||
(0, 3, 7, 4), # 左面 -X
|
||
(1, 5, 6, 2), # 右面 +X
|
||
]
|
||
|
||
for f in faces:
|
||
prim.addVertices(f[0], f[1], f[2])
|
||
prim.addVertices(f[0], f[2], f[3])
|
||
|
||
geom = Geom(vdata)
|
||
geom.addPrimitive(prim)
|
||
node = GeomNode("cube_geom")
|
||
node.addGeom(geom)
|
||
return node
|
||
|
||
def _quat_from_z(self, direction: Vec3) -> Quat:
|
||
"""返回一个四元数，使本地 +Z 旋转到指定 direction。"""
|
||
dir_norm = Vec3(direction)
|
||
if dir_norm.length_squared() == 0:
|
||
return Quat.identQuat()
|
||
dir_norm.normalize()
|
||
z_axis = Vec3(0, 0, 1)
|
||
dot = z_axis.dot(dir_norm)
|
||
if abs(dot - 1.0) < 1e-6:
|
||
return Quat.identQuat()
|
||
if abs(dot + 1.0) < 1e-6:
|
||
ortho = Vec3(1, 0, 0) if abs(z_axis.dot(
|
||
Vec3(1, 0, 0))) < 0.9 else Vec3(0, 1, 0)
|
||
axis = z_axis.cross(ortho)
|
||
axis.normalize()
|
||
q = Quat()
|
||
q.setFromAxisAngle(180.0, axis)
|
||
return q
|
||
axis = z_axis.cross(dir_norm)
|
||
axis_len = axis.length()
|
||
if axis_len == 0:
|
||
return Quat.identQuat()
|
||
axis.normalize()
|
||
angle_rad = math.atan2(axis_len, dot)
|
||
q = Quat()
|
||
q.setFromAxisAngle(math.degrees(angle_rad), axis)
|
||
return q
|
||
|
||
def attach(self, node_path: NodePath):
|
||
"""绑定控制柄到指定 NodePath。"""
|
||
if not node_path:
|
||
return
|
||
|
||
self.target_node = node_path
|
||
self.attached = True
|
||
self._update_root_transform()
|
||
self.root.show()
|
||
self._log(
|
||
f"attached to {node_path.getName()} "
|
||
f"world_pos={self.root.getPos(self.world.render)} "
|
||
f"target_scale={node_path.getScale()}"
|
||
)
|
||
self._register_events()
|
||
|
||
def detach(self):
|
||
"""解绑并隐藏 Gizmo。"""
|
||
self.target_node = None
|
||
self.root.hide()
|
||
self.attached = False
|
||
self.dragging = False
|
||
self.drag_axis = None
|
||
self.is_hovering = False
|
||
self._reset_axis_visuals()
|
||
self._ignore_events()
|
||
self._log("detached")
|
||
|
||
def _record_scale_action(self, node: NodePath, old_scale: Vec3, new_scale: Vec3):
|
||
"""将一次缩放操作压入撤销栈。"""
|
||
if node is None or node.isEmpty():
|
||
return
|
||
if old_scale is None or new_scale is None:
|
||
return
|
||
|
||
delta = new_scale - old_scale
|
||
if delta.length() < self._undo_scale_epsilon:
|
||
return
|
||
|
||
old_copy = Vec3(old_scale)
|
||
new_copy = Vec3(new_scale)
|
||
self._scale_undo_stack.append((node, old_copy, new_copy))
|
||
self._log(
|
||
f"record scale action: node={node.getName()} "
|
||
f"old_scale={old_copy} new_scale={new_copy} stack_size={len(self._scale_undo_stack)}"
|
||
)
|
||
|
||
if self.on_action_committed is not None:
|
||
try:
|
||
self.on_action_committed(
|
||
{
|
||
"kind": "scale",
|
||
"node": node,
|
||
"old_scale": Vec3(old_copy),
|
||
"new_scale": Vec3(new_copy),
|
||
}
|
||
)
|
||
except Exception as exc:
|
||
self._log(f"on_action_committed(scale) error: {exc}")
|
||
|
||
def undo_last_scale(self):
|
||
"""撤销最近一次缩放操作。"""
|
||
if not self._scale_undo_stack:
|
||
self._log("undo_last_scale: stack empty")
|
||
return
|
||
node, old_scale, new_scale = self._scale_undo_stack.pop()
|
||
if node is None or node.isEmpty():
|
||
self._log("undo_last_scale: target node invalid")
|
||
return
|
||
node.setScale(old_scale)
|
||
self._log(
|
||
f"undo_last_scale: node={node.getName()} "
|
||
f"old_scale={old_scale} new_scale={new_scale} remaining={len(self._scale_undo_stack)}"
|
||
)
|
||
|
||
def _register_events(self):
|
||
"""注册鼠标事件监听。"""
|
||
self.accept("mouse1", self._on_mouse_down)
|
||
self.accept("mouse1-up", self._on_mouse_up)
|
||
self.accept("mouse2-up", self._on_mouse_up)
|
||
self.accept("mouse3-up", self._on_mouse_up)
|
||
self.accept("mouse-move", self._on_mouse_move)
|
||
self._log("event listeners registered (mouse)")
|
||
|
||
def _ignore_events(self):
|
||
"""取消事件监听。"""
|
||
self.ignore("mouse1")
|
||
self.ignore("mouse1-up")
|
||
self.ignore("mouse2-up")
|
||
self.ignore("mouse3-up")
|
||
self.ignore("mouse-move")
|
||
self._log("event listeners removed")
|
||
|
||
def _get_normalized_mouse(self, extra) -> Optional[Point3]:
|
||
if self.world.mouseWatcherNode.hasMouse():
|
||
mouse = self.world.mouseWatcherNode.getMouse()
|
||
return Point3(mouse.x, mouse.y, 0)
|
||
|
||
"""将鼠标转换到 Panda3D 的标准化设备坐标 [-1, 1]。"""
|
||
if isinstance(extra, dict) and "x" in extra and "y" in extra:
|
||
parent = getattr(self.world, "parent", None)
|
||
if parent is not None:
|
||
w = max(parent.width(), 1)
|
||
h = max(parent.height(), 1)
|
||
nx = (extra["x"] / w) * 2.0 - 1.0
|
||
ny = 1.0 - (extra["y"] / h) * 2.0
|
||
return Point3(nx, ny, 0.0)
|
||
|
||
return None
|
||
|
||
def _on_mouse_down(self, extra=None):
|
||
if not self.attached or not self.camera or self.target_node is None:
|
||
return
|
||
|
||
mpos = self._get_normalized_mouse(extra)
|
||
if mpos is None:
|
||
self._log("mouse_down ignored: no mouse pos")
|
||
return
|
||
|
||
self.picker_np.reparentTo(self.camera)
|
||
if not self._picker_added:
|
||
self.c_trav.addCollider(self.picker_np, self.c_queue)
|
||
self._picker_added = True
|
||
self.picker_ray.setFromLens(self.camera.node(), mpos.x, mpos.y)
|
||
|
||
self.c_queue.clearEntries()
|
||
self.c_trav.traverse(self.root)
|
||
|
||
self._log(
|
||
f"mouse_down mpos={mpos} cam_pos={self.camera.getPos(self.world.render)} "
|
||
f"entries={self.c_queue.getNumEntries()}"
|
||
)
|
||
|
||
num_entries = self.c_queue.getNumEntries()
|
||
if num_entries <= 0:
|
||
self._log("mouse_down: no collision entries on scale gizmo")
|
||
return
|
||
|
||
self.c_queue.sortEntries()
|
||
|
||
axis_entry = None
|
||
center_entry = None
|
||
for i in range(num_entries):
|
||
e = self.c_queue.getEntry(i)
|
||
if not center_entry and e.getIntoNode().getTag("gizmo_center"):
|
||
center_entry = e
|
||
if not axis_entry and e.getIntoNode().getTag("gizmo_axis"):
|
||
axis_entry = e
|
||
if center_entry and axis_entry:
|
||
break
|
||
|
||
# 优先选择中心控制柄
|
||
if center_entry is not None:
|
||
self.dragging = True
|
||
self.drag_axis = 3 # Uniform scale
|
||
self.start_scale = self.target_node.getScale()
|
||
self.start_mouse = Point2(mpos.x, mpos.y)
|
||
node_pos_w = self.target_node.getPos(self.world.render)
|
||
cam_pos = self.camera.getPos(self.world.render)
|
||
self.drag_base_dist = max((cam_pos - node_pos_w).length(), 0.5)
|
||
self._debug_drag_counter = 0
|
||
self._highlight_center()
|
||
self._log(
|
||
f"pick center (uniform scale) target={self.target_node.getName()} "
|
||
f"start_scale={self.start_scale}"
|
||
)
|
||
self._emit_event(
|
||
GizmoEvent.DRAG_START,
|
||
{
|
||
"gizmo": "scale",
|
||
"target": self.target_node,
|
||
"axis": self.drag_axis,
|
||
"mouse": Point2(mpos.x, mpos.y),
|
||
"start_scale": self.start_scale,
|
||
},
|
||
)
|
||
elif axis_entry is not None:
|
||
axis_tag: str = axis_entry.getIntoNode().getTag("gizmo_axis")
|
||
self.dragging = True
|
||
self.drag_axis = int(axis_tag)
|
||
self.start_scale = self.target_node.getScale()
|
||
self.start_mouse = Point2(mpos.x, mpos.y)
|
||
|
||
axis_index = int(axis_tag)
|
||
axis_np: NodePath = self.axes[axis_index]
|
||
axis_dir: Vec3 = axis_np.getQuat(
|
||
self.world.render).xform(Vec3(0, 0, 1))
|
||
if axis_dir.length_squared() == 0:
|
||
axis_dir = Vec3(0, 0, 1)
|
||
axis_dir.normalize()
|
||
self.drag_axis_dir = axis_dir
|
||
|
||
cam_pos = self.camera.getPos(self.world.render)
|
||
node_pos_w = self.target_node.getPos(self.world.render)
|
||
lens: PerspectiveLens = self.camera.node().getLens()
|
||
self.drag_base_dist = max((cam_pos - node_pos_w).length(), 0.5)
|
||
|
||
sample_len = max(self.drag_base_dist * 0.25, 0.25)
|
||
p0_cam = self.camera.getRelativePoint(
|
||
self.world.render, node_pos_w)
|
||
p1_cam = self.camera.getRelativePoint(
|
||
self.world.render, node_pos_w + axis_dir * sample_len
|
||
)
|
||
p0_2d = Point2()
|
||
p1_2d = Point2()
|
||
# 注意：即使 lens.project 返回 False（点可能超出裁剪范围），
|
||
# 它仍然会填充 p0_2d/p1_2d，我们可以使用这些值来计算方向
|
||
proj_ok_0 = lens.project(p0_cam, p0_2d)
|
||
proj_ok_1 = lens.project(p1_cam, p1_2d)
|
||
|
||
# 无论 project 返回值如何，都尝试计算屏幕方向
|
||
axis_screen_raw: Point2 = p1_2d - p0_2d
|
||
axis_screen_len = axis_screen_raw.length()
|
||
if axis_screen_len > 1e-6:
|
||
axis_screen = axis_screen_raw / axis_screen_len
|
||
else:
|
||
# 只有当投影长度真的为0时才使用默认值
|
||
axis_screen = Point2(1, 0)
|
||
self.drag_axis_screen = axis_screen
|
||
self._axis_screen_len = axis_screen_len # 保存用于诊断
|
||
|
||
# 计算摄像机视线方向与轴的夹角（用于诊断）
|
||
view_dir = node_pos_w - cam_pos
|
||
if view_dir.length_squared() > 0:
|
||
view_dir.normalize()
|
||
axis_view_dot = abs(axis_dir.dot(view_dir))
|
||
|
||
self._debug_drag_counter = 0
|
||
self._highlight_axis(self.drag_axis)
|
||
|
||
# 诊断打印
|
||
strer: list[str] = []
|
||
strer.append(f"[ScaleGizmo DEBUG] ========== AXIS PICK ==========")
|
||
strer.append(
|
||
f" axis_id: {self.drag_axis} ({'XYZ'[self.drag_axis]})")
|
||
strer.append(f" axis_dir (world): {axis_dir}")
|
||
strer.append(f" cam_pos: {cam_pos}")
|
||
strer.append(f" node_pos: {node_pos_w}")
|
||
strer.append(f" view_dir: {view_dir}")
|
||
strer.append(f" axis_view_dot (|axis·view|): {axis_view_dot:.4f}")
|
||
strer.append(f" p0_cam: {p0_cam}, p1_cam: {p1_cam}")
|
||
strer.append(f" proj_ok: p0={proj_ok_0}, p1={proj_ok_1}")
|
||
strer.append(f" p0_2d: {p0_2d}, p1_2d: {p1_2d}")
|
||
strer.append(
|
||
f" axis_screen_raw: ({axis_screen_raw.x:.4f}, {axis_screen_raw.y:.4f})")
|
||
strer.append(
|
||
f" axis_screen_len (before normalize): {axis_screen_len:.6f}")
|
||
strer.append(
|
||
f" axis_screen (normalized): ({axis_screen.x:.4f}, {axis_screen.y:.4f})")
|
||
if axis_view_dot > 0.9:
|
||
strer.append(
|
||
f" WARNING: Axis nearly parallel to view direction!")
|
||
if axis_screen_len < 0.01:
|
||
strer.append(f" WARNING: Axis screen projection very short!")
|
||
strer.append(f" ==========================================")
|
||
self._log("\n".join(strer))
|
||
|
||
self._log(
|
||
f"pick axis={self.drag_axis} target={self.target_node.getName()} "
|
||
f"start_scale={self.start_scale} axis_dir={axis_dir}"
|
||
)
|
||
self._emit_event(
|
||
GizmoEvent.DRAG_START,
|
||
{
|
||
"gizmo": "scale",
|
||
"target": self.target_node,
|
||
"axis": self.drag_axis,
|
||
"mouse": Point2(mpos.x, mpos.y),
|
||
"start_scale": self.start_scale,
|
||
},
|
||
)
|
||
else:
|
||
self._log(
|
||
"mouse_down: hit something but no gizmo_axis or gizmo_center tag")
|
||
|
||
def _on_mouse_up(self, extra=None):
|
||
if self.dragging and self.target_node is not None:
|
||
try:
|
||
final_scale = self.target_node.getScale()
|
||
except Exception:
|
||
final_scale = None
|
||
old_scale = self.start_scale
|
||
if old_scale is not None and final_scale is not None:
|
||
self._record_scale_action(
|
||
self.target_node, old_scale, final_scale)
|
||
|
||
axis_id = self.drag_axis
|
||
self._emit_event(
|
||
GizmoEvent.DRAG_END,
|
||
{
|
||
"gizmo": "scale",
|
||
"target": self.target_node,
|
||
"axis": axis_id,
|
||
"start_scale": old_scale,
|
||
"final_scale": final_scale,
|
||
},
|
||
)
|
||
self.dragging = False
|
||
self.drag_axis = None
|
||
self._reset_axis_visuals()
|
||
self._reset_highlights()
|
||
self._log("mouse_up -> stop scaling")
|
||
|
||
def _on_mouse_move(self, extra=None):
|
||
if not self.attached or not self.camera:
|
||
return
|
||
|
||
mpos = self._get_normalized_mouse(extra)
|
||
if mpos is None:
|
||
if self.dragging:
|
||
self._log("mouse_move ignored: no mouse pos while scaling")
|
||
return
|
||
|
||
# Hover highlight when idle.
|
||
if not self.dragging:
|
||
self._update_hover_highlight(mpos)
|
||
return
|
||
|
||
if not self.target_node:
|
||
return
|
||
|
||
mouse_ndc = Point2(mpos.x, mpos.y)
|
||
delta = mouse_ndc - self.start_mouse
|
||
|
||
if self.drag_axis == 3:
|
||
# 均匀缩放：基于鼠标在屏幕上的垂直移动
|
||
scale_factor = 1.0 + delta.y * 2.0
|
||
scale_factor = max(scale_factor, 0.01) # 防止负缩放
|
||
new_scale = self.start_scale * scale_factor
|
||
self.target_node.setScale(new_scale)
|
||
|
||
if self._debug_drag_counter % 4 == 0:
|
||
self._log(
|
||
f"uniform scale factor={scale_factor:.4f} "
|
||
f"new_scale={new_scale}"
|
||
)
|
||
self._debug_drag_counter += 1
|
||
self._emit_event(
|
||
GizmoEvent.DRAG_MOVE,
|
||
{
|
||
"gizmo": "scale",
|
||
"target": self.target_node,
|
||
"axis": self.drag_axis,
|
||
"mouse": Point2(mpos.x, mpos.y),
|
||
"new_scale": new_scale,
|
||
"scale_factor": scale_factor,
|
||
},
|
||
)
|
||
self._update_axis_visuals_for_scale(new_scale)
|
||
else:
|
||
# 单轴缩放
|
||
s_scalar = delta.dot(self.drag_axis_screen)
|
||
scale_factor = 1.0 + s_scalar * 2.0
|
||
scale_factor = max(scale_factor, 0.01)
|
||
|
||
new_scale = Vec3(self.start_scale)
|
||
if self.drag_axis == 0:
|
||
new_scale.x = self.start_scale.x * scale_factor
|
||
elif self.drag_axis == 1:
|
||
new_scale.y = self.start_scale.y * scale_factor
|
||
elif self.drag_axis == 2:
|
||
new_scale.z = self.start_scale.z * scale_factor
|
||
|
||
self.target_node.setScale(new_scale)
|
||
|
||
# 诊断打印（每16帧打印一次，避免刷屏）
|
||
# if self._debug_drag_counter % 16 == 0:
|
||
# axis_screen_len = getattr(self, '_axis_screen_len', 0.0)
|
||
# print(f"[ScaleGizmo DRAG] axis={self.drag_axis}({'XYZ'[self.drag_axis]}) "
|
||
# f"delta=({delta.x:.4f}, {delta.y:.4f}) "
|
||
# f"axis_screen=({self.drag_axis_screen.x:.4f}, {self.drag_axis_screen.y:.4f}) "
|
||
# f"axis_screen_len={axis_screen_len:.4f} "
|
||
# f"s_scalar={s_scalar:.4f} "
|
||
# f"scale_factor={scale_factor:.4f}")
|
||
self._debug_drag_counter += 1
|
||
self._emit_event(
|
||
GizmoEvent.DRAG_MOVE,
|
||
{
|
||
"gizmo": "scale",
|
||
"target": self.target_node,
|
||
"axis": self.drag_axis,
|
||
"mouse": Point2(mpos.x, mpos.y),
|
||
"new_scale": new_scale,
|
||
"scale_factor": scale_factor,
|
||
},
|
||
)
|
||
self._update_axis_visuals_for_scale(new_scale)
|
||
|
||
def _update_hover_highlight(self, mpos: Point3):
|
||
"""Highlight hovered handle during mouse move without dragging."""
|
||
self.picker_np.reparentTo(self.camera)
|
||
if not self._picker_added:
|
||
self.c_trav.addCollider(self.picker_np, self.c_queue)
|
||
self._picker_added = True
|
||
self.picker_ray.setFromLens(self.camera.node(), mpos.x, mpos.y)
|
||
|
||
self.c_queue.clearEntries()
|
||
self.c_trav.traverse(self.root)
|
||
|
||
num_entries = self.c_queue.getNumEntries()
|
||
if num_entries <= 0:
|
||
self._reset_highlights()
|
||
self.is_hovering = False
|
||
return
|
||
|
||
self.c_queue.sortEntries()
|
||
|
||
axis_entry = None
|
||
center_entry = None
|
||
for i in range(num_entries):
|
||
e = self.c_queue.getEntry(i)
|
||
if center_entry is None and e.getIntoNode().getTag("gizmo_center"):
|
||
center_entry = e
|
||
if axis_entry is None and e.getIntoNode().getTag("gizmo_axis"):
|
||
axis_entry = e
|
||
if center_entry and axis_entry:
|
||
break
|
||
|
||
if center_entry is not None:
|
||
self._highlight_center()
|
||
self.is_hovering = True
|
||
elif axis_entry is not None:
|
||
axis_tag: str = axis_entry.getIntoNode().getTag("gizmo_axis")
|
||
self._highlight_axis(int(axis_tag))
|
||
self.is_hovering = True
|
||
else:
|
||
self._reset_highlights()
|
||
self.is_hovering = False
|
||
|
||
def _highlight_axis(self, axis_id: Optional[int]):
|
||
"""高亮被选中的轴。"""
|
||
for i, ax in enumerate(self.axes):
|
||
if i == axis_id:
|
||
ax.setColor(1, 1, 0, 1)
|
||
ax.clearColorScale()
|
||
else:
|
||
ax.clearColor()
|
||
ax.setAlphaScale(0.3)
|
||
if self.center_handle:
|
||
self.center_handle.setAlphaScale(0.3)
|
||
|
||
def _highlight_center(self):
|
||
"""高亮中心控制柄。"""
|
||
for ax in self.axes:
|
||
ax.clearColor()
|
||
ax.setAlphaScale(0.3)
|
||
if self.center_handle:
|
||
self.center_handle.setColor(1, 1, 0, 1)
|
||
self.center_handle.clearColorScale()
|
||
|
||
def _reset_highlights(self):
|
||
"""重置所有高亮。"""
|
||
for ax in self.axes:
|
||
ax.clearColor()
|
||
ax.clearColorScale()
|
||
ax.setAlphaScale(self.axis_alpha)
|
||
if self.center_handle:
|
||
self.center_handle.clearColor()
|
||
self.center_handle.clearColorScale()
|
||
self.center_handle.setAlphaScale(self.axis_alpha)
|
||
|
||
# --- 可视轴动态长度 -------------------------------------------------
|
||
def _set_axis_visual_factor(self, axis_id: int, factor: float):
|
||
"""仅调整可视几何长度/末端大小，不改碰撞体。"""
|
||
if axis_id < 0 or axis_id >= len(self.axis_visuals):
|
||
return
|
||
info = self.axis_visuals[axis_id]
|
||
line = info.get("line")
|
||
cube = info.get("cube")
|
||
base_len = info.get("length", self._axis_length0)
|
||
base_cube = info.get("cube_size", self._cube_size0)
|
||
if line is None or cube is None:
|
||
return
|
||
factor = max(0.3, min(factor, 3.0))
|
||
line.setScale(1, 1, factor)
|
||
cube.setZ(base_len * factor)
|
||
cube.setScale(factor)
|
||
|
||
def _reset_axis_visuals(self):
|
||
"""恢复所有轴的可视长度/端点大小。"""
|
||
for i in range(len(self.axis_visuals)):
|
||
self._set_axis_visual_factor(i, 1.0)
|
||
|
||
def _update_axis_visuals_for_scale(self, new_scale: Vec3):
|
||
"""根据当前缩放比例动态调整可视轴长度。"""
|
||
if self.start_scale is None:
|
||
return
|
||
|
||
def safe_ratio(a: float, b: float) -> float:
|
||
return a / b if abs(b) > 1e-6 else 1.0
|
||
|
||
sx0, sy0, sz0 = self.start_scale
|
||
sx1, sy1, sz1 = new_scale
|
||
|
||
if self.drag_axis == 3:
|
||
ratios = []
|
||
if abs(sx0) > 1e-6:
|
||
ratios.append(sx1 / sx0)
|
||
if abs(sy0) > 1e-6:
|
||
ratios.append(sy1 / sy0)
|
||
if abs(sz0) > 1e-6:
|
||
ratios.append(sz1 / sz0)
|
||
if not ratios:
|
||
return
|
||
factor = sum(ratios) / len(ratios)
|
||
for i in range(3):
|
||
self._set_axis_visual_factor(i, factor)
|
||
elif self.drag_axis is not None and 0 <= self.drag_axis <= 2:
|
||
ratio = [safe_ratio(sx1, sx0), safe_ratio(sy1, sy0), safe_ratio(sz1, sz0)]
|
||
self._set_axis_visual_factor(self.drag_axis, ratio[self.drag_axis])
|
||
|
||
def update(self):
|
||
"""根据摄像机距离自动缩放 Gizmo。"""
|
||
if self.world.mouseWatcherNode.has_mouse():
|
||
current_mouse = LPoint2f(self.world.mouseWatcherNode.get_mouse())
|
||
if current_mouse != self.last_mouse_pos or self.last_mouse_pos is None:
|
||
self._on_mouse_move()
|
||
self.last_mouse_pos = current_mouse
|
||
|
||
if self.attached and self.camera:
|
||
self._update_root_transform()
|
||
dist = (
|
||
self.camera.getPos(self.world.render)
|
||
- self.root.getPos(self.world.render)
|
||
).length()
|
||
scale = dist * 0.15
|
||
self.root.setScale(self.world.render, scale)
|
||
|
||
def _update_task(self, task: Task):
|
||
"""每帧调用，用于持续更新 Gizmo 的缩放。"""
|
||
self.update()
|
||
return Task.cont
|
||
|
||
# ------------------------------------------------------------------ #
|
||
# 内部：跟随目标更新根节点变换
|
||
# ------------------------------------------------------------------ #
|
||
def _update_root_transform(self):
|
||
if not self.attached or not self.target_node:
|
||
return
|
||
render = self.world.render
|
||
tgt = self.target_node
|
||
self.root.setPos(render, tgt.getPos(render))
|
||
if self.is_local:
|
||
self.root.setQuat(render, tgt.getQuat(render))
|
||
else:
|
||
self.root.setQuat(render, Quat.identQuat())
|
||
|
||
|
||
__all__ = ["ScaleGizmo"]
|