1283 lines
54 KiB
Python
1283 lines
54 KiB
Python
import os
|
||
|
||
from imgui_bundle import imgui
|
||
from direct.showbase.ShowBaseGlobal import globalClock
|
||
from direct.task.TaskManagerGlobal import taskMgr
|
||
from panda3d.core import WindowProperties
|
||
|
||
|
||
class AppActions:
|
||
"""Project, input, messaging, edit actions, and import workflows."""
|
||
|
||
def __init__(self, app):
|
||
self.app = app
|
||
|
||
def __getattr__(self, name):
|
||
return getattr(self.app, name)
|
||
|
||
def __setattr__(self, name, value):
|
||
if name == "app" or name in self.__dict__ or hasattr(type(self), name):
|
||
object.__setattr__(self, name, value)
|
||
else:
|
||
setattr(self.app, name, value)
|
||
|
||
def _resolve_cut_copy_node(self, node):
|
||
"""Resolve selection to a stable scene root for copy/cut/paste."""
|
||
if not node or node.isEmpty():
|
||
return node
|
||
|
||
current = node
|
||
while current and not current.isEmpty():
|
||
if current.getName() == "render":
|
||
break
|
||
if current.hasTag("tree_item_type") or current.hasTag("is_model_root") or current.hasTag("is_scene_element"):
|
||
return current
|
||
current = current.getParent()
|
||
|
||
return node
|
||
|
||
|
||
def _toggle_hot_reload(self):
|
||
"""切换热重载状态"""
|
||
if hasattr(self, 'script_manager') and self.script_manager:
|
||
try:
|
||
current_state = getattr(self.script_manager, 'hot_reload_enabled', False)
|
||
self.script_manager.hot_reload_enabled = not current_state
|
||
|
||
new_state = "启用" if not current_state else "禁用"
|
||
self.add_success_message(f"热重载已{new_state}")
|
||
print(f"[脚本系统] 热重载已{new_state}")
|
||
except Exception as e:
|
||
self.add_error_message(f"切换热重载失败: {str(e)}")
|
||
print(f"[脚本系统] 切换热重载失败: {e}")
|
||
|
||
|
||
def _create_new_script(self):
|
||
"""创建新脚本"""
|
||
if not hasattr(self, '_new_script_name') or not self._new_script_name.strip():
|
||
self.add_error_message("请输入脚本名称")
|
||
return
|
||
|
||
script_name = self._new_script_name.strip()
|
||
if not script_name.endswith('.py'):
|
||
script_name += '.py'
|
||
|
||
# 确定模板类型
|
||
template_map = {
|
||
0: "basic",
|
||
1: "movement",
|
||
2: "rotation",
|
||
3: "scale",
|
||
4: "animation"
|
||
}
|
||
template_type = template_map.get(getattr(self, '_selected_template', 0), "basic")
|
||
|
||
try:
|
||
if hasattr(self, 'script_manager') and self.script_manager:
|
||
result = self.script_manager.create_script_file(script_name, template_type)
|
||
if result:
|
||
self.add_success_message(f"脚本 {script_name} 创建成功")
|
||
print(f"[脚本系统] 创建脚本成功: {script_name}")
|
||
# 刷新脚本列表
|
||
self._refresh_scripts_list()
|
||
else:
|
||
self.add_error_message(f"脚本 {script_name} 创建失败")
|
||
else:
|
||
self.add_error_message("脚本管理器未初始化")
|
||
except Exception as e:
|
||
self.add_error_message(f"创建脚本失败: {str(e)}")
|
||
print(f"[脚本系统] 创建脚本失败: {e}")
|
||
|
||
|
||
def _refresh_scripts_list(self):
|
||
"""刷新脚本列表"""
|
||
try:
|
||
if hasattr(self, 'script_manager') and self.script_manager:
|
||
# 这里可以添加缓存逻辑，避免频繁刷新
|
||
available_scripts = self.script_manager.get_available_scripts()
|
||
print(f"[脚本系统] 刷新脚本列表: {len(available_scripts)} 个脚本")
|
||
self.add_success_message(f"脚本列表已刷新，共 {len(available_scripts)} 个脚本")
|
||
else:
|
||
self.add_error_message("脚本管理器未初始化")
|
||
except Exception as e:
|
||
self.add_error_message(f"刷新脚本列表失败: {str(e)}")
|
||
print(f"[脚本系统] 刷新脚本列表失败: {e}")
|
||
|
||
|
||
def _reload_all_scripts(self):
|
||
"""重载所有脚本"""
|
||
try:
|
||
if hasattr(self, 'script_manager') and self.script_manager:
|
||
# 获取所有可用脚本并逐个重载
|
||
available_scripts = self.script_manager.get_available_scripts()
|
||
success_count = 0
|
||
|
||
for script_name in available_scripts:
|
||
if self.script_manager.reload_script(script_name):
|
||
success_count += 1
|
||
|
||
self.add_success_message(f"重载完成: {success_count}/{len(available_scripts)} 个脚本成功")
|
||
print(f"[脚本系统] 重载脚本: {success_count}/{len(available_scripts)} 成功")
|
||
else:
|
||
self.add_error_message("脚本管理器未初始化")
|
||
except Exception as e:
|
||
self.add_error_message(f"重载脚本失败: {str(e)}")
|
||
print(f"[脚本系统] 重载脚本失败: {e}")
|
||
|
||
|
||
def _on_script_selected(self, script_name):
|
||
"""处理脚本选择事件"""
|
||
print(f"[脚本系统] 选择脚本: {script_name}")
|
||
self.add_info_message(f"已选择脚本: {script_name}")
|
||
|
||
|
||
def _edit_script(self, script_name):
|
||
"""编辑脚本"""
|
||
try:
|
||
if hasattr(self, 'script_manager') and self.script_manager:
|
||
# 获取脚本信息
|
||
script_info = self.script_manager.get_script_info(script_name)
|
||
if script_info and script_info.get("file"):
|
||
script_path = script_info["file"]
|
||
|
||
# 打开系统默认编辑器
|
||
import subprocess
|
||
import platform
|
||
|
||
system = platform.system()
|
||
try:
|
||
if system == "Windows":
|
||
subprocess.run(['notepad', script_path])
|
||
elif system == "Darwin": # macOS
|
||
subprocess.run(['open', script_path])
|
||
else: # Linux
|
||
subprocess.run(['xdg-open', script_path])
|
||
|
||
self.add_success_message(f"已打开脚本编辑器: {script_name}")
|
||
print(f"[脚本系统] 编辑脚本: {script_path}")
|
||
except Exception as e:
|
||
self.add_error_message(f"打开编辑器失败: {str(e)}")
|
||
else:
|
||
self.add_error_message(f"找不到脚本文件: {script_name}")
|
||
else:
|
||
self.add_error_message("脚本管理器未初始化")
|
||
except Exception as e:
|
||
self.add_error_message(f"编辑脚本失败: {str(e)}")
|
||
print(f"[脚本系统] 编辑脚本失败: {e}")
|
||
|
||
|
||
def _mount_script_to_selected(self, script_name):
|
||
"""挂载脚本到选中对象"""
|
||
selected_node = None
|
||
if hasattr(self, 'selection') and self.selection and hasattr(self.selection, 'selectedNode'):
|
||
selected_node = self.selection.selectedNode
|
||
|
||
if not selected_node or selected_node.isEmpty():
|
||
self.add_error_message("请先选择一个对象")
|
||
return
|
||
|
||
try:
|
||
if hasattr(self, 'script_manager') and self.script_manager:
|
||
script_component = self.script_manager.add_script_to_object(selected_node, script_name)
|
||
if script_component:
|
||
self.add_success_message(f"脚本 {script_name} 已挂载到 {selected_node.getName()}")
|
||
print(f"[脚本系统] 挂载脚本: {script_name} -> {selected_node.getName()}")
|
||
else:
|
||
self.add_error_message(f"挂载脚本 {script_name} 失败")
|
||
else:
|
||
self.add_error_message("脚本管理器未初始化")
|
||
except Exception as e:
|
||
self.add_error_message(f"挂载脚本失败: {str(e)}")
|
||
print(f"[脚本系统] 挂载脚本失败: {e}")
|
||
|
||
|
||
def _unmount_script_from_selected(self, script_name):
|
||
"""从选中对象卸载脚本"""
|
||
selected_node = None
|
||
if hasattr(self, 'selection') and self.selection and hasattr(self.selection, 'selectedNode'):
|
||
selected_node = self.selection.selectedNode
|
||
|
||
if not selected_node or selected_node.isEmpty():
|
||
self.add_error_message("请先选择一个对象")
|
||
return
|
||
|
||
try:
|
||
if hasattr(self, 'script_manager') and self.script_manager:
|
||
result = self.script_manager.remove_script_from_object(selected_node, script_name)
|
||
if result:
|
||
self.add_success_message(f"脚本 {script_name} 已从 {selected_node.getName()} 卸载")
|
||
print(f"[脚本系统] 卸载脚本: {script_name} <- {selected_node.getName()}")
|
||
else:
|
||
self.add_error_message(f"卸载脚本 {script_name} 失败")
|
||
else:
|
||
self.add_error_message("脚本管理器未初始化")
|
||
except Exception as e:
|
||
self.add_error_message(f"卸载脚本失败: {str(e)}")
|
||
print(f"[脚本系统] 卸载脚本失败: {e}")
|
||
|
||
# ==================== 菜单处理函数 ====================
|
||
|
||
|
||
def _on_new_project(self):
|
||
"""处理新建项目菜单项"""
|
||
self.add_info_message("打开新建项目对话框")
|
||
self.show_new_project_dialog = True
|
||
|
||
|
||
def _on_open_project(self):
|
||
"""处理打开项目菜单项"""
|
||
self.add_info_message("打开项目对话框")
|
||
self.show_open_project_dialog = True
|
||
|
||
|
||
def _on_save_project(self):
|
||
"""处理保存项目菜单项"""
|
||
if hasattr(self, 'project_manager') and self.project_manager:
|
||
try:
|
||
# 检查是否有当前项目路径
|
||
if not self.project_manager.current_project_path:
|
||
self.add_warning_message("没有当前项目路径，请先创建或打开项目")
|
||
self.show_save_as_dialog = True
|
||
return
|
||
|
||
# 直接调用保存逻辑，避免Qt依赖
|
||
if self._save_project_impl():
|
||
self.add_success_message("项目保存成功")
|
||
else:
|
||
self.add_error_message("项目保存失败")
|
||
except Exception as e:
|
||
self.add_error_message(f"项目保存失败: {e}")
|
||
else:
|
||
self.add_error_message("项目管理器未初始化")
|
||
|
||
|
||
def _on_save_as_project(self):
|
||
"""处理另存为项目菜单项"""
|
||
self.add_info_message("另存为项目（功能待实现）")
|
||
# TODO: 实现另存为对话框
|
||
# self.show_save_as_dialog = True
|
||
|
||
def _on_build_webgl_package(self):
|
||
"""处理“打包为 WebGL”菜单项。"""
|
||
if not hasattr(self, "project_manager") or not self.project_manager:
|
||
self.add_error_message("项目管理器未初始化")
|
||
return
|
||
|
||
if not self.project_manager.current_project_path:
|
||
self.add_warning_message("请先创建或打开项目，再进行WebGL打包")
|
||
return
|
||
|
||
# 导出前先保存当前项目
|
||
if not self._save_project_impl():
|
||
self.add_error_message("打包前自动保存失败，已取消WebGL打包")
|
||
return
|
||
|
||
current_project_path = self.project_manager.current_project_path
|
||
initial_dir = os.path.dirname(current_project_path) if current_project_path else os.getcwd()
|
||
selected_dir = self._select_directory_system_dialog("选择 WebGL 打包输出目录", initial_dir)
|
||
if not selected_dir:
|
||
dialog_error = getattr(self, "_last_directory_dialog_error", "")
|
||
if dialog_error:
|
||
# Fallback: when system dialog is unavailable (e.g. missing tkinter),
|
||
# reuse the built-in path browser so user can still choose directory.
|
||
self.add_warning_message(f"系统目录选择器不可用: {dialog_error}")
|
||
self.path_browser_mode = "webgl_build"
|
||
self.path_browser_current_path = initial_dir if os.path.isdir(initial_dir) else os.getcwd()
|
||
self.path_browser_selected_path = self.path_browser_current_path
|
||
self.show_path_browser = True
|
||
self._pending_webgl_package = True
|
||
self._refresh_path_browser()
|
||
self.add_info_message("已切换到内置路径浏览器，请选择输出目录并点击确定")
|
||
else:
|
||
self.add_info_message("已取消WebGL打包")
|
||
return
|
||
|
||
self._execute_webgl_package(selected_dir)
|
||
|
||
def _execute_webgl_package(self, selected_dir):
|
||
"""执行WebGL打包并输出消息。"""
|
||
ok = self.project_manager.buildWebGLPackage(selected_dir)
|
||
report = getattr(self.project_manager, "last_webgl_export_report", None) or {}
|
||
status = report.get("status", "failed")
|
||
out_dir = report.get("output_dir", "")
|
||
report_path = os.path.join(out_dir, "reports", "export_report.json") if out_dir else ""
|
||
|
||
if ok:
|
||
missing_count = len(report.get("missing_assets", []))
|
||
unsupported_count = len(report.get("unsupported_assets", []))
|
||
if status == "partial":
|
||
self.add_warning_message(
|
||
f"WebGL打包部分成功: 缺失资源 {missing_count}，不支持资源 {unsupported_count}"
|
||
)
|
||
else:
|
||
self.add_success_message("WebGL打包成功")
|
||
|
||
if out_dir:
|
||
self.add_info_message(f"输出目录: {out_dir}")
|
||
if report_path:
|
||
self.add_info_message(f"报告: {report_path}")
|
||
else:
|
||
self.add_error_message("WebGL打包失败")
|
||
if report_path:
|
||
self.add_warning_message(f"请检查报告: {report_path}")
|
||
|
||
|
||
def _on_exit(self):
|
||
"""处理退出菜单项"""
|
||
self.add_info_message("退出应用程序")
|
||
self.userExit()
|
||
|
||
def _select_directory_system_dialog(self, title, initial_dir=""):
|
||
"""打开系统目录选择器并返回目录路径。"""
|
||
self._last_directory_dialog_error = ""
|
||
try:
|
||
import tkinter as tk
|
||
from tkinter import filedialog
|
||
|
||
if not initial_dir or (not os.path.isdir(initial_dir)):
|
||
initial_dir = os.getcwd()
|
||
|
||
root = tk.Tk()
|
||
root.withdraw()
|
||
try:
|
||
root.attributes("-topmost", True)
|
||
except Exception:
|
||
pass
|
||
|
||
selected = filedialog.askdirectory(
|
||
title=title or "选择目录",
|
||
initialdir=initial_dir,
|
||
mustexist=True,
|
||
)
|
||
root.destroy()
|
||
return os.path.normpath(selected) if selected else ""
|
||
except Exception as e:
|
||
print(f"目录选择器打开失败: {e}")
|
||
self._last_directory_dialog_error = str(e)
|
||
return ""
|
||
|
||
# ==================== 键盘事件处理函数 ====================
|
||
|
||
|
||
def _on_ctrl_pressed(self):
|
||
"""Ctrl键按下"""
|
||
self.ctrl_pressed = True
|
||
|
||
|
||
def _on_ctrl_released(self):
|
||
"""Ctrl键释放"""
|
||
self.ctrl_pressed = False
|
||
|
||
|
||
def _on_alt_pressed(self):
|
||
"""Alt键按下"""
|
||
self.alt_pressed = True
|
||
|
||
|
||
def _on_alt_released(self):
|
||
"""Alt键释放"""
|
||
self.alt_pressed = False
|
||
|
||
|
||
def _on_n_pressed(self):
|
||
"""N键按下 - 检查Ctrl+N组合键"""
|
||
if self.ctrl_pressed:
|
||
self._on_new_project()
|
||
|
||
|
||
def _on_o_pressed(self):
|
||
"""O键按下 - 检查Ctrl+O组合键"""
|
||
if self.ctrl_pressed:
|
||
self._on_open_project()
|
||
|
||
|
||
|
||
|
||
def _on_f4_pressed(self):
|
||
"""F4键按下 - 检查Alt+F4组合键"""
|
||
if self.alt_pressed:
|
||
self._on_exit()
|
||
|
||
# 移除了单独的按键处理方法，现在直接使用组合键事件
|
||
|
||
|
||
def _on_delete_pressed(self):
|
||
"""Delete键按下 - 删除选中节点"""
|
||
self._on_delete()
|
||
|
||
def _on_escape_pressed(self):
|
||
"""Escape键按下 - 取消所有选区"""
|
||
# 1. 取消 LUI 组件选择
|
||
if hasattr(self, 'lui_manager'):
|
||
if self.lui_manager.selected_index >= 0:
|
||
self.lui_manager.selected_index = -1
|
||
print("✓ 已取消LUI组件选中")
|
||
|
||
# 2. 取消 3D 场景选择
|
||
if hasattr(self, 'selection') and self.selection:
|
||
if self.selection.selectedNode:
|
||
self.selection.selectedNode = None
|
||
self.selection.clearSelectionBox()
|
||
self.selection.clearGizmo()
|
||
print("✓ 已取消场景节点选中")
|
||
|
||
|
||
def _on_wheel_up(self):
|
||
"""滚轮向上滚动 - 相机前进"""
|
||
try:
|
||
if not self.camera_control_enabled:
|
||
return
|
||
|
||
# 检查鼠标是否在ImGui窗口上
|
||
if self._is_mouse_over_imgui():
|
||
return
|
||
|
||
# 沿相机前向向量移动
|
||
forward = self.camera.getMat().getRow3(1)
|
||
distance = 20.0 * globalClock.getDt()
|
||
currentPos = self.camera.getPos()
|
||
newPos = currentPos + forward * distance
|
||
self.camera.setPos(newPos)
|
||
except Exception as e:
|
||
print(f"滚轮前进失败: {e}")
|
||
|
||
|
||
def _on_wheel_down(self):
|
||
"""滚轮向下滚动 - 相机后退"""
|
||
try:
|
||
# 检查鼠标是否在ImGui窗口上
|
||
if self._is_mouse_over_imgui():
|
||
return
|
||
|
||
# 沿相机前向向量移动
|
||
forward = self.camera.getMat().getRow3(1)
|
||
distance = -20.0 * globalClock.getDt()
|
||
currentPos = self.camera.getPos()
|
||
newPos = currentPos + forward * distance
|
||
self.camera.setPos(newPos)
|
||
except Exception as e:
|
||
print(f"滚轮后退失败: {e}")
|
||
|
||
|
||
def _is_mouse_over_imgui(self):
|
||
"""检测鼠标是否在ImGui窗口上"""
|
||
try:
|
||
# 检查是否有任何ImGui窗口想要捕获鼠标
|
||
if hasattr(imgui, 'get_io') and imgui.get_io().want_capture_mouse:
|
||
return True
|
||
|
||
# 检查鼠标是否在任何ImGui窗口内
|
||
mouse_pos = self.mouseWatcherNode.getMouse()
|
||
if not mouse_pos:
|
||
return False
|
||
|
||
# 简单的边界检查（可以根据需要扩展）
|
||
display_size = imgui.get_io().display_size
|
||
mouse_x = mouse_pos.get_x() * display_size.x / 2 + display_size.x / 2
|
||
mouse_y = display_size.y - (mouse_pos.get_y() * display_size.y / 2 + display_size.y / 2)
|
||
|
||
# 检查是否在常见的ImGui界面区域内
|
||
# 这里可以根据实际的ImGui窗口位置进行更精确的检测
|
||
if mouse_x < 300 and mouse_y < 200: # 左上角区域（菜单栏）
|
||
return True
|
||
if mouse_x < 300 and mouse_y > display_size.y - 200: # 左下角区域（工具栏）
|
||
return True
|
||
if mouse_x > display_size.x - 300 and mouse_y < 200: # 右上角区域
|
||
return True
|
||
|
||
return False
|
||
except Exception as e:
|
||
print(f"ImGui界面检测失败: {e}")
|
||
return False
|
||
|
||
|
||
def processImGuiMouseClick(self, x, y):
|
||
"""处理ImGui鼠标点击事件，返回是否消费了该事件"""
|
||
try:
|
||
# ImGui优先策略：如果ImGui想要捕获鼠标，则由ImGui处理
|
||
if hasattr(imgui, 'get_io') and imgui.get_io().want_capture_mouse:
|
||
return True
|
||
|
||
# 检查是否有任何ImGui窗口悬停
|
||
try:
|
||
if imgui.is_any_window_hovered():
|
||
return True
|
||
except AttributeError:
|
||
# 如果方法不存在，跳过这个检查
|
||
pass
|
||
|
||
# 检查鼠标是否在ImGui界面区域内
|
||
if self._is_mouse_over_imgui():
|
||
return True
|
||
|
||
# 如果以上条件都不满足，则让3D场景处理该事件
|
||
return False
|
||
|
||
except Exception as e:
|
||
print(f"ImGui鼠标点击处理失败: {e}")
|
||
return False
|
||
|
||
# ==================== 消息系统 ====================
|
||
|
||
|
||
def add_message(self, text, color=(1.0, 1.0, 1.0, 1.0)):
|
||
"""添加消息到消息列表，同时输出到终端"""
|
||
import datetime
|
||
timestamp = datetime.datetime.now().strftime("%H:%M:%S")
|
||
|
||
# 输出到终端
|
||
print(f"[{timestamp}] {text}")
|
||
|
||
# 添加到GUI消息列表
|
||
self.messages.append({
|
||
'text': text,
|
||
'color': color,
|
||
'timestamp': timestamp
|
||
})
|
||
|
||
# 限制消息数量
|
||
if len(self.messages) > self.max_messages:
|
||
self.messages = self.messages[-self.max_messages:]
|
||
|
||
|
||
def add_success_message(self, text):
|
||
"""添加成功消息"""
|
||
self.add_message(f"✓ {text}", (0.176, 1.0, 0.769, 1.0))
|
||
|
||
|
||
def add_error_message(self, text):
|
||
"""添加错误消息"""
|
||
self.add_message(f"✗ {text}", (1.0, 0.3, 0.3, 1.0))
|
||
|
||
|
||
def add_warning_message(self, text):
|
||
"""添加警告消息"""
|
||
self.add_message(f"⚠ {text}", (0.953, 0.616, 0.471, 1.0))
|
||
|
||
|
||
def add_info_message(self, text):
|
||
"""添加信息消息"""
|
||
self.add_message(f"ℹ {text}", (0.157, 0.620, 1.0, 1.0))
|
||
|
||
# ==================== 编辑菜单功能实现 ====================
|
||
|
||
|
||
def _on_undo(self):
|
||
"""处理撤销操作"""
|
||
try:
|
||
# 1) 优先使用命令系统（删除/创建等命令）
|
||
if hasattr(self, 'command_manager') and self.command_manager and self.command_manager.can_undo():
|
||
success = self.command_manager.undo()
|
||
if success:
|
||
self.add_success_message("撤销操作成功")
|
||
return
|
||
self.add_error_message("撤销操作失败")
|
||
return
|
||
|
||
# 2) 回退到 TransformGizmo 历史（拖拽位移/旋转/缩放）
|
||
tg = getattr(self, 'newTransform', None)
|
||
if tg and hasattr(tg, 'undo_last') and tg.undo_last():
|
||
self.add_success_message("撤销操作成功")
|
||
return
|
||
|
||
self.add_warning_message("没有可撤销的操作")
|
||
except Exception as e:
|
||
self.add_error_message(f"撤销操作失败: {e}")
|
||
|
||
|
||
def _on_redo(self):
|
||
"""处理重做操作"""
|
||
try:
|
||
# 1) 优先使用命令系统
|
||
if hasattr(self, 'command_manager') and self.command_manager and self.command_manager.can_redo():
|
||
success = self.command_manager.redo()
|
||
if success:
|
||
self.add_success_message("重做操作成功")
|
||
return
|
||
self.add_error_message("重做操作失败")
|
||
return
|
||
|
||
# 2) 回退到 TransformGizmo 重做栈
|
||
tg = getattr(self, 'newTransform', None)
|
||
if tg and hasattr(tg, 'redo_last') and tg.redo_last():
|
||
self.add_success_message("重做操作成功")
|
||
return
|
||
|
||
self.add_warning_message("没有可重做的操作")
|
||
except Exception as e:
|
||
self.add_error_message(f"重做操作失败: {e}")
|
||
|
||
|
||
def _on_copy(self):
|
||
"""处理复制操作"""
|
||
try:
|
||
if not hasattr(self, 'selection') or not self.selection:
|
||
self.add_error_message("选择系统未初始化")
|
||
return
|
||
|
||
# 获取当前选中的节点
|
||
selected_node = self._resolve_cut_copy_node(self.selection.selectedNode)
|
||
if not selected_node:
|
||
self.add_warning_message("没有选中的节点")
|
||
return
|
||
|
||
# 检查节点有效性（不能复制根节点）
|
||
if selected_node.getName() == "render":
|
||
self.add_warning_message("不能复制根节点")
|
||
return
|
||
|
||
# 序列化节点
|
||
if hasattr(self, 'scene_manager') and self.scene_manager:
|
||
node_data = self.scene_manager.serializeNodeForCopy(selected_node)
|
||
if node_data:
|
||
self.clipboard = [node_data]
|
||
# Keep live source nodes for robust copy->paste clone path.
|
||
self.clipboard_source_nodes = [selected_node]
|
||
self.clipboard_mode = "copy"
|
||
self.add_success_message(f"已复制节点: {selected_node.getName()}")
|
||
else:
|
||
self.add_error_message("节点序列化失败")
|
||
else:
|
||
self.add_error_message("场景管理器未初始化")
|
||
except Exception as e:
|
||
self.add_error_message(f"复制操作失败: {e}")
|
||
|
||
|
||
def _on_cut(self):
|
||
"""处理剪切操作"""
|
||
try:
|
||
if not hasattr(self, 'selection') or not self.selection:
|
||
self.add_error_message("选择系统未初始化")
|
||
return
|
||
|
||
# 获取当前选中的节点
|
||
selected_node = self._resolve_cut_copy_node(self.selection.selectedNode)
|
||
if not selected_node:
|
||
self.add_warning_message("没有选中的节点")
|
||
return
|
||
|
||
# 检查节点有效性（不能剪切根节点和系统节点）
|
||
node_name = selected_node.getName()
|
||
if node_name == "render":
|
||
self.add_warning_message("不能剪切根节点")
|
||
return
|
||
|
||
# 序列化节点
|
||
if hasattr(self, 'scene_manager') and self.scene_manager:
|
||
node_data = self.scene_manager.serializeNodeForCopy(selected_node)
|
||
if node_data:
|
||
self.clipboard = [node_data]
|
||
# Cut preserves the source node references for cloning in paste
|
||
self.clipboard_source_nodes = [selected_node]
|
||
self.clipboard_mode = "cut"
|
||
|
||
# 删除原节点
|
||
if self._delete_node(selected_node):
|
||
self.selection.clearSelection()
|
||
self.add_success_message(f"已剪切节点: {node_name}")
|
||
else:
|
||
self.add_error_message(f"剪切失败，无法删除节点: {node_name}")
|
||
else:
|
||
self.add_error_message("节点序列化失败")
|
||
else:
|
||
self.add_error_message("场景管理器未初始化")
|
||
except Exception as e:
|
||
self.add_error_message(f"剪切操作失败: {e}")
|
||
|
||
|
||
def _on_paste(self):
|
||
"""处理粘贴操作"""
|
||
try:
|
||
if not self.clipboard:
|
||
self.add_warning_message("剪切板为空")
|
||
return
|
||
|
||
if not hasattr(self, 'scene_manager') or not self.scene_manager:
|
||
self.add_error_message("场景管理器未初始化")
|
||
return
|
||
|
||
# 确定粘贴目标父节点
|
||
parent_node = None
|
||
if hasattr(self, 'selection') and self.selection:
|
||
selected_node = self.selection.selectedNode
|
||
if selected_node and not selected_node.isEmpty():
|
||
# Paste as sibling by default (not as child of selected node),
|
||
# which matches editor expectations and avoids "pasted but invisible".
|
||
if selected_node.getName() == "render":
|
||
parent_node = selected_node
|
||
else:
|
||
p = selected_node.getParent()
|
||
parent_node = p if p and not p.isEmpty() else self.render
|
||
|
||
# 如果没有选中节点，使用渲染根节点
|
||
if not parent_node:
|
||
parent_node = self.render
|
||
|
||
# 反序列化并添加节点
|
||
created_any = False
|
||
source_nodes = getattr(self, "clipboard_source_nodes", []) or []
|
||
for i, node_data in enumerate(self.clipboard):
|
||
def _paste_create_node(parent):
|
||
created = None
|
||
|
||
# Copy mode: prefer direct NodePath clone to preserve visual geometry.
|
||
if self.clipboard_mode in ("copy", "cut") and i < len(source_nodes):
|
||
source_node = source_nodes[i]
|
||
if source_node and not source_node.isEmpty():
|
||
try:
|
||
if self.clipboard_mode == "cut":
|
||
source_node.reparentTo(parent)
|
||
created = source_node
|
||
else:
|
||
created = source_node.copyTo(parent)
|
||
if hasattr(self.scene_manager, "_generateUniqueName"):
|
||
unique_name = self.scene_manager._generateUniqueName(source_node.getName(), parent)
|
||
created.setName(unique_name)
|
||
# Preserve model source tags so later cut/paste can rebuild real model.
|
||
for _tag in ("model_path", "saved_model_path", "original_path", "file", "element_type"):
|
||
if source_node.hasTag(_tag):
|
||
created.setTag(_tag, source_node.getTag(_tag))
|
||
# Offset slightly so the new node can be seen immediately.
|
||
created.setPos(created.getX() + 0.2, created.getY() + 0.2, created.getZ())
|
||
except Exception:
|
||
created = None
|
||
|
||
# Fallback: recreate from serialized data.
|
||
if not created:
|
||
if hasattr(self.scene_manager, "recreateNodeFromData"):
|
||
created = self.scene_manager.recreateNodeFromData(node_data, parent)
|
||
else:
|
||
created = self.scene_manager.deserializeNode(node_data, parent)
|
||
return created
|
||
|
||
new_node = None
|
||
if hasattr(self, "command_manager") and self.command_manager:
|
||
try:
|
||
from core.Command_System import CreateNodeCommand
|
||
create_cmd = CreateNodeCommand(_paste_create_node, parent_node)
|
||
self.command_manager.execute_command(create_cmd)
|
||
new_node = create_cmd.created_node
|
||
except Exception as e:
|
||
print(f"[Paste] command create failed, fallback direct create: {e}")
|
||
new_node = _paste_create_node(parent_node)
|
||
else:
|
||
new_node = _paste_create_node(parent_node)
|
||
|
||
if new_node:
|
||
created_any = True
|
||
# Ensure pasted model can be picked by legacy collision fallback.
|
||
try:
|
||
if hasattr(self, "scene_manager") and self.scene_manager:
|
||
if not new_node.hasTag("tree_item_type"):
|
||
new_node.setTag("tree_item_type", "IMPORTED_MODEL_NODE")
|
||
new_node.setTag("is_model_root", "1")
|
||
new_node.setTag("is_scene_element", "1")
|
||
self.scene_manager.setupCollision(new_node)
|
||
if hasattr(self.scene_manager, "models") and new_node not in self.scene_manager.models:
|
||
self.scene_manager.models.append(new_node)
|
||
except Exception as _e:
|
||
print(f"[Paste] setup collision for pasted node failed: {_e}")
|
||
self.add_success_message(f"已粘贴节点: {new_node.getName()}")
|
||
else:
|
||
self.add_error_message("节点反序列化失败")
|
||
|
||
# 如果是剪切模式且粘贴成功，清空剪切板
|
||
if created_any and self.clipboard_mode == "cut":
|
||
self.clipboard = []
|
||
self.clipboard_source_nodes = []
|
||
self.clipboard_mode = ""
|
||
except Exception as e:
|
||
self.add_error_message(f"粘贴操作失败: {e}")
|
||
|
||
|
||
def _on_delete(self):
|
||
"""处理删除操作"""
|
||
try:
|
||
if not hasattr(self, 'selection') or not self.selection:
|
||
self.add_error_message("选择系统未初始化")
|
||
return
|
||
|
||
# 获取当前选中的节点
|
||
selected_node = self.selection.selectedNode
|
||
if not selected_node:
|
||
self.add_warning_message("没有选中的节点")
|
||
return
|
||
|
||
# 检查节点有效性（不能删除根节点）
|
||
node_name = selected_node.getName()
|
||
if node_name == "render":
|
||
self.add_warning_message("不能删除根节点")
|
||
return
|
||
|
||
# 删除节点
|
||
if hasattr(self, 'scene_manager') and self.scene_manager:
|
||
self._delete_node(selected_node)
|
||
self.selection.clearSelection()
|
||
self.add_success_message(f"已删除节点: {node_name}")
|
||
else:
|
||
self.add_error_message("场景管理器未初始化")
|
||
except Exception as e:
|
||
self.add_error_message(f"删除操作失败: {e}")
|
||
|
||
|
||
def _delete_node(self, node):
|
||
"""删除节点的通用方法 - 使用命令系统"""
|
||
try:
|
||
if not node or node.isEmpty():
|
||
return False
|
||
|
||
node_name = node.getName() or "未命名节点"
|
||
parent = node.getParent()
|
||
ssbo_editor = getattr(self, "ssbo_editor", None)
|
||
ssbo_model = getattr(ssbo_editor, "model", None) if ssbo_editor else None
|
||
deleting_ssbo_root = bool(ssbo_model and (node == ssbo_model))
|
||
|
||
# 创建删除命令
|
||
if hasattr(self, 'command_manager') and self.command_manager:
|
||
from core.Command_System import DeleteNodeCommand
|
||
command = DeleteNodeCommand(node, parent, self)
|
||
self.command_manager.execute_command(command)
|
||
print(f"[命令系统] 创建删除命令: {node_name}")
|
||
else:
|
||
# 备用方案：直接删除并执行清理
|
||
print(f"[删除] 命令管理器不可用，直接删除节点: {node_name}")
|
||
self._perform_node_cleanup(node)
|
||
node.removeNode()
|
||
|
||
if deleting_ssbo_root and ssbo_editor:
|
||
try:
|
||
ssbo_editor.on_model_deleted(node)
|
||
except Exception as e:
|
||
print(f"[SSBO] 删除模型后清理失败: {e}")
|
||
|
||
print(f"[删除] 成功删除节点: {node_name}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"[删除] 删除节点失败: {e}")
|
||
return False
|
||
|
||
|
||
def _perform_node_cleanup(self, node):
|
||
"""执行节点清理逻辑"""
|
||
try:
|
||
node_name = node.getName() or "未命名节点"
|
||
|
||
# 从场景管理器的模型列表中移除（如果是模型）
|
||
if hasattr(self, 'scene_manager') and self.scene_manager:
|
||
if node in self.scene_manager.models:
|
||
self.scene_manager.models.remove(node)
|
||
print(f"[场景管理器] 从模型列表移除: {node_name}")
|
||
|
||
# 停止所有与该节点相关的脚本
|
||
if hasattr(self, 'script_manager') and self.script_manager:
|
||
try:
|
||
# 移除该节点上的所有脚本
|
||
if node in self.script_manager.object_scripts:
|
||
del self.script_manager.object_scripts[node]
|
||
print(f"[脚本系统] 移除节点 {node_name} 的所有脚本")
|
||
except Exception as e:
|
||
print(f"[脚本系统] 移除脚本失败: {e}")
|
||
|
||
# 清理碰撞体
|
||
if hasattr(self, 'collision_manager') and self.collision_manager:
|
||
try:
|
||
self.collision_manager.remove_collision_for_node(node)
|
||
print(f"[碰撞系统] 移除节点 {node_name} 的碰撞体")
|
||
except Exception as e:
|
||
print(f"[碰撞系统] 移除碰撞体失败: {e}")
|
||
|
||
# 清理Actor缓存（如果有动画）
|
||
if hasattr(self, '_actor_cache') and node in self._actor_cache:
|
||
actor = self._actor_cache[node]
|
||
try:
|
||
# 清理相关任务
|
||
taskMgr.remove(f"maintain_anim_pos_{id(actor)}")
|
||
# 清理Actor
|
||
if not actor.isEmpty():
|
||
actor.cleanup()
|
||
actor.removeNode()
|
||
print(f"[动画系统] 清理节点 {node_name} 的Actor缓存")
|
||
except Exception as e:
|
||
print(f"[动画系统] 清理Actor缓存失败: {e}")
|
||
finally:
|
||
del self._actor_cache[node]
|
||
|
||
except Exception as e:
|
||
print(f"[清理] 节点清理失败: {e}")
|
||
|
||
# ==================== 对话框绘制函数 ====================
|
||
|
||
|
||
def _create_new_project(self, name, path):
|
||
"""创建新项目的实际实现"""
|
||
if not hasattr(self, 'project_manager') or not self.project_manager:
|
||
print("✗ 项目管理器未初始化")
|
||
return
|
||
|
||
try:
|
||
if self._create_new_project_impl(name, path):
|
||
print(f"✓ 项目创建成功: {name}")
|
||
else:
|
||
print(f"✗ 项目创建失败: {name}")
|
||
except Exception as e:
|
||
print(f"✗ 项目创建失败: {e}")
|
||
|
||
|
||
def _open_project_path(self, path):
|
||
"""打开项目的实际实现"""
|
||
if not hasattr(self, 'project_manager') or not self.project_manager:
|
||
print("✗ 项目管理器未初始化")
|
||
return
|
||
|
||
try:
|
||
print(f"打开项目: {path}")
|
||
if self._open_project_impl(path):
|
||
print(f"✓ 项目打开成功: {path}")
|
||
else:
|
||
print(f"✗ 项目打开失败: {path}")
|
||
except Exception as e:
|
||
print(f"✗ 项目打开失败: {e}")
|
||
|
||
# ==================== 项目管理具体实现 ====================
|
||
|
||
|
||
def _save_project_impl(self):
|
||
"""保存项目的具体实现（不依赖Qt）"""
|
||
import json
|
||
import datetime
|
||
import os
|
||
|
||
project_path = self.project_manager.current_project_path
|
||
scenes_path = os.path.join(project_path, "scenes")
|
||
|
||
# 固定的场景文件名
|
||
scene_file = os.path.join(scenes_path, "scene.bam")
|
||
|
||
# 如果存在旧文件，先删除
|
||
if os.path.exists(scene_file):
|
||
try:
|
||
os.remove(scene_file)
|
||
print(f"已删除旧场景文件: {scene_file}")
|
||
except Exception as e:
|
||
print(f"删除旧场景文件失败: {str(e)}")
|
||
return False
|
||
|
||
# 保存场景
|
||
if self.scene_manager.saveScene(scene_file, project_path):
|
||
# 更新项目配置文件
|
||
config_file = os.path.join(project_path, "project.json")
|
||
if os.path.exists(config_file):
|
||
with open(config_file, "r", encoding="utf-8") as f:
|
||
project_config = json.load(f)
|
||
|
||
# 更新最后修改时间
|
||
project_config["last_modified"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||
# 记录场景文件路径
|
||
project_config["scene_file"] = os.path.relpath(scene_file, project_path)
|
||
|
||
with open(config_file, "w", encoding="utf-8") as f:
|
||
json.dump(project_config, f, ensure_ascii=False, indent=4)
|
||
|
||
# 更新项目配置
|
||
self.project_manager.project_config = project_config
|
||
return True
|
||
return False
|
||
|
||
|
||
def _open_project_impl(self, project_path):
|
||
"""打开项目的具体实现（不依赖Qt）"""
|
||
import json
|
||
import datetime
|
||
import os
|
||
|
||
try:
|
||
# 检查项目管理器是否已初始化
|
||
if not hasattr(self, 'project_manager') or not self.project_manager:
|
||
print("✗ 项目管理器未初始化")
|
||
self.add_error_message("项目管理器未初始化")
|
||
return False
|
||
|
||
# 检查场景管理器是否已初始化
|
||
if not hasattr(self, 'scene_manager') or not self.scene_manager:
|
||
print("✗ 场景管理器未初始化")
|
||
self.add_error_message("场景管理器未初始化")
|
||
return False
|
||
|
||
# 检查是否是有效的项目文件夹
|
||
config_file = os.path.join(project_path, "project.json")
|
||
if not os.path.exists(config_file):
|
||
print(f"⚠ 选择的不是有效的项目文件夹: {project_path}")
|
||
self.add_warning_message(f"选择的不是有效的项目文件夹: {project_path}")
|
||
return False
|
||
|
||
# 读取项目配置
|
||
try:
|
||
with open(config_file, "r", encoding="utf-8") as f:
|
||
project_config = json.load(f)
|
||
except Exception as e:
|
||
print(f"✗ 读取项目配置文件失败: {e}")
|
||
self.add_error_message(f"读取项目配置文件失败: {e}")
|
||
return False
|
||
|
||
# 检查场景文件
|
||
scene_file = os.path.join(project_path, "scenes", "scene.bam")
|
||
if os.path.exists(scene_file):
|
||
if getattr(self, "use_ssbo_mouse_picking", False) and callable(getattr(self, "_import_model_for_runtime", None)):
|
||
self.use_ssbo_scene_import = True
|
||
# 加载场景
|
||
try:
|
||
if self.scene_manager.loadScene(scene_file):
|
||
# 更新项目配置
|
||
project_config["scene_file"] = os.path.relpath(scene_file, project_path)
|
||
print(f"✓ 场景加载成功: {scene_file}")
|
||
else:
|
||
print(f"⚠ 场景加载失败: {scene_file}")
|
||
self.add_warning_message(f"场景加载失败: {scene_file}")
|
||
except Exception as e:
|
||
print(f"✗ 加载场景时发生错误: {e}")
|
||
self.add_error_message(f"加载场景时发生错误: {e}")
|
||
# 继续执行，不阻止项目打开
|
||
|
||
# 更新项目配置
|
||
project_config["last_modified"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||
try:
|
||
with open(config_file, "w", encoding="utf-8") as f:
|
||
json.dump(project_config, f, ensure_ascii=False, indent=4)
|
||
except Exception as e:
|
||
print(f"✗ 保存项目配置失败: {e}")
|
||
self.add_error_message(f"保存项目配置失败: {e}")
|
||
|
||
# 更新项目状态
|
||
self.project_manager.current_project_path = project_path
|
||
self.project_manager.project_config = project_config
|
||
|
||
# 更新窗口标题
|
||
project_name = os.path.basename(project_path)
|
||
self._update_window_title(project_name)
|
||
|
||
print(f"✓ 项目打开成功: {project_path}")
|
||
self.add_success_message(f"项目打开成功: {project_name}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"✗ 打开项目时发生错误: {e}")
|
||
self.add_error_message(f"打开项目时发生错误: {e}")
|
||
return False
|
||
|
||
|
||
def _create_new_project_impl(self, name, path):
|
||
"""创建新项目的具体实现（不依赖Qt）"""
|
||
import json
|
||
import datetime
|
||
import os
|
||
|
||
full_project_path = os.path.normpath(os.path.join(path, name))
|
||
print(f"创建项目路径: {full_project_path}")
|
||
|
||
try:
|
||
# 创建项目文件夹结构
|
||
os.makedirs(full_project_path)
|
||
os.makedirs(os.path.join(full_project_path, "models")) # 模型文件夹
|
||
os.makedirs(os.path.join(full_project_path, "textures")) # 贴图文件夹
|
||
scenes_path = os.path.join(full_project_path, "scenes") # 场景文件夹
|
||
os.makedirs(scenes_path)
|
||
|
||
# 创建项目配置文件
|
||
project_config = {
|
||
"name": name,
|
||
"path": full_project_path,
|
||
"created": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
|
||
"last_modified": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
|
||
"version": "1.0",
|
||
"scene_file": "scenes/scene.bam"
|
||
}
|
||
|
||
# 保存项目配置
|
||
config_file = os.path.join(full_project_path, "project.json")
|
||
with open(config_file, "w", encoding="utf-8") as f:
|
||
json.dump(project_config, f, ensure_ascii=False, indent=4)
|
||
|
||
# 保存初始场景
|
||
scene_file = os.path.join(scenes_path, "scene.bam")
|
||
self.scene_manager.saveScene(scene_file, full_project_path)
|
||
|
||
# 更新项目管理器状态
|
||
self.project_manager.current_project_path = full_project_path
|
||
self.project_manager.project_config = project_config
|
||
|
||
# 更新窗口标题
|
||
self._update_window_title(name)
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"创建项目失败: {e}")
|
||
return False
|
||
|
||
|
||
def _update_window_title(self, project_name):
|
||
"""更新窗口标题"""
|
||
try:
|
||
props = WindowProperties()
|
||
props.set_title(f"EG Engine - {project_name}")
|
||
self.win.request_properties(props)
|
||
print(f"窗口标题已更新: EG Engine - {project_name}")
|
||
except Exception as e:
|
||
print(f"更新窗口标题失败: {e}")
|
||
|
||
# ==================== 路径浏览器辅助方法 ====================
|
||
|
||
|
||
def _import_model_for_runtime(self, file_path, prefer_scene_manager=False):
|
||
"""Import model through the active runtime path.
|
||
SSBO mode: load via SSBOEditor always (regardless of prefer_scene_manager).
|
||
Legacy mode: load via SceneManager.
|
||
"""
|
||
if self.use_ssbo_mouse_picking and getattr(self, 'ssbo_editor', None):
|
||
try:
|
||
# Clear selection/gizmo first, then import as an additional scene model.
|
||
if hasattr(self, 'selection') and self.selection:
|
||
try:
|
||
self.selection.clearSelection()
|
||
except Exception:
|
||
try:
|
||
self.selection.updateSelection(None)
|
||
except Exception:
|
||
pass
|
||
|
||
self.ssbo_editor.load_model(file_path)
|
||
model_np = getattr(self.ssbo_editor, 'model', None)
|
||
normalized_import_path = str(file_path).replace("\\", "/").lower()
|
||
is_project_scene_bam = (
|
||
normalized_import_path.endswith(".bam")
|
||
and "/scenes/" in normalized_import_path
|
||
)
|
||
# Keep legacy ray-pick fallback usable by adding a collision body.
|
||
if model_np:
|
||
try:
|
||
from scene import util as scene_util
|
||
normalized_model_path = scene_util.normalize_model_path(file_path)
|
||
except Exception:
|
||
normalized_model_path = file_path
|
||
# Apply vital tags manually since SSBO overrides SceneManager loader
|
||
model_np.setTag("model_path", normalized_model_path)
|
||
model_np.setTag("original_path", file_path)
|
||
model_np.setTag("saved_model_path", normalized_model_path)
|
||
model_np.setTag("is_model_root", "1")
|
||
model_np.setTag("is_scene_element", "1")
|
||
model_np.setTag("file", os.path.basename(file_path))
|
||
model_np.setName(os.path.basename(file_path))
|
||
|
||
if hasattr(self, 'scene_manager') and self.scene_manager:
|
||
try:
|
||
if not is_project_scene_bam:
|
||
self.scene_manager.setupCollision(model_np)
|
||
self.scene_manager._processModelAnimations(model_np)
|
||
else:
|
||
model_np.setTag("has_animations", "false")
|
||
model_np.setTag("has_animations_checked", "true")
|
||
if hasattr(self.scene_manager, "models") and model_np not in self.scene_manager.models:
|
||
self.scene_manager.models.append(model_np)
|
||
except Exception as e:
|
||
print(f"[SSBO] setup components failed: {e}")
|
||
return model_np
|
||
except Exception as e:
|
||
print(f"[SSBO] load_model failed: {e}")
|
||
return None
|
||
|
||
# Legacy fallback
|
||
if hasattr(self, 'scene_manager') and self.scene_manager:
|
||
return self.scene_manager.importModel(file_path)
|
||
return None
|
||
|
||
def _import_model_with_menu_logic(
|
||
self,
|
||
file_path,
|
||
select_model=True,
|
||
set_origin=True,
|
||
show_info_message=True,
|
||
show_success_message=True,
|
||
):
|
||
"""统一的单文件导入入口，保持与菜单导入一致的处理流程。"""
|
||
try:
|
||
if not file_path:
|
||
self.add_error_message("请选择要导入的文件")
|
||
return None
|
||
|
||
normalized_path = os.fspath(file_path)
|
||
if not os.path.exists(normalized_path):
|
||
self.add_error_message(f"文件不存在: {normalized_path}")
|
||
return None
|
||
|
||
file_ext = os.path.splitext(normalized_path)[1].lower()
|
||
if file_ext not in self.supported_formats:
|
||
self.add_error_message(f"不支持的文件格式: {file_ext}")
|
||
return None
|
||
|
||
if not hasattr(self, 'scene_manager') or not self.scene_manager:
|
||
self.add_error_message("场景管理器未初始化")
|
||
return None
|
||
|
||
file_name = os.path.basename(normalized_path)
|
||
if show_info_message:
|
||
self.add_info_message(f"正在导入模型: {file_name}")
|
||
|
||
model_node = self._import_model_for_runtime(normalized_path)
|
||
if not model_node:
|
||
self.add_error_message("模型导入失败")
|
||
return None
|
||
|
||
# SSBO 模式下保留原始材质/纹理，避免模型发黑。
|
||
if not getattr(self, "use_ssbo_mouse_picking", False):
|
||
if hasattr(self.scene_manager, 'processMaterials'):
|
||
self.scene_manager.processMaterials(model_node)
|
||
if show_info_message:
|
||
self.add_info_message("已应用默认材质")
|
||
|
||
try:
|
||
model_node.clearMaterial()
|
||
model_node.clearTexture()
|
||
|
||
if hasattr(self.scene_manager, 'processMaterials'):
|
||
self.scene_manager.processMaterials(model_node)
|
||
|
||
try:
|
||
color = model_node.getColor()
|
||
if color and len(color) >= 4 and color == (1, 1, 1, 1):
|
||
model_node.setColor(0.8, 0.8, 0.8, 1.0)
|
||
elif not color:
|
||
model_node.setColor(0.8, 0.8, 0.8, 1.0)
|
||
except Exception:
|
||
model_node.setColor(0.8, 0.8, 0.8, 1.0)
|
||
except Exception as e:
|
||
self.add_warning_message(f"材质处理警告: {e}")
|
||
|
||
if set_origin:
|
||
model_node.setPos(0, 0, 0)
|
||
|
||
if hasattr(self.scene_manager, 'models') and model_node not in self.scene_manager.models:
|
||
self.scene_manager.models.append(model_node)
|
||
|
||
if select_model and hasattr(self, 'selection') and self.selection:
|
||
self.selection.updateSelection(model_node)
|
||
|
||
if show_success_message:
|
||
self.add_success_message(f"模型导入成功: {file_name}")
|
||
return model_node
|
||
except Exception as e:
|
||
self.add_error_message(f"导入模型失败: {e}")
|
||
return None
|
||
|
||
def _on_import_model(self):
|
||
"""处理导入模型菜单项"""
|
||
self.add_info_message("打开系统文件选择器")
|
||
self.show_import_dialog = True
|
||
|
||
|
||
def _import_model(self):
|
||
"""导入模型的具体实现"""
|
||
model_node = self._import_model_with_menu_logic(self.import_file_path)
|
||
self.import_file_path = ""
|
||
return model_node
|