1038 lines
41 KiB
Python
1038 lines
41 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
"""MetaCore packaged project runtime template."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import importlib
|
|
import json
|
|
import os
|
|
import sys
|
|
import traceback
|
|
|
|
from direct.showbase.ShowBase import ShowBase
|
|
from direct.showbase.ShowBaseGlobal import globalClock
|
|
from panda3d.core import (
|
|
CardMaker,
|
|
Filename,
|
|
Material,
|
|
MaterialAttrib,
|
|
ModelRoot,
|
|
MovieTexture,
|
|
NodePath,
|
|
Vec4,
|
|
TextNode,
|
|
TransparencyAttrib,
|
|
Vec3,
|
|
load_prc_file_data,
|
|
)
|
|
from project.scene_description import normalize_runtime_scene
|
|
|
|
PROJECT_NAME = "__EG_PROJECT_NAME__"
|
|
|
|
|
|
def _bootstrap_paths():
|
|
if getattr(sys, "frozen", False):
|
|
bundle_root = getattr(sys, "_MEIPASS", "") or os.path.join(os.path.dirname(sys.executable), "_internal")
|
|
if not os.path.isdir(bundle_root):
|
|
bundle_root = os.path.dirname(sys.executable)
|
|
project_root = bundle_root
|
|
else:
|
|
source_root = os.path.dirname(os.path.abspath(__file__))
|
|
staged_root = os.path.normpath(os.path.join(source_root, ".."))
|
|
project_root = staged_root if os.path.isdir(os.path.join(staged_root, "data")) else source_root
|
|
|
|
data_root = os.path.join(project_root, "data")
|
|
os.chdir(data_root if os.path.isdir(data_root) else project_root)
|
|
|
|
search_paths = [
|
|
project_root,
|
|
data_root,
|
|
os.path.join(data_root, "pipeline"),
|
|
os.path.join(project_root, "third_party"),
|
|
]
|
|
for path in search_paths:
|
|
if os.path.isdir(path) and path not in sys.path:
|
|
sys.path.insert(0, path)
|
|
|
|
return project_root, data_root
|
|
|
|
|
|
PROJECT_ROOT, DATA_ROOT = _bootstrap_paths()
|
|
|
|
|
|
class MainApp(ShowBase):
|
|
def __init__(self):
|
|
self.project_path = DATA_ROOT
|
|
self.data_root = DATA_ROOT
|
|
self.gui_elements = []
|
|
self.chinese_font = None
|
|
self.script_manager = None
|
|
self.render_pipeline = None
|
|
self._movie_textures = []
|
|
self.camera_control_enabled = True
|
|
self.mouse_controller = None
|
|
self.cameraSpeed = 20.0
|
|
self.cameraRotateSpeed = 10.0
|
|
self.lastMouseX = 0
|
|
self.lastMouseY = 0
|
|
self.mouseRightPressed = False
|
|
self.use_ssbo_mouse_picking = True
|
|
self.use_ssbo_scene_import = True
|
|
self.ssbo_runtime_importer = None
|
|
self._ssbo_visible_scene = None
|
|
self.runtime_manifest = {}
|
|
self.runtime_scene = {}
|
|
|
|
load_prc_file_data(
|
|
"",
|
|
f"""
|
|
win-size 1380 750
|
|
window-title {PROJECT_NAME}
|
|
load-display pandagl
|
|
aux-display p3tinydisplay
|
|
sync-video false
|
|
show-frame-rate-meter false
|
|
support-threads false
|
|
""",
|
|
)
|
|
|
|
from rpcore import RenderPipeline
|
|
|
|
self.render_pipeline = RenderPipeline()
|
|
self.render_pipeline.pre_showbase_init()
|
|
ShowBase.__init__(self)
|
|
self.render_pipeline.create(self)
|
|
self.render_pipeline._showbase.camera = self.render_pipeline._showbase.cam
|
|
self.disableMouse()
|
|
|
|
self._load_font()
|
|
self._load_manifest()
|
|
self._init_script_manager()
|
|
self._init_ssbo_runtime_importer()
|
|
self.load_runtime_scene()
|
|
|
|
def _init_script_manager(self):
|
|
script_module = importlib.import_module("core.script_system")
|
|
self.script_manager = script_module.ScriptManager(self)
|
|
self.script_manager.hot_reload_enabled = False
|
|
|
|
scripts_dir = self.get_resource_path("scripts")
|
|
if hasattr(self.script_manager, "set_scripts_directory"):
|
|
self.script_manager.set_scripts_directory(
|
|
scripts_dir,
|
|
create=False,
|
|
reload_scripts=False,
|
|
)
|
|
|
|
self.script_manager.start_system()
|
|
self.script_manager.set_hot_reload_enabled(False)
|
|
|
|
def _load_font(self):
|
|
font_candidates = [
|
|
"C:/Windows/Fonts/msyh.ttc",
|
|
"C:/Windows/Fonts/simhei.ttf",
|
|
]
|
|
for font_path in font_candidates:
|
|
if os.path.exists(font_path):
|
|
try:
|
|
self.chinese_font = self.loader.loadFont(font_path)
|
|
if self.chinese_font:
|
|
print(f"✓ 中文字体加载成功: {font_path}")
|
|
return
|
|
except Exception:
|
|
continue
|
|
print("⚠ 未找到可用中文字体，继续使用默认字体")
|
|
|
|
def _init_ssbo_runtime_importer(self):
|
|
if not (self.use_ssbo_mouse_picking and self.use_ssbo_scene_import):
|
|
return
|
|
try:
|
|
importer_module = importlib.import_module("ssbo_component.runtime_importer")
|
|
importer_cls = getattr(importer_module, "RuntimeSSBOSceneImporter", None)
|
|
if importer_cls:
|
|
self.ssbo_runtime_importer = importer_cls(self)
|
|
print("✓ 运行时 SSBO 场景导入器已启用")
|
|
except Exception as e:
|
|
print(f"⚠ 初始化运行时 SSBO 导入器失败: {e}")
|
|
|
|
def get_chinese_font(self):
|
|
return self.chinese_font
|
|
|
|
def get_resource_path(self, relative_path):
|
|
return os.path.normpath(os.path.join(DATA_ROOT, relative_path))
|
|
|
|
def _load_json_file(self, file_path, default_value):
|
|
if not os.path.exists(file_path):
|
|
return default_value
|
|
try:
|
|
with open(file_path, "r", encoding="utf-8-sig") as f:
|
|
return json.load(f)
|
|
except Exception as e:
|
|
print(f"⚠ 读取 JSON 失败 {file_path}: {e}")
|
|
return default_value
|
|
|
|
def _load_manifest(self):
|
|
manifest_path = self.get_resource_path("manifest.json")
|
|
self.runtime_manifest = self._load_json_file(manifest_path, {})
|
|
if not isinstance(self.runtime_manifest, dict):
|
|
self.runtime_manifest = {}
|
|
self._asset_index = {
|
|
str(asset.get("guid", "") or ""): dict(asset or {})
|
|
for asset in (self.runtime_manifest.get("assets", []) or [])
|
|
if isinstance(asset, dict) and asset.get("guid")
|
|
}
|
|
|
|
def _load_camera_state(self, camera_state=None):
|
|
camera_state = dict(camera_state or {})
|
|
if not isinstance(camera_state, dict):
|
|
camera_state = {}
|
|
|
|
position = camera_state.get("position") or [0, -20, 5]
|
|
rotation = camera_state.get("rotation") or [0, 0, 0]
|
|
self.camera_control_enabled = bool(camera_state.get("camera_control_enabled", True))
|
|
|
|
try:
|
|
if len(position) >= 3:
|
|
self.camera.setPos(position[0], position[1], position[2])
|
|
if len(rotation) >= 3:
|
|
self.camera.setHpr(rotation[0], rotation[1], rotation[2])
|
|
self.cam = self.camera
|
|
except Exception as e:
|
|
print(f"⚠ 恢复主相机状态失败: {e}")
|
|
|
|
def _init_camera_controller(self):
|
|
if not self.camera_control_enabled:
|
|
return
|
|
try:
|
|
controller_module = importlib.import_module("core.CustomMouseController")
|
|
controller_cls = getattr(controller_module, "CustomMouseController", None)
|
|
if not controller_cls:
|
|
return
|
|
|
|
self.mouse_controller = controller_cls(self)
|
|
self.mouse_controller.setUp()
|
|
self.accept("wheel_up", self.wheelForward)
|
|
self.accept("wheel_down", self.wheelBackward)
|
|
except Exception as e:
|
|
print(f"⚠ 初始化主相机控制失败: {e}")
|
|
|
|
def wheelForward(self, _data=None):
|
|
if not self.camera_control_enabled:
|
|
return
|
|
try:
|
|
forward = self.cam.getMat().getRow3(1)
|
|
distance = self.cameraSpeed * globalClock.getDt()
|
|
current_pos = self.cam.getPos()
|
|
self.cam.setPos(current_pos + forward * distance)
|
|
except Exception as e:
|
|
print(f"滚轮前进失败: {e}")
|
|
|
|
def wheelBackward(self, _data=None):
|
|
if not self.camera_control_enabled:
|
|
return
|
|
try:
|
|
forward = self.cam.getMat().getRow3(1)
|
|
distance = self.cameraSpeed * globalClock.getDt()
|
|
current_pos = self.cam.getPos()
|
|
self.cam.setPos(current_pos - forward * distance)
|
|
except Exception as e:
|
|
print(f"滚轮后退失败: {e}")
|
|
|
|
def _resolve_media_path(self, relative_path):
|
|
if not relative_path:
|
|
return ""
|
|
if str(relative_path).startswith(("http://", "https://")):
|
|
return relative_path
|
|
if os.path.isabs(relative_path):
|
|
return relative_path
|
|
return self.get_resource_path(relative_path.replace("/", os.sep))
|
|
|
|
def _resolve_startup_scene_runtime_path(self):
|
|
startup_scene_guid = self.runtime_manifest.get("startup_scene_guid", "")
|
|
for scene_entry in self.runtime_manifest.get("scenes", []) or []:
|
|
if scene_entry.get("guid") == startup_scene_guid:
|
|
return scene_entry.get("runtime_path", "")
|
|
scenes = self.runtime_manifest.get("scenes", []) or []
|
|
if scenes:
|
|
return scenes[0].get("runtime_path", "")
|
|
return ""
|
|
|
|
def load_runtime_scene(self):
|
|
runtime_scene_path = self._resolve_startup_scene_runtime_path()
|
|
if not runtime_scene_path:
|
|
print("⚠ 未找到启动场景")
|
|
return
|
|
|
|
runtime_scene_file = self.get_resource_path(runtime_scene_path)
|
|
self.runtime_scene = normalize_runtime_scene(self._load_json_file(runtime_scene_file, {}))
|
|
if not isinstance(self.runtime_scene, dict):
|
|
self.runtime_scene = {}
|
|
return
|
|
|
|
scene_components = dict(self.runtime_scene.get("scene_components", {}) or {})
|
|
camera_component = dict(scene_components.get("camera", {}) or self.runtime_scene.get("camera", {}) or {})
|
|
self._load_camera_state(camera_component)
|
|
self._init_camera_controller()
|
|
|
|
visible_scene = self._build_runtime_scene_from_description(self.runtime_scene)
|
|
if visible_scene is None or visible_scene.isEmpty():
|
|
print("⚠ 运行时场景重建失败")
|
|
return
|
|
visible_scene.reparentTo(self.render)
|
|
|
|
self._prepare_scene_for_render_pipeline(visible_scene)
|
|
self.process_scene_elements(
|
|
visible_scene,
|
|
skip_model_nodes=False,
|
|
runtime_root=visible_scene,
|
|
)
|
|
self.load_gui_from_runtime(self.runtime_scene)
|
|
print("✓ 场景加载完成")
|
|
|
|
def _build_runtime_scene_from_description(self, runtime_scene):
|
|
scene_root = NodePath(ModelRoot("RuntimeSceneRoot"))
|
|
nodes = list(runtime_scene.get("nodes", []) or [])
|
|
node_lookup = {
|
|
str(node.get("node_id", "") or ""): dict(node)
|
|
for node in nodes
|
|
if node.get("node_id") is not None
|
|
}
|
|
keep_nodes = {}
|
|
for node_id, node in node_lookup.items():
|
|
if self._should_keep_runtime_node(node_id, node, node_lookup):
|
|
keep_nodes[node_id] = node
|
|
|
|
built_nodes = {}
|
|
for node_id, node in keep_nodes.items():
|
|
parent_id = self._resolve_runtime_parent(node, keep_nodes, node_lookup)
|
|
parent_np = built_nodes.get(parent_id, scene_root)
|
|
built_np = self._instantiate_runtime_node(node, parent_np)
|
|
if built_np is not None and not built_np.isEmpty():
|
|
built_nodes[node_id] = built_np
|
|
return scene_root
|
|
|
|
def _should_keep_runtime_node(self, node_id, node, node_lookup):
|
|
if not node_id:
|
|
return False
|
|
if node.get("asset_guid"):
|
|
return True
|
|
components = node.get("components", {}) or {}
|
|
if components.get("light"):
|
|
return True
|
|
if node.get("scripts"):
|
|
return True
|
|
tags = node.get("tags", {}) or {}
|
|
if any(key in tags for key in ("is_scene_element", "runtime_interactive", "element_type", "has_scripts")):
|
|
return True
|
|
|
|
parent_id = node.get("parent_id")
|
|
while parent_id:
|
|
parent_node = node_lookup.get(parent_id)
|
|
if not parent_node:
|
|
break
|
|
if parent_node.get("asset_guid"):
|
|
return False
|
|
parent_id = parent_node.get("parent_id")
|
|
return True
|
|
|
|
def _resolve_runtime_parent(self, node, keep_nodes, node_lookup):
|
|
parent_id = node.get("parent_id")
|
|
while parent_id:
|
|
if parent_id in keep_nodes:
|
|
return parent_id
|
|
parent_node = node_lookup.get(parent_id)
|
|
parent_id = parent_node.get("parent_id") if parent_node else None
|
|
return None
|
|
|
|
def _instantiate_runtime_node(self, node, parent_np):
|
|
node_name = str(node.get("name", "") or "Node")
|
|
components = dict(node.get("components", {}) or {})
|
|
model_component = dict(components.get("model", {}) or {})
|
|
metadata_component = dict(components.get("metadata", {}) or {})
|
|
asset_guid = str(model_component.get("asset_guid", "") or node.get("asset_guid", "") or "")
|
|
imported_node_key = str(model_component.get("imported_node_key", "") or node.get("imported_node_key", "") or "")
|
|
|
|
if asset_guid:
|
|
loaded_np = self._load_runtime_asset_node(asset_guid, imported_node_key, node_name, node)
|
|
rebuilt_np = loaded_np if loaded_np and not loaded_np.isEmpty() else parent_np.attachNewNode(node_name)
|
|
if rebuilt_np.getParent() != parent_np:
|
|
rebuilt_np.reparentTo(parent_np)
|
|
rebuilt_np.setName(node_name)
|
|
else:
|
|
rebuilt_np = parent_np.attachNewNode(node_name)
|
|
|
|
transform = node.get("transform", {}) or {}
|
|
position = list(transform.get("position", [0, 0, 0]) or [0, 0, 0])
|
|
rotation = list(transform.get("rotation", [0, 0, 0]) or [0, 0, 0])
|
|
scale = list(transform.get("scale", [1, 1, 1]) or [1, 1, 1])
|
|
if len(position) >= 3:
|
|
rebuilt_np.setPos(float(position[0]), float(position[1]), float(position[2]))
|
|
if len(rotation) >= 3:
|
|
rebuilt_np.setHpr(float(rotation[0]), float(rotation[1]), float(rotation[2]))
|
|
if len(scale) >= 3:
|
|
rebuilt_np.setScale(float(scale[0]), float(scale[1]), float(scale[2]))
|
|
|
|
for tag_name, tag_value in (node.get("tags", {}) or {}).items():
|
|
if tag_value is None:
|
|
continue
|
|
rebuilt_np.setTag(str(tag_name), str(tag_value))
|
|
|
|
if bool(metadata_component.get("runtime_interactive", node.get("runtime_interactive", False))):
|
|
rebuilt_np.setTag("runtime_interactive", "true")
|
|
|
|
scripts = list((components.get("scripts", {}) or {}).get("entries", []) or node.get("scripts", []) or [])
|
|
if scripts:
|
|
rebuilt_np.setTag("has_scripts", "true")
|
|
rebuilt_np.setTag("scripts_info", json.dumps(scripts, ensure_ascii=False))
|
|
|
|
if asset_guid:
|
|
rebuilt_np.setTag("asset_guid", asset_guid)
|
|
if imported_node_key:
|
|
rebuilt_np.setTag("imported_node_key", imported_node_key)
|
|
|
|
return rebuilt_np
|
|
|
|
def _load_runtime_asset_node(self, asset_guid, imported_node_key="", node_name="", node_data=None):
|
|
asset_record = dict(self._asset_index.get(str(asset_guid or ""), {}) or {})
|
|
if not asset_record:
|
|
return None
|
|
|
|
candidate_paths = []
|
|
node_data = dict(node_data or {})
|
|
components = dict(node_data.get("components", {}) or {})
|
|
metadata_component = dict(components.get("metadata", {}) or {})
|
|
node_tags = dict(node_data.get("tags", {}) or {})
|
|
has_animations = str(
|
|
metadata_component.get(
|
|
"has_animations",
|
|
metadata_component.get(
|
|
"saved_has_animations",
|
|
node_tags.get("has_animations", node_tags.get("saved_has_animations", "")),
|
|
),
|
|
)
|
|
or ""
|
|
).lower() == "true"
|
|
can_create_actor = str(
|
|
metadata_component.get(
|
|
"can_create_actor_from_memory",
|
|
metadata_component.get(
|
|
"saved_can_create_actor_from_memory",
|
|
node_tags.get(
|
|
"can_create_actor_from_memory",
|
|
node_tags.get("saved_can_create_actor_from_memory", ""),
|
|
),
|
|
),
|
|
)
|
|
or ""
|
|
).lower() == "true"
|
|
|
|
asset_dir = os.path.join(DATA_ROOT, "assets", asset_guid)
|
|
asset_path = str(asset_record.get("asset_path", "") or "").replace("\\", "/").strip()
|
|
if asset_path:
|
|
candidate_paths.append(os.path.join(DATA_ROOT, asset_path.replace("/", os.sep)))
|
|
candidate_paths.append(os.path.join(asset_dir, os.path.basename(asset_path)))
|
|
|
|
imported_cache = dict(asset_record.get("imported_cache", {}) or {})
|
|
imported_model_rel = str(imported_cache.get("model_bam", "") or "").replace("\\", "/").strip()
|
|
if imported_model_rel and not (has_animations or can_create_actor):
|
|
candidate_paths.append(os.path.join(DATA_ROOT, imported_model_rel.replace("/", os.sep)))
|
|
|
|
imported_model_path = os.path.join(asset_dir, "imported", "model.bam")
|
|
if os.path.exists(imported_model_path) and not (has_animations or can_create_actor):
|
|
candidate_paths.append(imported_model_path)
|
|
|
|
for candidate_path in candidate_paths:
|
|
if not candidate_path or not os.path.exists(candidate_path):
|
|
continue
|
|
try:
|
|
loaded_np = self.loader.loadModel(Filename.fromOsSpecific(candidate_path))
|
|
if not loaded_np or loaded_np.isEmpty():
|
|
continue
|
|
if imported_node_key:
|
|
return self._clone_runtime_subnode(loaded_np, imported_node_key, node_name)
|
|
return loaded_np
|
|
except Exception as e:
|
|
print(f"⚠ 运行时加载资产失败 {candidate_path}: {e}")
|
|
return None
|
|
|
|
def _clone_runtime_subnode(self, loaded_np, imported_node_key, node_name):
|
|
imported_node_key = str(imported_node_key or "").strip().strip("/")
|
|
if not imported_node_key:
|
|
return loaded_np
|
|
|
|
target_np = loaded_np
|
|
try:
|
|
for part in imported_node_key.split("/"):
|
|
if part == "":
|
|
continue
|
|
child_index = int(part)
|
|
children = list(target_np.getChildren())
|
|
if child_index < 0 or child_index >= len(children):
|
|
return loaded_np
|
|
target_np = children[child_index]
|
|
except Exception:
|
|
return loaded_np
|
|
|
|
try:
|
|
clone_root = NodePath(ModelRoot(node_name or target_np.getName() or "ImportedNode"))
|
|
cloned_child = target_np.copyTo(clone_root)
|
|
cloned_child.wrtReparentTo(clone_root)
|
|
cloned_child.setName(node_name or target_np.getName())
|
|
return cloned_child
|
|
except Exception:
|
|
return target_np
|
|
|
|
def _find_runtime_node_by_name(self, runtime_root, node_name):
|
|
if runtime_root is None or runtime_root.isEmpty() or not node_name:
|
|
return None
|
|
try:
|
|
for candidate in runtime_root.find_all_matches("**"):
|
|
if candidate.getName() == node_name:
|
|
return candidate
|
|
except Exception:
|
|
return None
|
|
return None
|
|
|
|
def _prepare_scene_for_render_pipeline(self, scene):
|
|
self._bake_effective_geom_materials(scene)
|
|
self._ensure_geom_materials(scene)
|
|
|
|
try:
|
|
self.render_pipeline.prepare_scene(scene)
|
|
except Exception as e:
|
|
print(f"⚠ RenderPipeline 场景预处理失败，继续使用原始场景: {e}")
|
|
traceback.print_exc()
|
|
|
|
def _build_default_material(self):
|
|
material = Material()
|
|
material.setAmbient(Vec4(0.2, 0.2, 0.2, 1.0))
|
|
material.setDiffuse(Vec4(0.8, 0.8, 0.8, 1.0))
|
|
material.setSpecular(Vec4(0.0, 0.0, 0.0, 1.0))
|
|
material.setEmission(Vec4(0.0, 0.0, 0.0, 1.0))
|
|
material.setShininess(0.0)
|
|
return material
|
|
|
|
def _ensure_geom_materials(self, scene):
|
|
for geom_np in scene.find_all_matches("**/+GeomNode"):
|
|
try:
|
|
geom_node = geom_np.node()
|
|
except Exception:
|
|
continue
|
|
|
|
fallback_material = None
|
|
try:
|
|
if geom_np.hasMaterial():
|
|
fallback_material = geom_np.getMaterial()
|
|
except Exception:
|
|
fallback_material = None
|
|
|
|
for geom_index in range(geom_node.getNumGeoms()):
|
|
try:
|
|
geom_state = geom_node.getGeomState(geom_index)
|
|
except Exception:
|
|
continue
|
|
|
|
material = None
|
|
try:
|
|
if geom_state.hasAttrib(MaterialAttrib):
|
|
material_attrib = geom_state.getAttrib(MaterialAttrib)
|
|
material = material_attrib.getMaterial() if material_attrib else None
|
|
except Exception:
|
|
material = None
|
|
|
|
if material is None:
|
|
material = fallback_material or self._build_default_material()
|
|
|
|
try:
|
|
geom_node.setGeomState(
|
|
geom_index,
|
|
geom_state.setAttrib(MaterialAttrib.make(material)),
|
|
)
|
|
except Exception:
|
|
continue
|
|
|
|
def _bake_effective_geom_materials(self, scene):
|
|
for geom_np in scene.find_all_matches("**/+GeomNode"):
|
|
try:
|
|
geom_node = geom_np.node()
|
|
net_state = geom_np.getNetState()
|
|
except Exception:
|
|
continue
|
|
|
|
for geom_index in range(geom_node.getNumGeoms()):
|
|
try:
|
|
geom_state = geom_node.getGeomState(geom_index)
|
|
except Exception:
|
|
continue
|
|
|
|
material = None
|
|
try:
|
|
if geom_state.hasAttrib(MaterialAttrib):
|
|
material_attrib = geom_state.getAttrib(MaterialAttrib)
|
|
material = material_attrib.getMaterial() if material_attrib else None
|
|
except Exception:
|
|
material = None
|
|
|
|
if material is None:
|
|
try:
|
|
if net_state.hasAttrib(MaterialAttrib):
|
|
material_attrib = net_state.getAttrib(MaterialAttrib)
|
|
material = material_attrib.getMaterial() if material_attrib else None
|
|
except Exception:
|
|
material = None
|
|
|
|
if material is None:
|
|
try:
|
|
if geom_np.hasMaterial():
|
|
material = geom_np.getMaterial()
|
|
except Exception:
|
|
material = None
|
|
|
|
if material is None:
|
|
continue
|
|
|
|
try:
|
|
geom_node.setGeomState(
|
|
geom_index,
|
|
geom_state.setAttrib(MaterialAttrib.make(material)),
|
|
)
|
|
except Exception:
|
|
continue
|
|
|
|
def process_scene_elements(self, root_node, skip_model_nodes=False, runtime_root=None):
|
|
processed_lights = set()
|
|
|
|
def walk(node_path):
|
|
is_model_root = node_path.hasTag("is_model_root")
|
|
runtime_target = None
|
|
if is_model_root and runtime_root is not None:
|
|
runtime_target = self._find_runtime_node_by_name(runtime_root, node_path.getName())
|
|
|
|
self._apply_user_visibility(node_path)
|
|
if runtime_target is not None:
|
|
self._apply_user_visibility(runtime_target)
|
|
|
|
if skip_model_nodes and is_model_root:
|
|
runtime_target = None
|
|
if self.ssbo_runtime_importer:
|
|
runtime_target = self.ssbo_runtime_importer.get_runtime_node_for_name(node_path.getName())
|
|
if runtime_target is None:
|
|
runtime_target = self._ssbo_visible_scene
|
|
|
|
if node_path.hasTag("scripts_info") and runtime_target:
|
|
try:
|
|
scripts_info = json.loads(node_path.getTag("scripts_info"))
|
|
self.process_scripts(runtime_target, scripts_info)
|
|
except Exception as e:
|
|
print(f"处理 SSBO 模型根脚本失败 {node_path.getName()}: {e}")
|
|
return
|
|
|
|
if node_path.hasTag("scripts_info"):
|
|
try:
|
|
scripts_info = json.loads(node_path.getTag("scripts_info"))
|
|
self.process_scripts(runtime_target or node_path, scripts_info)
|
|
except Exception as e:
|
|
print(f"处理节点脚本失败 {node_path.getName()}: {e}")
|
|
|
|
if node_path.hasTag("light_type") and node_path not in processed_lights:
|
|
if node_path.hasTag("is_auxiliary_light") and node_path.getTag("is_auxiliary_light").lower() == "true":
|
|
return
|
|
|
|
light_type = node_path.getTag("light_type")
|
|
if light_type == "spot_light":
|
|
self._recreate_spot_light(node_path)
|
|
elif light_type == "point_light":
|
|
self._recreate_point_light(node_path)
|
|
processed_lights.add(node_path)
|
|
|
|
for child in node_path.getChildren():
|
|
walk(child)
|
|
|
|
walk(root_node)
|
|
|
|
def _apply_user_visibility(self, node_path):
|
|
if not node_path.hasTag("user_visible"):
|
|
return
|
|
|
|
user_visible = node_path.getTag("user_visible").lower() == "true"
|
|
node_path.setPythonTag("user_visible", user_visible)
|
|
if user_visible:
|
|
node_path.show()
|
|
else:
|
|
node_path.hide()
|
|
|
|
def _recreate_spot_light(self, light_node):
|
|
try:
|
|
from rpcore import SpotLight
|
|
|
|
light = SpotLight()
|
|
light.direction = Vec3(0, 0, -1)
|
|
light.fov = float(light_node.getTag("light_fov")) if light_node.hasTag("light_fov") else 70.0
|
|
light.energy = float(light_node.getTag("light_energy")) if light_node.hasTag("light_energy") else 5000.0
|
|
light.radius = float(light_node.getTag("light_radius")) if light_node.hasTag("light_radius") else 1000.0
|
|
light.casts_shadows = True
|
|
light.shadow_map_resolution = 256
|
|
light.setPos(light_node.getPos())
|
|
self.render_pipeline.add_light(light)
|
|
except Exception as e:
|
|
print(f"创建聚光灯失败 {light_node.getName()}: {e}")
|
|
|
|
def _recreate_point_light(self, light_node):
|
|
try:
|
|
from rpcore import PointLight
|
|
|
|
light = PointLight()
|
|
light.energy = float(light_node.getTag("light_energy")) if light_node.hasTag("light_energy") else 5000.0
|
|
light.radius = float(light_node.getTag("light_radius")) if light_node.hasTag("light_radius") else 1000.0
|
|
light.inner_radius = 0.4
|
|
light.casts_shadows = True
|
|
light.shadow_map_resolution = 256
|
|
light.setPos(light_node.getPos())
|
|
self.render_pipeline.add_light(light)
|
|
except Exception as e:
|
|
print(f"创建点光源失败 {light_node.getName()}: {e}")
|
|
|
|
def process_scripts(self, node_path, script_info_list):
|
|
if not self.script_manager:
|
|
return
|
|
|
|
for script_info in script_info_list or []:
|
|
script_name = str(script_info.get("name", "") or "").strip()
|
|
if not script_name:
|
|
continue
|
|
|
|
try:
|
|
if script_name not in self.script_manager.loader.script_classes:
|
|
script_path = ""
|
|
if hasattr(self.script_manager, "resolve_script_path"):
|
|
script_path = self.script_manager.resolve_script_path(script_info)
|
|
if script_path:
|
|
self.script_manager.load_script_from_file(script_path)
|
|
|
|
script_component = self.script_manager.add_script_to_object(node_path, script_name)
|
|
if script_component:
|
|
print(f"✓ 脚本 {script_name} 已挂载到 {node_path.getName()}")
|
|
else:
|
|
print(f"⚠ 脚本 {script_name} 挂载失败")
|
|
except Exception as e:
|
|
print(f"挂载脚本失败 {script_name}: {e}")
|
|
|
|
def load_gui_from_runtime(self, runtime_scene):
|
|
gui_data = []
|
|
if isinstance(runtime_scene, dict):
|
|
scene_components = dict(runtime_scene.get("scene_components", {}) or {})
|
|
gui_component = dict(scene_components.get("gui", {}) or {})
|
|
gui_data = gui_component.get("elements", []) or runtime_scene.get("gui", []) or []
|
|
if not gui_data:
|
|
return
|
|
self.create_gui_elements(gui_data)
|
|
|
|
def create_gui_elements(self, element_data):
|
|
processed_names = set()
|
|
created_elements = {}
|
|
pending_parent_links = []
|
|
|
|
for index, gui_info in enumerate(element_data or []):
|
|
try:
|
|
gui_type = gui_info.get("type", "unknown")
|
|
name = gui_info.get("name", f"gui_element_{index}")
|
|
if name in processed_names:
|
|
continue
|
|
processed_names.add(name)
|
|
|
|
position = list(gui_info.get("position", [0, 0, 0]))
|
|
scale = list(gui_info.get("scale", [1, 1, 1]))
|
|
parent_name = gui_info.get("parent_name")
|
|
|
|
text = gui_info.get("text", "")
|
|
raw_image_path = str(gui_info.get("image_path", "") or "")
|
|
raw_video_path = str(gui_info.get("video_path", "") or "")
|
|
image_path = self._resolve_media_path(raw_image_path)
|
|
video_path = self._resolve_media_path(raw_video_path)
|
|
|
|
new_element = None
|
|
if gui_type == "3d_text":
|
|
new_element = self.create_gui_3d_text(tuple(position), text, scale[0] if scale else 1.0)
|
|
elif gui_type == "3d_image":
|
|
new_element = self.create_gui_3d_image(tuple(position), image_path, scale)
|
|
elif gui_type == "button":
|
|
new_element = self.create_gui_button(tuple(position), text, scale[0] if scale else 1.0)
|
|
elif gui_type == "label":
|
|
new_element = self.create_gui_label(tuple(position), text, scale[0] if scale else 1.0)
|
|
elif gui_type == "entry":
|
|
new_element = self.create_gui_entry(tuple(position), text, scale[0] if scale else 1.0)
|
|
elif gui_type == "2d_image":
|
|
new_element = self.create_gui_2d_image(tuple(position), image_path, scale)
|
|
elif gui_type == "video_screen":
|
|
new_element = self.create_gui_video_screen(tuple(position), scale, video_path)
|
|
elif gui_type == "2d_video_screen":
|
|
new_element = self.create_gui_2d_video_screen(tuple(position), scale, video_path)
|
|
|
|
if not new_element:
|
|
continue
|
|
|
|
self._apply_gui_metadata(new_element, gui_info, gui_type, text, raw_image_path, raw_video_path)
|
|
self.gui_elements.append(new_element)
|
|
created_elements[name] = new_element
|
|
|
|
if parent_name:
|
|
pending_parent_links.append((new_element, parent_name))
|
|
|
|
if gui_info.get("scripts"):
|
|
self.process_scripts(new_element, gui_info["scripts"])
|
|
except Exception as e:
|
|
print(f"重建 GUI 元素失败: {e}")
|
|
traceback.print_exc()
|
|
|
|
for child, parent_name in pending_parent_links:
|
|
parent = created_elements.get(parent_name)
|
|
if not parent:
|
|
continue
|
|
try:
|
|
child.reparentTo(parent)
|
|
except Exception as e:
|
|
print(f"恢复 GUI 父子关系失败 {parent_name}: {e}")
|
|
|
|
def _apply_gui_metadata(self, node, gui_info, gui_type, text, image_path, video_path):
|
|
try:
|
|
name = gui_info.get("name")
|
|
if name and hasattr(node, "setName"):
|
|
node.setName(name)
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
position = gui_info.get("position", [])
|
|
if len(position) >= 3 and hasattr(node, "setPos"):
|
|
node.setPos(position[0], position[1], position[2])
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
rotation = gui_info.get("rotation", [])
|
|
if len(rotation) >= 3 and hasattr(node, "setHpr"):
|
|
node.setHpr(rotation[0], rotation[1], rotation[2])
|
|
except Exception:
|
|
pass
|
|
|
|
try:
|
|
scale = gui_info.get("scale", [])
|
|
if hasattr(node, "setScale"):
|
|
if isinstance(scale, (list, tuple)):
|
|
if len(scale) >= 3:
|
|
node.setScale(scale[0], scale[1], scale[2])
|
|
elif len(scale) == 1:
|
|
node.setScale(scale[0])
|
|
elif scale:
|
|
node.setScale(scale)
|
|
except Exception:
|
|
pass
|
|
|
|
if hasattr(node, "setTag"):
|
|
node.setTag("gui_type", gui_type)
|
|
node.setTag("saved_gui_type", gui_type)
|
|
node.setTag("is_gui_element", "true")
|
|
if text:
|
|
node.setTag("gui_text", str(text))
|
|
if image_path:
|
|
node.setTag("gui_image_path", str(image_path))
|
|
node.setTag("image_path", str(image_path))
|
|
if video_path:
|
|
node.setTag("video_path", str(video_path))
|
|
for key, value in (gui_info.get("tags") or {}).items():
|
|
try:
|
|
node.setTag(str(key), str(value))
|
|
except Exception:
|
|
continue
|
|
|
|
user_visible = bool(gui_info.get("user_visible", True))
|
|
if hasattr(node, "setPythonTag"):
|
|
node.setPythonTag("user_visible", user_visible)
|
|
if hasattr(node, "show") and hasattr(node, "hide"):
|
|
if user_visible:
|
|
node.show()
|
|
else:
|
|
node.hide()
|
|
|
|
def create_gui_button(self, pos=(0, 0, 0), text="按钮", size=0.1):
|
|
from direct.gui.DirectGui import DirectButton
|
|
|
|
return DirectButton(
|
|
text=text,
|
|
pos=(pos[0], pos[1], pos[2]),
|
|
scale=size,
|
|
frameColor=(0.2, 0.6, 0.8, 1),
|
|
text_font=self.get_chinese_font() or None,
|
|
rolloverSound=None,
|
|
clickSound=None,
|
|
parent=self.aspect2d,
|
|
command=None,
|
|
)
|
|
|
|
def create_gui_label(self, pos=(0, 0, 0), text="标签", size=0.08):
|
|
from direct.gui.DirectGui import DirectLabel
|
|
|
|
return DirectLabel(
|
|
text=text,
|
|
pos=(pos[0], pos[1], pos[2]),
|
|
scale=size,
|
|
frameColor=(0, 0, 0, 0),
|
|
text_fg=(1, 1, 1, 1),
|
|
text_font=self.get_chinese_font() or None,
|
|
text_align=TextNode.ACenter,
|
|
text_mayChange=True,
|
|
parent=self.aspect2d,
|
|
)
|
|
|
|
def create_gui_entry(self, pos=(0, 0, 0), placeholder="输入文本...", size=0.08):
|
|
from direct.gui.DirectGui import DirectEntry
|
|
|
|
return DirectEntry(
|
|
text="",
|
|
pos=(pos[0], pos[1], pos[2]),
|
|
scale=size,
|
|
command=self.on_gui_entry_submit,
|
|
initialText=placeholder,
|
|
numLines=1,
|
|
width=12,
|
|
focus=0,
|
|
frameColor=(0, 0, 0, 0),
|
|
text_fg=(1, 1, 1, 1),
|
|
text_font=self.get_chinese_font() or None,
|
|
text_align=TextNode.ACenter,
|
|
text_mayChange=True,
|
|
parent=self.aspect2d,
|
|
rolloverSound=None,
|
|
clickSound=None,
|
|
suppressKeys=True,
|
|
suppressMouse=True,
|
|
)
|
|
|
|
def on_gui_entry_submit(self, text, *_args):
|
|
print(f"GUI 输入框提交: {text}")
|
|
|
|
def create_gui_2d_image(self, pos=(0, 0, 0), image_path="", size=(1, 1, 1)):
|
|
if isinstance(size, (list, tuple)) and len(size) >= 3:
|
|
width_scale = float(size[0]) * 0.2
|
|
height_scale = float(size[2]) * 0.2
|
|
else:
|
|
scalar = float(size) if isinstance(size, (int, float)) else 0.2
|
|
width_scale = scalar * 0.1
|
|
height_scale = width_scale
|
|
|
|
cm = CardMaker("gui_2d_image")
|
|
cm.setFrame(-width_scale, width_scale, -height_scale, height_scale)
|
|
image_node = self.aspect2d.attachNewNode(cm.generate())
|
|
image_node.setPos(pos)
|
|
image_node.setBin("fixed", 0)
|
|
image_node.setDepthWrite(False)
|
|
image_node.setDepthTest(False)
|
|
image_node.setTransparency(TransparencyAttrib.MAlpha)
|
|
if image_path:
|
|
texture = self.loader.loadTexture(image_path)
|
|
if texture:
|
|
image_node.setTexture(texture, 1)
|
|
return image_node
|
|
|
|
def create_gui_3d_text(self, pos=(0, 0, 0), text="3D文本", size=0.5):
|
|
text_node = TextNode("gui_3d_text")
|
|
text_node.setText(text)
|
|
text_node.setAlign(TextNode.ACenter)
|
|
if self.get_chinese_font():
|
|
text_node.setFont(self.get_chinese_font())
|
|
|
|
text_np = self.render.attachNewNode(text_node)
|
|
text_np.setPos(Vec3(pos[0], pos[1], pos[2]))
|
|
text_np.setScale(size)
|
|
text_np.setBin("fixed", 40)
|
|
text_np.setDepthWrite(False)
|
|
return text_np
|
|
|
|
def create_gui_3d_image(self, pos=(0, 0, 0), image_path="", size=(1, 1, 1)):
|
|
if isinstance(size, (list, tuple)) and len(size) >= 3:
|
|
width_scale = float(size[0])
|
|
height_scale = float(size[2])
|
|
else:
|
|
width_scale = float(size) if isinstance(size, (int, float)) else 1.0
|
|
height_scale = width_scale
|
|
|
|
cm = CardMaker("gui_3d_image")
|
|
cm.setFrame(-width_scale, width_scale, -height_scale, height_scale)
|
|
image_node = self.render.attachNewNode(cm.generate())
|
|
image_node.setPos(pos)
|
|
image_node.setTransparency(TransparencyAttrib.MAlpha)
|
|
if image_path:
|
|
texture = self.loader.loadTexture(image_path)
|
|
if texture:
|
|
image_node.setTexture(texture, 1)
|
|
return image_node
|
|
|
|
def _load_movie_texture(self, name, video_path):
|
|
if not video_path:
|
|
return None
|
|
if str(video_path).startswith(("http://", "https://")):
|
|
print(f"⚠ 当前运行时仅支持本地视频文件: {video_path}")
|
|
return None
|
|
movie_texture = MovieTexture(name)
|
|
if not movie_texture.read(Filename.fromOsSpecific(video_path)):
|
|
print(f"⚠ 无法加载视频: {video_path}")
|
|
return None
|
|
movie_texture.play()
|
|
return movie_texture
|
|
|
|
def create_gui_video_screen(self, pos=(0, 0, 0), size=(1, 1, 1), video_path=""):
|
|
if isinstance(size, (list, tuple)) and len(size) >= 3:
|
|
width_scale = float(size[0])
|
|
height_scale = float(size[2])
|
|
else:
|
|
width_scale = float(size) if isinstance(size, (int, float)) else 1.0
|
|
height_scale = width_scale
|
|
|
|
cm = CardMaker("gui_video_screen")
|
|
cm.setFrame(-width_scale, width_scale, -height_scale, height_scale)
|
|
video_node = self.render.attachNewNode(cm.generate())
|
|
video_node.setPos(pos)
|
|
video_node.setTransparency(TransparencyAttrib.MAlpha)
|
|
|
|
movie_texture = self._load_movie_texture("gui_video_texture_3d", video_path)
|
|
if movie_texture:
|
|
video_node.setTexture(movie_texture, 1)
|
|
video_node.setPythonTag("movie_texture", movie_texture)
|
|
self._movie_textures.append(movie_texture)
|
|
return video_node
|
|
|
|
def create_gui_2d_video_screen(self, pos=(0, 0, 0), size=(1, 1, 1), video_path=""):
|
|
if isinstance(size, (list, tuple)) and len(size) >= 3:
|
|
width_scale = float(size[0]) * 0.2
|
|
height_scale = float(size[2]) * 0.2
|
|
else:
|
|
scalar = float(size) if isinstance(size, (int, float)) else 0.2
|
|
width_scale = scalar * 0.1
|
|
height_scale = width_scale
|
|
|
|
cm = CardMaker("gui_2d_video_screen")
|
|
cm.setFrame(-width_scale, width_scale, -height_scale, height_scale)
|
|
video_node = self.aspect2d.attachNewNode(cm.generate())
|
|
video_node.setPos(pos)
|
|
video_node.setTransparency(TransparencyAttrib.MAlpha)
|
|
video_node.setDepthWrite(False)
|
|
video_node.setDepthTest(False)
|
|
|
|
movie_texture = self._load_movie_texture("gui_video_texture_2d", video_path)
|
|
if movie_texture:
|
|
video_node.setTexture(movie_texture, 1)
|
|
video_node.setPythonTag("movie_texture", movie_texture)
|
|
self._movie_textures.append(movie_texture)
|
|
return video_node
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
app = MainApp()
|
|
app.run()
|
|
except Exception as e:
|
|
print(f"应用程序启动失败: {e}")
|
|
traceback.print_exc()
|