""" VR摇杆交互系统模块 提供类似SteamVR的摇杆交互功能： - 摇杆左右转向（旋转视角） - 摇杆向前传送预览（抛物线轨迹） - 松开摇杆执行传送 - 死区处理和平滑控制 """ import math from panda3d.core import Vec2, Vec3, Vec4 from direct.showbase.DirectObject import DirectObject try: import openvr OPENVR_AVAILABLE = True except ImportError: OPENVR_AVAILABLE = False class VRJoystickManager(DirectObject): """VR摇杆管理器 - 处理手柄摇杆的转向和传送功能""" def __init__(self, vr_manager): """初始化VR摇杆管理器 Args: vr_manager: VR管理器实例 """ super().__init__() self.vr_manager = vr_manager self.teleport_system = None # 传送系统引用，稍后初始化 # 摇杆参数配置 self.deadzone = 0.15 # 摇杆死区 (0-1) self.turn_threshold = 0.3 # 转向激活阈值 self.teleport_threshold = 0.5 # 传送激活阈值 self.turn_sensitivity = 250.0 # 转向灵敏度（度/秒）- 增加速度 self.smooth_turning = True # 是否平滑转向 self.snap_turn_angle = 30.0 # 分段转向角度（度） # 摇杆状态跟踪 self.left_joystick_state = JoystickState() self.right_joystick_state = JoystickState() # 转向状态 self.left_turn_cooldown = 0.0 # 分段转向冷却时间 self.right_turn_cooldown = 0.0 self.snap_turn_cooldown = 0.3 # 分段转向间隔（秒） # 传送状态 self.active_teleport_controller = None # 正在传送的控制器 self.teleport_preview_active = False # 传送预览是否激活 # 互斥状态管理 - 防止同时触发多种操作 self.interaction_mode = 'none' # 当前交互模式: 'none', 'turning', 'teleporting' self.left_controller_mode = 'none' # 左手控制器状态 self.right_controller_mode = 'none' # 右手控制器状态 self.mode_lock_timeout = 0.1 # 模式锁定超时时间（秒） self.left_mode_timer = 0.0 # 左手模式计时器 self.right_mode_timer = 0.0 # 右手模式计时器 print("✓ VR摇杆管理器初始化完成") def initialize(self, teleport_system): """初始化摇杆系统 Args: teleport_system: VR传送系统实例 """ self.teleport_system = teleport_system print("✅ VR摇杆系统初始化成功") def update(self, dt): """更新摇杆系统 - 每帧调用 Args: dt: 帧间隔时间（秒） """ if not self.vr_manager.are_controllers_connected(): return # 调试计数器 if not hasattr(self, '_debug_frame_count'): self._debug_frame_count = 0 print("🎮 VR摇杆系统开始更新") self._debug_frame_count += 1 # 更新转向冷却时间 if self.left_turn_cooldown > 0: self.left_turn_cooldown -= dt if self.right_turn_cooldown > 0: self.right_turn_cooldown -= dt # 更新互斥状态计时器 self._update_interaction_modes(dt) # 处理左手控制器摇杆 if self.vr_manager.left_controller: self._update_controller_joystick( self.vr_manager.left_controller, self.left_joystick_state, 'left', dt ) # 处理右手控制器摇杆 if self.vr_manager.right_controller: self._update_controller_joystick( self.vr_manager.right_controller, self.right_joystick_state, 'right', dt ) # 每5秒输出一次状态报告 if self._debug_frame_count % 300 == 1: # 假设60fps self._print_debug_status() def _update_controller_joystick(self, controller, joystick_state, hand, dt): """更新单个控制器的摇杆状态 Args: controller: VR控制器实例 joystick_state: 摇杆状态对象 hand: 'left' 或 'right' dt: 帧间隔时间 """ # 获取摇杆输入 joystick_input = self._get_joystick_input(controller, hand) if joystick_input is None: return # 应用死区 filtered_input = self._apply_deadzone(joystick_input) # 更新摇杆状态 joystick_state.update(filtered_input) # 处理转向（左右移动） self._handle_turning(filtered_input, hand, dt) # 处理传送（向前移动） self._handle_teleport(controller, filtered_input, joystick_state, hand) def _update_interaction_modes(self, dt): """更新互斥交互模式状态""" # 更新左手模式计时器 if self.left_mode_timer > 0: self.left_mode_timer -= dt if self.left_mode_timer <= 0: self.left_controller_mode = 'none' # 更新右手模式计时器 if self.right_mode_timer > 0: self.right_mode_timer -= dt if self.right_mode_timer <= 0: self.right_controller_mode = 'none' # 更新全局交互模式 if self.left_controller_mode == 'none' and self.right_controller_mode == 'none': if self.interaction_mode != 'none': # 所有操作结束，恢复自由模式 self.interaction_mode = 'none' print("🔓 摇杆交互模式解锁，恢复自由操作") def _set_controller_mode(self, hand, mode): """设置控制器交互模式 Args: hand: 'left' 或 'right' mode: 'turning', 'teleporting', 'none' """ if hand == 'left': if self.left_controller_mode != mode: old_mode = self.left_controller_mode self.left_controller_mode = mode self.left_mode_timer = self.mode_lock_timeout if mode != 'none': print(f"🔒 左手控制器: {old_mode} → {mode}模式") else: print(f"🔓 左手控制器解锁: {old_mode} → 自由") else: if self.right_controller_mode != mode: old_mode = self.right_controller_mode self.right_controller_mode = mode self.right_mode_timer = self.mode_lock_timeout if mode != 'none': print(f"🔒 右手控制器: {old_mode} → {mode}模式") else: print(f"🔓 右手控制器解锁: {old_mode} → 自由") # 更新全局模式 if mode != 'none' and self.interaction_mode != mode: self.interaction_mode = mode def _can_use_mode(self, hand, requested_mode): """检查是否可以使用指定的交互模式 Args: hand: 'left' 或 'right' requested_mode: 'turning' 或 'teleporting' Returns: bool: 是否可以使用该模式 """ current_mode = self.left_controller_mode if hand == 'left' else self.right_controller_mode # 如果当前控制器已经是该模式，允许继续 if current_mode == requested_mode: return True # 如果当前控制器是空闲的，且全局模式兼容，允许切换 if current_mode == 'none': if self.interaction_mode == 'none' or self.interaction_mode == requested_mode: return True # 其他情况不允许 return False def _get_joystick_input(self, controller, hand): """获取摇杆输入 Args: controller: VR控制器实例 hand: 'left' 或 'right' Returns: Vec2: 摇杆位置 (x, y) 或 None """ # 直接从控制器读取摇杆输入（绕过动作系统） joystick_input = Vec2(0, 0) # 优先读取joystick_pos if hasattr(controller, 'joystick_pos') and controller.joystick_pos: joystick_input = Vec2(controller.joystick_pos.x, controller.joystick_pos.y) # 检查是否有有效输入 if joystick_input.length() > 0.01: # 调试输出 - 仅在有输入时显示 if not hasattr(self, '_last_debug_time'): self._last_debug_time = 0 self._debug_counter = 0 self._debug_counter += 1 # 每30帧输出一次调试信息 if self._debug_counter % 30 == 1: print(f"🎮 {hand}手摇杆输入: ({joystick_input.x:.3f}, {joystick_input.y:.3f})") return joystick_input # 备选方案：读取touchpad_pos（Quest等设备） if hasattr(controller, 'touchpad_pos') and controller.touchpad_pos: touchpad_input = Vec2(controller.touchpad_pos.x, controller.touchpad_pos.y) # 检查是否有有效输入 if touchpad_input.length() > 0.01: # 调试输出 - 仅在有输入时显示 if not hasattr(self, '_last_debug_time'): self._last_debug_time = 0 self._debug_counter = 0 self._debug_counter += 1 # 每30帧输出一次调试信息 if self._debug_counter % 30 == 1: print(f"🎮 {hand}手触摸板输入: ({touchpad_input.x:.3f}, {touchpad_input.y:.3f})") return touchpad_input # 可选：尝试从动作系统获取（如果可用） if (self.vr_manager.action_manager and hasattr(self.vr_manager.action_manager, 'get_analog_action_value')): try: device_path = f'/user/hand/{hand}' # 尝试摇杆 joystick_value, _ = self.vr_manager.action_manager.get_analog_action_value('joystick', device_path) if joystick_value is not None: return Vec2(joystick_value.x, joystick_value.y) # 尝试触摸板 trackpad_value, _ = self.vr_manager.action_manager.get_analog_action_value('trackpad', device_path) if trackpad_value is not None: return Vec2(trackpad_value.x, trackpad_value.y) except Exception: # 静默忽略动作系统错误 pass return Vec2(0, 0) def _apply_deadzone(self, input_vec): """应用摇杆死区 Args: input_vec: 原始摇杆输入 Returns: Vec2: 应用死区后的输入 """ magnitude = input_vec.length() if magnitude < self.deadzone: return Vec2(0, 0) # 重新映射到 [0, 1] 范围 normalized_magnitude = (magnitude - self.deadzone) / (1.0 - self.deadzone) normalized_magnitude = min(normalized_magnitude, 1.0) if magnitude > 0: direction = input_vec / magnitude return direction * normalized_magnitude return Vec2(0, 0) def _handle_turning(self, input_vec, hand, dt): """处理摇杆转向 Args: input_vec: 摇杆输入向量 hand: 'left' 或 'right' dt: 帧间隔时间 """ # 检查是否超过转向阈值 if abs(input_vec.x) < self.turn_threshold: # 没有转向输入，重置该控制器的转向模式 current_mode = self.left_controller_mode if hand == 'left' else self.right_controller_mode if current_mode == 'turning': self._set_controller_mode(hand, 'none') return # 检查是否可以使用转向模式 if not self._can_use_mode(hand, 'turning'): # 当前控制器被传送锁定，忽略转向输入 current_mode = self.left_controller_mode if hand == 'left' else self.right_controller_mode if current_mode != 'turning': print(f"⛔ {hand}手转向被阻止 - 当前模式: {current_mode}") return # 激活转向模式 self._set_controller_mode(hand, 'turning') # 检查冷却时间（分段转向） cooldown = self.left_turn_cooldown if hand == 'left' else self.right_turn_cooldown if self.smooth_turning: # 平滑转向 - 反转方向：摇杆右移(+x)应该向右转(-angle) turn_amount = -input_vec.x * self.turn_sensitivity * dt self._apply_rotation(turn_amount) # 调试输出转向 if not hasattr(self, '_turn_debug_counter'): self._turn_debug_counter = 0 self._turn_debug_counter += 1 if self._turn_debug_counter % 60 == 1: # 每秒输出一次 print(f"🔄 {hand}手转向: 输入={input_vec.x:.3f}, 角度={turn_amount:.1f}°") else: # 分段转向 if cooldown <= 0: # 反转方向：摇杆右移应该向右转 turn_amount = -self.snap_turn_angle if input_vec.x > 0 else self.snap_turn_angle self._apply_rotation(turn_amount) print(f"🔄 {hand}手分段转向: 输入={input_vec.x:.3f}, 角度={turn_amount:.1f}°") # 设置冷却时间 if hand == 'left': self.left_turn_cooldown = self.snap_turn_cooldown else: self.right_turn_cooldown = self.snap_turn_cooldown def _apply_rotation(self, angle_degrees): """应用旋转到VR跟踪空间 Args: angle_degrees: 旋转角度（度） """ if not self.vr_manager.tracking_space: return # 绕Z轴旋转（垂直轴） current_h = self.vr_manager.tracking_space.getH() new_h = current_h + angle_degrees self.vr_manager.tracking_space.setH(new_h) def _handle_teleport(self, controller, input_vec, joystick_state, hand): """处理摇杆传送 Args: controller: VR控制器实例 input_vec: 摇杆输入向量 joystick_state: 摇杆状态对象 hand: 'left' 或 'right' """ # 检查Y轴向前移动是否超过阈值 forward_input = input_vec.y if forward_input > self.teleport_threshold: # 检查是否可以使用传送模式 if not self._can_use_mode(hand, 'teleporting'): # 当前控制器被转向锁定，忽略传送输入 current_mode = self.left_controller_mode if hand == 'left' else self.right_controller_mode if current_mode != 'teleporting': print(f"⛔ {hand}手传送被阻止 - 当前模式: {current_mode}") return # 激活传送模式 self._set_controller_mode(hand, 'teleporting') # 开始或更新传送预览 if not joystick_state.teleport_active: joystick_state.teleport_active = True self.active_teleport_controller = controller self.teleport_preview_active = True # 触发震动反馈 controller.trigger_haptic_feedback(0.002, 0.3) # 计算传送方向 direction = self._calculate_teleport_direction(controller, input_vec) # 更新传送预览 if self.teleport_system: if joystick_state.teleport_just_started: self.teleport_system.start_teleport_preview(controller, direction) joystick_state.teleport_just_started = False else: self.teleport_system.update_teleport_preview(controller, direction) else: # 检查是否需要执行传送 if joystick_state.teleport_active: # 松开摇杆，执行传送 self._execute_teleport(controller) joystick_state.teleport_active = False joystick_state.teleport_just_started = True # 重置该控制器的传送模式 self._set_controller_mode(hand, 'none') else: # 没有传送输入，检查是否需要重置传送模式 current_mode = self.left_controller_mode if hand == 'left' else self.right_controller_mode if current_mode == 'teleporting': self._set_controller_mode(hand, 'none') def _calculate_teleport_direction(self, controller, input_vec): """计算传送方向向量 - 基于手柄姿态 Args: controller: VR控制器实例 input_vec: 摇杆输入向量（仅用于激活，不影响方向） Returns: Vec3: 世界坐标中的传送方向 """ # 方法1：直接使用手柄指向（推荐） if controller and hasattr(controller, 'get_forward_direction'): try: # 获取手柄的前向方向 controller_forward = controller.get_forward_direction() # 确保方向向量在水平面上 horizontal_direction = Vec3(controller_forward.x, controller_forward.y, 0) if horizontal_direction.length() > 0: horizontal_direction.normalize() # 调试输出（每30帧输出一次） if not hasattr(self, '_direction_debug_counter'): self._direction_debug_counter = 0 self._direction_debug_counter += 1 if self._direction_debug_counter % 30 == 1: # 获取当前tracking_space的旋转角度用于调试 tracking_rotation = 0 if self.vr_manager.tracking_space: tracking_rotation = self.vr_manager.tracking_space.getH() print(f"🎯 综合传送方向: 视角旋转({tracking_rotation:.1f}°) + 手柄姿态({controller_forward.x:.2f},{controller_forward.y:.2f},{controller_forward.z:.2f}) → 最终方向({horizontal_direction.x:.2f},{horizontal_direction.y:.2f})") return horizontal_direction except Exception as e: print(f"⚠️ 获取手柄方向失败: {e}") # 备选方案：使用玩家朝向（保留原逻辑作为备选） print("🔄 使用备选传送方向计算...") # 获取玩家当前朝向的变换矩阵 player_transform = None # 优先使用头显的世界变换 if self.vr_manager.hmd_anchor and hasattr(self.vr_manager, 'world') and self.vr_manager.world: player_transform = self.vr_manager.hmd_anchor.getMat(self.vr_manager.world.render) # 备选：使用tracking_space的世界变换 elif self.vr_manager.tracking_space and hasattr(self.vr_manager, 'world') and self.vr_manager.world: player_transform = self.vr_manager.tracking_space.getMat(self.vr_manager.world.render) if player_transform: # 从变换矩阵提取前向向量 forward = Vec3(player_transform.getRow3(1)) # Y轴 = 前向 # 确保向量在水平面上 forward.z = 0 if forward.length() > 0: forward.normalize() return forward # 最终备选方案：默认前向 print("⚠️ 无法获取任何朝向，使用默认方向") return Vec3(0, 1, 0) def _execute_teleport(self, controller): """执行传送 Args: controller: VR控制器实例 """ if self.teleport_system and self.teleport_preview_active: success = self.teleport_system.execute_teleport() if success: # 传送成功，触发震动反馈 controller.trigger_haptic_feedback(0.005, 0.8) else: # 传送失败，触发不同的震动反馈 controller.trigger_haptic_feedback(0.001, 0.2) # 停止传送预览 self.teleport_system.stop_teleport_preview() self.teleport_preview_active = False self.active_teleport_controller = None def set_turning_mode(self, smooth=True): """设置转向模式 Args: smooth: True为平滑转向，False为分段转向 """ self.smooth_turning = smooth print(f"✓ 转向模式设置为: {'平滑转向' if smooth else '分段转向'}") def set_turn_sensitivity(self, sensitivity): """设置转向灵敏度 Args: sensitivity: 转向灵敏度（度/秒） """ self.turn_sensitivity = max(10.0, min(180.0, sensitivity)) print(f"✓ 转向灵敏度设置为: {self.turn_sensitivity}度/秒") def apply_config(self, config): """应用配置 Args: config: VRJoystickConfig配置实例 """ try: self.deadzone = config.deadzone self.turn_threshold = config.turn_threshold self.teleport_threshold = config.teleport_threshold self.turn_sensitivity = config.turn_sensitivity self.smooth_turning = (config.turn_mode.value == 'smooth') self.snap_turn_angle = config.snap_turn_angle self.snap_turn_cooldown = config.snap_turn_cooldown # 应用传送系统配置 if self.teleport_system and hasattr(config, 'teleport_range'): self.teleport_system.teleport_range = config.teleport_range if hasattr(config, 'teleport_arc_resolution'): self.teleport_system.arc_resolution = config.teleport_arc_resolution if hasattr(config, 'teleport_initial_velocity'): self.teleport_system.initial_velocity = config.teleport_initial_velocity if hasattr(config, 'min_teleport_distance'): self.teleport_system.min_teleport_distance = config.min_teleport_distance print("✅ 摇杆配置已成功应用") except Exception as e: print(f"⚠️ 应用配置失败: {e}") def get_current_config(self): """获取当前配置 Returns: dict: 当前配置参数 """ return { 'deadzone': self.deadzone, 'turn_threshold': self.turn_threshold, 'teleport_threshold': self.teleport_threshold, 'turn_sensitivity': self.turn_sensitivity, 'smooth_turning': self.smooth_turning, 'snap_turn_angle': self.snap_turn_angle, 'snap_turn_cooldown': self.snap_turn_cooldown } def _print_debug_status(self): """打印调试状态信息""" try: print("🔍 ======= VR摇杆调试状态 =======") # 控制器连接状态 left_connected = self.vr_manager.left_controller is not None right_connected = self.vr_manager.right_controller is not None print(f"📱 控制器状态: 左手={left_connected}, 右手={right_connected}") # 检查控制器属性 if left_connected: left_ctrl = self.vr_manager.left_controller has_joystick = hasattr(left_ctrl, 'joystick_pos') has_touchpad = hasattr(left_ctrl, 'touchpad_pos') print(f"📊 左手控制器: joystick_pos={has_joystick}, touchpad_pos={has_touchpad}") if has_joystick and left_ctrl.joystick_pos: pos = left_ctrl.joystick_pos print(f" 当前摇杆位置: ({pos.x:.3f}, {pos.y:.3f}, {pos.z:.3f})") if has_touchpad and left_ctrl.touchpad_pos: pos = left_ctrl.touchpad_pos print(f" 当前触摸板位置: ({pos.x:.3f}, {pos.y:.3f}, {pos.z:.3f})") if right_connected: right_ctrl = self.vr_manager.right_controller has_joystick = hasattr(right_ctrl, 'joystick_pos') has_touchpad = hasattr(right_ctrl, 'touchpad_pos') print(f"📊 右手控制器: joystick_pos={has_joystick}, touchpad_pos={has_touchpad}") if has_joystick and right_ctrl.joystick_pos: pos = right_ctrl.joystick_pos print(f" 当前摇杆位置: ({pos.x:.3f}, {pos.y:.3f}, {pos.z:.3f})") if has_touchpad and right_ctrl.touchpad_pos: pos = right_ctrl.touchpad_pos print(f" 当前触摸板位置: ({pos.x:.3f}, {pos.y:.3f}, {pos.z:.3f})") # 摇杆配置 print(f"⚙️ 摇杆配置:") print(f" 死区: {self.deadzone}") print(f" 转向阈值: {self.turn_threshold}") print(f" 传送阈值: {self.teleport_threshold}") print(f" 转向模式: {'平滑' if self.smooth_turning else '分段'}") # 动作系统状态 action_mgr_available = (self.vr_manager.action_manager is not None) print(f"🎯 动作系统: {'可用' if action_mgr_available else '不可用'}") # 传送系统状态 teleport_available = (self.teleport_system is not None) print(f"🚀 传送系统: {'可用' if teleport_available else '不可用'}") print("🔍 ==============================") except Exception as e: print(f"⚠️ 调试状态输出失败: {e}") def cleanup(self): """清理摇杆系统资源""" try: # 停止任何活跃的传送预览 if self.teleport_preview_active and self.teleport_system: self.teleport_system.stop_teleport_preview() self.teleport_preview_active = False self.active_teleport_controller = None self.ignoreAll() print("🧹 VR摇杆系统已清理") except Exception as e: print(f"⚠️ 清理摇杆系统失败: {e}") class JoystickState: """摇杆状态跟踪类""" def __init__(self): self.current_input = Vec2(0, 0) # 当前摇杆输入 self.previous_input = Vec2(0, 0) # 上一帧摇杆输入 self.teleport_active = False # 传送是否激活 self.teleport_just_started = True # 传送是否刚开始 def update(self, new_input): """更新摇杆状态 Args: new_input: 新的摇杆输入 """ self.previous_input = Vec2(self.current_input) self.current_input = Vec2(new_input) def is_input_changed(self, threshold=0.01): """检查输入是否发生变化 Args: threshold: 变化阈值 Returns: bool: 是否发生变化 """ diff = self.current_input - self.previous_input return diff.length() > threshold