diff --git a/.idea/misc.xml b/.idea/misc.xml
index a0ea9286..51b9fc17 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -3,5 +3,5 @@
-
+
\ No newline at end of file
diff --git a/QPanda3D/QPanda3DWidget.py b/QPanda3D/QPanda3DWidget.py
index 25a6158c..61b531b1 100644
--- a/QPanda3D/QPanda3DWidget.py
+++ b/QPanda3D/QPanda3DWidget.py
@@ -32,9 +32,24 @@ class QPanda3DSynchronizer(QTimer):
self.setInterval(int(dt))
self.timeout.connect(self.tick)
+ # def tick(self):
+ # taskMgr.step()
+ # self.qPanda3DWidget.update()
+
def tick(self):
- taskMgr.step()
- self.qPanda3DWidget.update()
+ try:
+ taskMgr.step()
+ self.qPanda3DWidget.update()
+ except AssertionError as e:
+ if "has_mat()" in str(e):
+ print("⚠️ 检测到变换矩阵错误，跳过此帧")
+ # 继续运行而不是崩溃
+ else:
+ raise
+ except Exception as e:
+ print(f"❌ 渲染循环错误: {e}")
+ import traceback
+ traceback.print_exc()
def get_panda_key_modifiers(evt):
@@ -160,8 +175,8 @@ class QPanda3DWidget(QWidget):
def resizeEvent(self, evt):
width = evt.size().width()
height = evt.size().height()
- print(f"width:{width}")
- print(f"height:{height}")
+ #print(f"width:{width}")
+ #print(f"height:{height}")
from Panda3DWorld import resize_buffer
#resize_buffer(width, height)
diff --git a/RenderPipelineFile/config/daytime.yaml b/RenderPipelineFile/config/daytime.yaml
index 731e5beb..9c9622cd 100644
--- a/RenderPipelineFile/config/daytime.yaml
+++ b/RenderPipelineFile/config/daytime.yaml
@@ -5,7 +5,7 @@
control_points:
clouds:
- cloud_brightness: [[[0.4558541267,0.9574780059],[0.2744727256,0.8944309678],[0.1938559693,0.5249266862],[0.8905932438,0.2375366569],[0.6429901728,0.9589492375],[0.7581600000,0.8914912023],[0.2226478119,0.7859268915],[0.8406909789,0.4897360704],[0.5451055662,0.9618768328],[0.9462571977,0.0000000000],[1.0000000000,0.0000000000],[0.3646833013,0.9472140762],[0.3186180422,0.9325513197],[0.0823264879,0.0000000000]]]
+ cloud_brightness: [[[0.4558541267,0.9574780059],[0.2744727256,0.8944309678],[0.1938559693,0.5249266862],[0.8905932438,0.2375366569],[0.6429901728,0.9589492375],[0.7581600000,0.8914912023],[0.2226478119,0.7859268915],[0.8406909789,0.4897360704],[0.5451055662,0.9618768328],[0.9462571977,0.0000000000],[1.0000000000,0.0000000000],[0.3646833013,0.9472140762],[0.3186180422,0.9325513197],[0.0823264879,0.0000000000],[0.4932562620,0.9526462396]]]
color_correction:
camera_iso: [[[0.4708024067,0.2757660168]]]
camera_shutter: [[[0.5134061147,0.0552217053]]]
@@ -17,8 +17,8 @@ control_points:
scattering:
sun_intensity: [[[0.0000000000,0.0000000000],[0.0041666667,0.0000000000],[0.0083333333,0.0000000000],[0.0125000000,0.0000000000],[0.0166666667,0.0000000000],[0.0208333333,0.0000000000],[0.0250000000,0.0000000000],[0.0291666667,0.0000000000],[0.0333333333,0.0000000000],[0.0375000000,0.0000000000],[0.0416666667,0.0000000000],[0.0458333333,0.0000000000],[0.0500000000,0.0000000000],[0.0541666667,0.0000000000],[0.0583333333,0.0000000000],[0.0625000000,0.0000000000],[0.0666666667,0.0000000000],[0.0708333333,0.0000000000],[0.0750000000,0.0000000000],[0.0791666667,0.0000000000],[0.0833333333,0.0000000000],[0.0875000000,0.0000000000],[0.0916666667,0.0000000000],[0.0958333333,0.0000000000],[0.1000000000,0.0000000000],[0.1041666667,0.0000000000],[0.1083333333,0.0000000000],[0.1125000000,0.0000000000],[0.1166666667,0.0000000000],[0.1208333333,0.0000000000],[0.1250000000,0.0000000000],[0.1291666667,0.0000000000],[0.1333333333,0.0000000000],[0.1375000000,0.0000000000],[0.1416666667,0.0000000000],[0.1458333333,0.0000000000],[0.1500000000,0.0000000000],[0.1541666667,0.0000000000],[0.1583333333,0.0000028805],[0.1625000000,0.0003577724],[0.1666666667,0.0013331400],[0.1708333333,0.0029671803],[0.1750000000,0.0052963381],[0.1791666667,0.0083550556],[0.1833333333,0.0121755589],[0.1875000000,0.0167876159],[0.1916666667,0.0222183530],[0.1958333333,0.0284919947],[0.2000000000,0.0356297193],[0.2041666667,0.0436494349],[0.2083333333,0.0525656099],[0.2125000000,0.0623891610],[0.2166666667,0.0731272461],[0.2208333333,0.0847831708],[0.2250000000,0.0973563167],[0.2291666667,0.1108419698],[0.2333333333,0.1252313631],[0.2375000000,0.1405115250],[0.2416666667,0.1566653434],[0.2458333333,0.1736715009],[0.2500000000,0.1915046014],[0.2541666667,0.2101350464],[0.2583333333,0.2295292930],[0.2625000000,0.2496498145],[0.2666666667,0.2704552670],[0.2708333333,0.2919006662],[0.2750000000,0.3139375192],[0.2791666667,0.3365139497],[0.2833333333,0.3595750662],[0.2875000000,0.3830630359],[0.2916666667,0.4069173972],[0.2958333333,0.4310753462],[0.3000000000,0.4554720417],[0.3041666667,0.4800408236],[0.3083333333,0.5047136020],[0.3125000000,0.5294212108],[0.3166666667,0.5540936424],[0.3208333333,0.5786605298],[0.3250000000,0.6030514553],[0.3291666667,0.6271963182],[0.3333333333,0.6510256858],[0.3375000000,0.6744711982],[0.3416666667,0.6974659988],[0.3458333333,0.7199450163],[0.3500000000,0.7418453485],[0.3541666667,0.7631067095],[0.3583333333,0.7836717291],[0.3625000000,0.8034862953],[0.3666666667,0.8224999302],[0.3708333333,0.8406661079],[0.3750000000,0.8579425235],[0.3791666667,0.8742914270],[0.3833333333,0.8896799131],[0.3875000000,0.9040801386],[0.3916666667,0.9174695289],[0.3958333333,0.9298310650],[0.4000000000,0.9411533765],[0.4041666667,0.9514309312],[0.4083333333,0.9606641691],[0.4125000000,0.9688595571],[0.4166666667,0.9760296330],[0.4208333333,0.9821930708],[0.4250000000,0.9873746114],[0.4291666667,0.9916050060],[0.4333333333,0.9949209310],[0.4375000000,0.9973647924],[0.4416666667,0.9989845508],[0.4458333333,0.9998334497],[0.4500000000,0.9999696949],[0.4541666667,0.9994560801],[0.4583333333,0.9983595429],[0.4625000000,0.9967506613],[0.4666666667,0.9947030614],[0.4708333333,0.9922927758],[0.4750000000,0.9895975125],[0.4791666667,0.9866958610],[0.4833333333,0.9836664262],[0.4875000000,0.9805868867],[0.4916666667,0.9775330316],[0.4958333333,0.9745777179],[0.5000000000,0.9717898417],[0.5041666667,0.9692332877],[0.5083333333,0.9669658924],[0.5125000000,0.9650384806],[0.5089595376,0.9690650222],[0.5208333333,0.9623666659],[0.5250000000,0.9616814371],[0.5291666667,0.9614534423],[0.5333333333,0.9616877089],[0.5375000000,0.9623790807],[0.5416666667,0.9635123329],[0.5458333333,0.9650624244],[0.5500000000,0.9669949804],[0.5541666667,0.9692669864],[0.5583333333,0.9718275065],[0.5625000000,0.9746185969],[0.5666666667,0.9775762863],[0.5708333333,0.9806315864],[0.5750000000,0.9837115661],[0.5791666667,0.9867403433],[0.5833333333,0.9896401655],[0.5875000000,0.9923323562],[0.5916666667,0.9947382579],[0.5958333333,0.9967800977],[0.6000000000,0.9983817820],[0.6041666667,0.9994696263],[0.6083333333,0.9999730028],[0.6125000000,0.9998249266],[0.6166666667,0.9989625601],[0.6208333333,0.9973276624],[0.6250000000,0.9948669567],[0.6291666667,0.9915324664],[0.6333333333,0.9872817545],[0.6375000000,0.9820781426],[0.6416666667,0.9758908775],[0.6458333333,0.9686952146],[0.6500000000,0.9604725211],[0.6541666667,0.9512102537],[0.6583333333,0.9409019858],[0.6625000000,0.9295473441],[0.6666666667,0.9171518878],[0.6708333333,0.9037270619],[0.6750000000,0.8892899902],[0.6791666667,0.8738633008],[0.6833333333,0.8574749656],[0.6875000000,0.8401579787],[0.6916666667,0.8219502453],[0.6958333333,0.8028941798],[0.7000000000,0.7830364456],[0.7041666667,0.7624277344],[0.7083333333,0.7411222520],[0.7125000000,0.7191776044],[0.7166666667,0.6966542563],[0.7208333333,0.6736152714],[0.7250000000,0.6501259629],[0.7291666667,0.6262533880],[0.7333333333,0.6020661121],[0.7375000000,0.5776338043],[0.7416666667,0.5530267796],[0.7458333333,0.5283156992],[0.7500000000,0.5035711751],[0.7541666667,0.4788634341],[0.7583333333,0.4542618347],[0.7625000000,0.4298347613],[0.7666666667,0.4056490351],[0.7708333333,0.3817697830],[0.7750000000,0.3582600107],[0.7791666667,0.3351803495],[0.7833333333,0.3125888445],[0.7875000000,0.2905406366],[0.7916666667,0.2690876955],[0.7958333333,0.2482787388],[0.8000000000,0.2281588906],[0.8041666667,0.2087696425],[0.8083333333,0.1901486315],[0.8125000000,0.1723295359],[0.8166666667,0.1553419918],[0.8208333333,0.1392115328],[0.8250000000,0.1239595144],[0.8291666667,0.1096030703],[0.8333333333,0.0961551918],[0.8375000000,0.0836246599],[0.8416666667,0.0720161369],[0.8458333333,0.0613302273],[0.8500000000,0.0515635598],[0.8541666667,0.0427088803],[0.8583333333,0.0347551990],[0.8625000000,0.0276878920],[0.8666666667,0.0214889271],[0.8708333333,0.0161369711],[0.8750000000,0.0116076130],[0.8791666667,0.0078735477],[0.8833333333,0.0049047927],[0.8875000000,0.0026688977],[0.8916666667,0.0011311782],[0.8958333333,0.0002549473],[0.9000000000,0.0000000000],[0.9041666667,0.0000000000],[0.9083333333,0.0000000000],[0.9125000000,0.0000000000],[0.9166666667,0.0000000000],[0.9208333333,0.0000000000],[0.9250000000,0.0000000000],[0.9291666667,0.0000000000],[0.9333333333,0.0000000000],[0.9375000000,0.0000000000],[0.9416666667,0.0000000000],[0.9458333333,0.0000000000],[0.9500000000,0.0000000000],[0.9541666667,0.0000000000],[0.9583333333,0.0000000000],[0.9625000000,0.0000000000],[0.9666666667,0.0000000000],[0.9708333333,0.0000000000],[0.9750000000,0.0000000000],[0.9791666667,0.0000000000],[0.9833333333,0.0000000000],[0.9875000000,0.0000000000],[0.9916666667,0.0000000000],[0.9958333333,0.0000000000]]]
sun_color: [[[0.5010435645,0.5818710306],[0.0433100000,0.8999700000],[0.8635787716,0.9130000000],[0.1785000000,0.8973600000],[0.8099800000,0.8651100000],[0.2360800000,0.7712700000],[0.6583432177,0.8485126184],[0.1266806142,0.9648102053],[0.9558541267,0.9090909091],[0.5568400771,0.7353760446]],[[0.5001318426,0.5160300000],[0.0572700000,0.6541600000],[0.2395000000,0.5976800000],[0.8104600000,0.6009000000],[0.6967400000,0.5483900000]],[[0.0862400000,0.4257800000],[0.4955600000,0.4033000000],[0.8234200000,0.4340200000]]]
- sun_azimuth: [[[0.5000000000,0.0000000000]]]
- sun_altitude: [[[0.5000000000,0.9333333333]]]
+ sun_azimuth: [[[0.5000000000,0.4833333333]]]
+ sun_altitude: [[[0.5000000000,0.9777777778]]]
extinction: [[[0.4913294798,0.6378830084]]]
volumetrics:
fog_ramp_size: [[[0.5510597303,0.7409470752]]]
diff --git a/RenderPipelineFile/rpcore/light_manager.py b/RenderPipelineFile/rpcore/light_manager.py
index b24ec006..fe9e4ceb 100644
--- a/RenderPipelineFile/rpcore/light_manager.py
+++ b/RenderPipelineFile/rpcore/light_manager.py
@@ -90,6 +90,10 @@ class LightManager(RPObject):
def remove_light(self, light):
""" Removes a light """
+ print(f'333333333333333333333333333333,{light.casts_shadows}')
+ # from RenderPipelineFile.rpcore.pynative.internal_light_manager import InternalLightManager
+ # inter = InternalLightManager()
+ # inter.remove_light(light)
self.internal_mgr.remove_light(light)
self.pta_max_light_index[0] = self.internal_mgr.max_light_index
diff --git a/RenderPipelineFile/rpcore/native/__init__.py b/RenderPipelineFile/rpcore/native/__init__.py
index 3ba9d575..a2f219a3 100644
--- a/RenderPipelineFile/rpcore/native/__init__.py
+++ b/RenderPipelineFile/rpcore/native/__init__.py
@@ -80,6 +80,7 @@ if NATIVE_CXX_LOADED:
RPObject.global_debug("CORE", "Using native core module")
from rpcore.native import native_ as _native_module # pylint: disable=wrong-import-position
else:
+ print(f'343434343434343434343434343')
from rpcore import pynative as _native_module # pylint: disable=wrong-import-position
RPObject.global_debug("CORE", "Using simulated python-wrapper module")
diff --git a/RenderPipelineFile/rpcore/native/source/pointer_slot_storage.h b/RenderPipelineFile/rpcore/native/source/pointer_slot_storage.h
index 979732ec..4c3e6964 100644
--- a/RenderPipelineFile/rpcore/native/source/pointer_slot_storage.h
+++ b/RenderPipelineFile/rpcore/native/source/pointer_slot_storage.h
@@ -161,7 +161,12 @@ public:
// Update maximum index
if (slot == _max_index) {
- while (_max_index >= 0 && !_data[_max_index--]);
+ while (_max_index >= 0 && !_data[_max_index--]);
+ // 正确的修复代码
+// while (_max_index >= 0 && _data[_max_index] == NULL) {
+// _max_index--;
+// }
+ }
}
}
diff --git a/RenderPipelineFile/rpcore/pynative/internal_light_manager.py b/RenderPipelineFile/rpcore/pynative/internal_light_manager.py
index 911ee147..eb4f5810 100644
--- a/RenderPipelineFile/rpcore/pynative/internal_light_manager.py
+++ b/RenderPipelineFile/rpcore/pynative/internal_light_manager.py
@@ -116,7 +116,25 @@ class InternalLightManager(object):
source.set_slot(slot)
def remove_light(self, light):
- print("111111111111111111111111111111111111111111111111")
+ print(f'44444444444444444444444444')
+ print("\n" + "=" * 50)
+ print(f"DEBUG: Entering remove_light for light object: {light.casts_shadows}")
+ if light:
+ print(f" - Light's Slot: {light.get_slot() if light.has_slot() else 'No Slot'}")
+ print(f" - Does it cast shadows? light.get_casts_shadows() -> {light.get_casts_shadows()}")
+ else:
+ print(" - Light object is None!")
+
+ print("\n --- State of Light System BEFORE removal ---")
+ if hasattr(self, '_lights') and hasattr(self._lights, '_data'):
+ # 打印出当前所有灯光对象，看看有没有异常
+ print(f" - Light Data Array (_data):")
+ for i, l_obj in enumerate(self._lights._data):
+ print(f" [{i}]: {l_obj}")
+
+ print(f"\n - Max Index (_max_index): {self._lights._max_index}")
+ print(f" - Num Entries (_num_entries): {self._lights._num_entries}")
+ print("=" * 50 + "\n")
assert light is not None
if not light.has_slot():
print("ERROR: Could not detach light, light was not attached!")
@@ -133,7 +151,10 @@ class InternalLightManager(object):
# 关键修复：先保存第一个source的slot，再清理
first_source = light.get_shadow_source(0)
first_source_slot = first_source.get_slot() # 保存slot值
-
+
+ # --- 在这里加上打印语句 ---
+ print(f"DEBUG: Removing shadow sources. Start Slot: {first_source_slot}, Count: {num_sources}")
+
# 先发送GPU移除命令（在清理之前）
cmd_remove = GPUCommand(GPUCommand.CMD_remove_sources)
cmd_remove.push_int(first_source_slot) # 使用保存的slot值
diff --git a/RenderPipelineFile/rpcore/render_pipeline.py b/RenderPipelineFile/rpcore/render_pipeline.py
index 0424783f..a7ac29df 100644
--- a/RenderPipelineFile/rpcore/render_pipeline.py
+++ b/RenderPipelineFile/rpcore/render_pipeline.py
@@ -208,6 +208,7 @@ class RenderPipeline(RPObject):
def remove_light(self, light):
""" Removes a previously attached light, check out the LightManager
remove_light documentation for further information. """
+ print(f'222222222222222222222222222,{light.casts_shadows}')
self.light_mgr.remove_light(light)
def load_ies_profile(self, filename):
diff --git a/Resources/models/DancingTwerk.glb b/Resources/models/DancingTwerk.glb
new file mode 100644
index 00000000..1567bf93
Binary files /dev/null and b/Resources/models/DancingTwerk.glb differ
diff --git a/Resources/models/Haqijingzhu.glb b/Resources/models/Haqijingzhu.glb
new file mode 100644
index 00000000..0b5e1df0
Binary files /dev/null and b/Resources/models/Haqijingzhu.glb differ
diff --git a/Resources/models/JQB_auto_converted.glb b/Resources/models/JQB_auto_converted.glb
new file mode 100644
index 00000000..89df9e5b
Binary files /dev/null and b/Resources/models/JQB_auto_converted.glb differ
diff --git a/Resources/models/Women_1.glb b/Resources/models/Women_1.glb
new file mode 100644
index 00000000..79ebe8d2
Binary files /dev/null and b/Resources/models/Women_1.glb differ
diff --git a/Resources/models/Women_2.glb b/Resources/models/Women_2.glb
new file mode 100644
index 00000000..efba7b02
Binary files /dev/null and b/Resources/models/Women_2.glb differ
diff --git a/Resources/models/women_1.glb b/Resources/models/women_1.glb
new file mode 100644
index 00000000..f634ea92
Binary files /dev/null and b/Resources/models/women_1.glb differ
diff --git a/Start_Run.py b/Start_Run.py
new file mode 100644
index 00000000..8e6a1214
--- /dev/null
+++ b/Start_Run.py
@@ -0,0 +1,34 @@
+import os
+import sys
+
+# 添加项目根目录到 Python 路径
+project_root = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, project_root)
+
+# 添加 RenderPipeline 到路径（注意路径名称应与实际目录一致）
+render_pipeline_path = os.path.join(project_root, "RenderPipeline")
+sys.path.insert(0, render_pipeline_path)
+
+# 添加 RenderPipelineFile 路径
+render_pipeline_file_path = os.path.join(project_root, "RenderPipelineFile")
+sys.path.insert(0, render_pipeline_file_path)
+
+# 添加 icons 目录到路径
+icons_path = os.path.join(project_root, "icons")
+sys.path.insert(0, icons_path)
+
+# 现在可以导入并运行主程序
+if __name__ == "__main__":
+ args = sys.argv[1:]
+ # args = "/home/tiger/桌面/Test1"
+ # args = "C:/Users/29381/Desktop/1"
+ print(f'Path is {args}')
+ # 将整个列表转换为字符串（包括方括号）
+ args_str = ''.join(args)
+
+ from main import run
+ if args:
+ run(args_str)
+ # run(args)
+ else:
+ run()
\ No newline at end of file
diff --git a/core/InfoPanelManager.py b/core/InfoPanelManager.py
index dbe6dede..35000ffe 100644
--- a/core/InfoPanelManager.py
+++ b/core/InfoPanelManager.py
@@ -1,6 +1,7 @@
# 修改后的 InfoPanelManager.py
from xml.sax.handler import property_encoding
+from PyQt5.QtCore import Qt
from direct.gui.DirectGui import DirectFrame, DirectLabel
from direct.showbase.ShowBaseGlobal import aspect2d
from panda3d.core import TextNode, Vec4, NodePath
@@ -144,7 +145,7 @@ class InfoPanelManager(DirectObject):
text_scale=0.045,
text_fg=content_color,
text_align=TextNode.ALeft,
- text_wordwrap=500, # 设置一个非常大的值，几乎不自动换行
+ text_wordwrap=0, # 设置一个非常大的值，几乎不自动换行
pos=(-size[0] / 2 + 0.03, 0, size[1] / 2 - title_bar_height - 0.05),
parent=panel_node,
relief=None,
@@ -182,12 +183,60 @@ class InfoPanelManager(DirectObject):
panel_node.setTag("gui_type", "info_panel")
panel_node.setTag("panel_id", panel_id)
panel_node.setTag("supports_3d_position_editing", "1") # 支持3D位置编辑
+ panel_node.setTag("is_gui_element",'1')
+ panel_node.setTag("tree_item_type","INFO_PANEL")
+ panel_node.setTag("supports_3d_position_editing","1")
+
+ # 如果有背景图片，保存背景图片路径
+ if bg_image:
+ panel_node.setTag("bg_image_path", bg_image)
+
if not visible:
panel_node.hide()
+ # 将面板添加到场景树
+ #self._addPanelToSceneTree(panel_node, panel_id)
+
return panel_node
+ def _addPanelToSceneTree(self, panel_node, panel_id):
+ """
+ 将信息面板添加到场景树中
+ """
+ try:
+ # 获取树形控件
+ if hasattr(self.world, 'interface_manager') and hasattr(self.world.interface_manager, 'treeWidget'):
+ tree_widget = self.world.interface_manager.treeWidget
+ if tree_widget:
+ # 查找根节点项
+ root_item = None
+ for i in range(tree_widget.topLevelItemCount()):
+ item = tree_widget.topLevelItem(i)
+ if item.text(0) == "render" or item.data(0, Qt.UserRole) == self.world.render:
+ root_item = item
+ break
+
+ if root_item:
+ # 使用现有的 add_node_to_tree_widget 方法添加节点
+ qt_item = tree_widget.add_node_to_tree_widget(panel_node, root_item, "INFO_PANEL")
+ if qt_item:
+ print(f"✅ 信息面板 {panel_id} 已添加到场景树")
+ # 选中创建的节点
+ tree_widget.setCurrentItem(qt_item)
+ # 更新选择和属性面板
+ tree_widget.update_selection_and_properties(panel_node, qt_item)
+ else:
+ print(f"⚠️ 信息面板 {panel_id} 添加到场景树失败")
+ else:
+ print("⚠️ 未找到场景树根节点，无法添加信息面板")
+ else:
+ print("⚠️ 无法访问场景树控件，信息面板未添加到场景树")
+ except Exception as e:
+ print(f"❌ 添加信息面板到场景树时出错: {e}")
+ import traceback
+ traceback.print_exc()
+
def setPanelBackgroundImage(self, panel_id, image_path):
"""
为指定面板设置背景图片
@@ -317,11 +366,10 @@ class InfoPanelManager(DirectObject):
return True
+ # 更新 registerDataSource 方法以更好地处理不同类型面板
def registerDataSource(self, panel_id, data_callback, update_interval=1.0):
"""
- 注册数据源，定期更新面板内容
- data_callback: 返回数据的回调函数
- update_interval: 更新间隔（秒）
+ 注册数据源，定期更新面板内容 - 改进版
"""
if panel_id not in self.panels:
print(f"面板 {panel_id} 不存在")
@@ -335,7 +383,8 @@ class InfoPanelManager(DirectObject):
data_source = {
'callback': data_callback,
'interval': update_interval,
- 'stop': False
+ 'stop': False,
+ 'panel_type': '3d' if self._is3DPanel(panel_id) else '2d' if self._is2DPanel(panel_id) else 'unknown'
}
self.data_sources[panel_id] = data_source
@@ -346,9 +395,10 @@ class InfoPanelManager(DirectObject):
return True
+ # 在 InfoPanelManager 类中修复 _updateDataThread 方法
def _updateDataThread(self, panel_id):
"""
- 数据更新线程
+ 数据更新线程 - 最终修复版
"""
while panel_id in self.data_sources and not self.data_sources[panel_id]['stop']:
try:
@@ -357,7 +407,18 @@ class InfoPanelManager(DirectObject):
# 更新面板内容
if data and panel_id in self.panels:
- self.updatePanelContent(panel_id, content=data)
+ panel_type = self.data_sources[panel_id].get('panel_type', 'unknown')
+
+ if panel_type == '2d':
+ self.updatePanelContent(panel_id, content=data)
+ elif panel_type == '3d':
+ self.update3DPanelContent(panel_id, content=data)
+ else:
+ # 尝试自动检测
+ if self._is2DPanel(panel_id):
+ self.updatePanelContent(panel_id, content=data)
+ elif self._is3DPanel(panel_id):
+ self.update3DPanelContent(panel_id, content=data)
# 等待下次更新
interval = self.data_sources[panel_id]['interval']
@@ -365,8 +426,29 @@ class InfoPanelManager(DirectObject):
except Exception as e:
print(f"更新面板 {panel_id} 数据时出错: {e}")
+ import traceback
+ traceback.print_exc()
time.sleep(1.0) # 出错时等待1秒再重试
+ # 在 InfoPanelManager 类中添加以下方法
+ def _is3DPanel(self, panel_id):
+ """
+ 判断面板是否为3D面板
+ """
+ if panel_id not in self.panels:
+ return False
+ panel_data = self.panels[panel_id]
+ return 'content_node' in panel_data and 'content_label' not in panel_data
+
+ def _is2DPanel(self, panel_id):
+ """
+ 判断面板是否为2D面板
+ """
+ if panel_id not in self.panels:
+ return False
+ panel_data = self.panels[panel_id]
+ return 'content_label' in panel_data and 'content_node' not in panel_data
+
def unregisterDataSource(self, panel_id):
"""
注销数据源
@@ -447,9 +529,7 @@ class InfoPanelManager(DirectObject):
-size[0] / 2 + 0.03, 0, size[1] / 2 - title_bar_height - 0.05
)
- # 设置一个非常大的换行值，几乎不自动换行
- panel_data['content_label']['text_wordwrap'] = 500
- print(f"更新面板换行: 设置为500（几乎不换行）")
+ panel_data['content_label']['text_wordwrap'] = 0
# 如果有背景图片，也需要更新其大小
if 'bg_image' in panel_data and panel_data['bg_image']:
@@ -493,8 +573,9 @@ class InfoPanelManager(DirectObject):
if 'content_size' in properties:
panel_data['content_label']['text_scale'] = properties['content_size']
props['content_size'] = properties['content_size']
+ current_size = props.get('size',(1.0,0.6))
# 当字体大小改变时，仍然保持较大的换行值
- panel_data['content_label']['text_wordwrap'] = 500
+ panel_data['content_label']['text_wordwrap'] = 0
# 更新背景图片
if 'bg_image' in properties:
@@ -657,10 +738,247 @@ class InfoPanelManager(DirectObject):
return True
+ def create3DInfoPanel(self, panel_id, position=(0, 0, 0), size=(1.0, 0.6),
+ bg_color=(0.15, 0.15, 0.15, 0.9), border_color=(0.3, 0.3, 0.3, 1.0),
+ title_color=(1.0, 1.0, 1.0, 1.0), content_color=(0.9, 0.9, 0.9, 1.0),
+ visible=True, font=None, bg_image=None):
+ """
+ 创建简化版3D信息面板 - 只显示文字，无面板背景，避免闪烁
+ """
+ # 如果面板已存在，先移除它
+ if panel_id in self.panels:
+ self.removePanel(panel_id)
+
+ # 确保父节点存在
+ parent_node = self.parent if self.parent else self.world.render
+
+ # 根据面板ID确定标题和内容
+ title, content = self._getPanelContent(panel_id)
+
+ # 创建主节点，便于统一管理
+ panel_node = parent_node.attachNewNode(f"info_panel_3d_{panel_id}")
+ panel_node.setPos(position[0], position[1], position[2])
+
+ # 直接创建文字节点，不创建面板背景和边框
+ from panda3d.core import TextNode
+
+ # 创建标题文本
+ title_text_node = TextNode(f'title_{panel_id}')
+ title_text_node.setText(title)
+ title_text_node.setTextColor(*title_color)
+ title_text_node.setAlign(TextNode.ACenter)
+ if font:
+ title_text_node.setFont(font)
+
+ title_text = panel_node.attachNewNode(title_text_node)
+ title_text.setScale(0.06)
+ title_text.setPos(0, 0, size[1] / 4) # 将标题放在上方
+
+ # 创建内容文本
+ content_text_node = TextNode(f'content_{panel_id}')
+ content_text_node.setText(content)
+ content_text_node.setTextColor(*content_color)
+ content_text_node.setAlign(TextNode.ALeft)
+ content_text_node.setWordwrap(size[0] * 2) # 根据面板宽度设置换行
+ if font:
+ content_text_node.setFont(font)
+
+ content_text = panel_node.attachNewNode(content_text_node)
+ content_text.setScale(0.045)
+ content_text.setPos(-size[0] / 2, 0, size[1] / 4 - 0.1) # 将内容放在标题下方
+
+ # 保存引用
+ self.panels[panel_id] = {
+ 'node': panel_node,
+ 'title_text': title_text,
+ 'content_text': content_text,
+ 'title_node': title_text_node,
+ 'content_node': content_text_node,
+ 'properties': {
+ 'size': size,
+ 'position': position,
+ 'title_color': title_color,
+ 'content_color': content_color,
+ 'font': font
+ }
+ }
+
+ # 设置GUI类型标记和支持3D编辑的标记
+ panel_node.setTag("gui_type", "info_panel_3d")
+ panel_node.setTag("panel_id", panel_id)
+ panel_node.setTag("is_gui_element", "1") # 添加此标记确保节点被识别为GUI元素
+ panel_node.setTag("is_scene_element", "1") # 添加此标记确保节点被识别为场景元素
+ panel_node.setTag("supports_3d_position_editing", "1") # 支持3D位置编辑
+ panel_node.setTag("tree_item_type", "INFO_PANEL_3D") # 添加树节点类型标记
+
+ # 如果有背景图片，保存背景图片路径
+ if bg_image:
+ panel_node.setTag("bg_image_path", bg_image)
+
+ if not visible:
+ panel_node.hide()
+
+ # 将面板添加到场景树
+ #self._addPanelToSceneTree(panel_node, panel_id)
+
+ return panel_node
+
+ def update3DPanelContent(self, panel_id, title=None, content=None):
+ """
+ 更新3D面板内容
+ """
+ if panel_id not in self.panels:
+ print(f"面板 {panel_id} 不存在")
+ return False
+
+ panel_data = self.panels[panel_id]
+
+ if title is not None and 'title_node' in panel_data:
+ panel_data['title_node'].setText(title)
+
+ if content is not None and 'content_node' in panel_data:
+ panel_data['content_node'].setText(content)
+
+ return True
+
+ def update3DPanelProperties(self, panel_id, **properties):
+ """
+ 更新3D面板属性
+ """
+ if panel_id not in self.panels:
+ print(f"面板 {panel_id} 不存在")
+ return False
+
+ panel_data = self.panels[panel_id]
+ props = panel_data['properties']
+
+ # 更新位置
+ if 'position' in properties:
+ pos = properties['position']
+ panel_data['node'].setPos(pos[0], pos[1], pos[2])
+ props['position'] = pos
+
+ # 更新大小
+ if 'size' in properties:
+ size = properties['size']
+ props['size'] = size
+
+ # 由于3D面板使用CardMaker创建，需要重新创建几何体
+ print("注意：3D面板大小调整需要重新创建面板几何体")
+
+ # 更新背景颜色
+ if 'bg_color' in properties:
+ bg_color = properties['bg_color']
+ if 'panel_bg' in panel_data:
+ from panda3d.core import Material
+ material = Material()
+ material.setDiffuse(Vec4(*bg_color))
+ material.setAmbient(Vec4(*bg_color[:3], 1.0))
+ panel_data['panel_bg'].setMaterial(material, 1)
+ props['bg_color'] = bg_color
+
+ # 更新边框颜色
+ if 'border_color' in properties:
+ border_color = properties['border_color']
+ from panda3d.core import Material
+ border_mat = Material()
+ border_mat.setDiffuse(Vec4(*border_color))
+ for border in panel_data['borders'].values():
+ border.setMaterial(border_mat, 1)
+ props['border_color'] = border_color
+
+ # 更新标题颜色
+ if 'title_color' in properties:
+ title_color = properties['title_color']
+ if 'title_node' in panel_data:
+ panel_data['title_node'].setTextColor(*title_color)
+ props['title_color'] = title_color
+
+ # 更新内容颜色
+ if 'content_color' in properties:
+ content_color = properties['content_color']
+ if 'content_node' in panel_data:
+ panel_data['content_node'].setTextColor(*content_color)
+ props['content_color'] = content_color
+
+ # 更新标题
+ if 'title' in properties:
+ if 'title_node' in panel_data:
+ panel_data['title_node'].setText(properties['title'])
+
+ # 更新内容
+ if 'content' in properties:
+ if 'content_node' in panel_data:
+ panel_data['content_node'].setText(properties['content'])
+
+ # 更新字体大小
+ if 'title_size' in properties:
+ if 'title_text' in panel_data:
+ panel_data['title_text'].setScale(properties['title_size'])
+ props['title_size'] = properties['title_size']
+
+ if 'content_size' in properties:
+ if 'content_text' in panel_data:
+ panel_data['content_text'].setScale(properties['content_size'])
+ props['content_size'] = properties['content_size']
+
+ return True
+
+ def create3DHTTPInfoPanel(self, panel_id, url, method="GET", headers=None, data=None,
+ position=(0, 0, 0), size=(1.0, 0.6),
+ bg_color=(0.15, 0.15, 0.15, 0.9),
+ border_color=(0.3, 0.3, 0.3, 1.0),
+ title_color=(1.0, 1.0, 1.0, 1.0),
+ content_color=(0.9, 0.9, 0.9, 1.0),
+ update_interval=30.0, font=None):
+ """
+ 创建3D HTTP信息面板
+ """
+ # 创建面板
+ domain = urlparse(url).netloc or url[:30]
+ title = f"HTTP数据: {domain}"
+
+ panel_node = self.create3DInfoPanel(
+ panel_id=panel_id,
+ position=position,
+ size=size,
+ bg_color=bg_color,
+ border_color=border_color,
+ title_color=title_color,
+ content_color=content_color,
+ font=font
+ )
+
+ # 更新标题
+ self.update3DPanelContent(panel_id, title=title)
+
+ # 立即获取并显示数据
+ content = fetchHTTPData(url, method, headers, data)
+ self.update3DPanelContent(panel_id, content=content)
+
+ # 注册数据源，定期更新
+ def http_data_callback():
+ return fetchHTTPData(url, method, headers, data)
+
+ self.registerDataSource(panel_id, http_data_callback, update_interval)
+
+ # 保存HTTP请求信息，便于后续更新
+ if panel_id not in self.data_sources:
+ self.data_sources[panel_id] = {}
+ self.data_sources[panel_id]['http_info'] = {
+ 'url': url,
+ 'method': method,
+ 'headers': headers,
+ 'data': data
+ }
+
+ return panel_node
+
# 在 add_methods_to_property_panel 函数中添加以下方法
def add_methods_to_property_panel(property_panel_instance):
# ... (原有代码保持不变)
+ import types
def createHTTPInfoPanel(self, url, panel_id="http_info", method="GET", headers=None, data=None,
position=(0.8, 0.0), size=(0.4, 0.3), update_interval=30.0):
@@ -721,12 +1039,233 @@ class InfoPanelManager(DirectObject):
print(f"✗ 更新HTTP信息面板失败: {e}")
return False
+ def create3DRealtimeDataPanel(self, data_callback=None, update_interval=1.0):
+ """创建3D实时数据面板"""
+ try:
+ # 确保父节点已设置
+ if self.info_panel_manager.parent is None and hasattr(self, 'world'):
+ self.info_panel_manager.setParent(self.world.render)
+
+ # 创建3D实时数据面板
+ panel_node = self.info_panel_manager.create3DInfoPanel(
+ panel_id="realtime_data_3d",
+ position=(0, 0, 0),
+ size=(0.35, 0.3),
+ bg_color=(0.15, 0.25, 0.35, 0.95), # 蓝色背景
+ border_color=(0.3, 0.5, 0.7, 1.0), # 蓝色边框
+ title_color=(0.7, 0.9, 1.0, 1.0), # 浅蓝色标题
+ content_color=(0.95, 0.95, 0.95, 1.0)
+ )
+
+ # 设置标签
+ panel_node.setTag("element_type", "info_panel_3d")
+ panel_node.setTag("is_scene_element", "1")
+ panel_node.setTag("supports_3d_position_editing", "1") # 支持3D位置编辑
+
+ # 如果提供了数据回调函数，则注册数据源
+ if data_callback:
+ # 立即显示初始数据
+ initial_data = data_callback()
+ self.info_panel_manager.update3DPanelContent("realtime_data_3d", content=initial_data)
+
+ # 注册数据源
+ self.info_panel_manager.registerDataSource("realtime_data_3d", data_callback, update_interval)
+ else:
+ # 使用默认数据
+ default_data = "等待数据..."
+ self.info_panel_manager.update3DPanelContent("realtime_data_3d", content=default_data)
+
+ print("✓ 已创建3D实时数据面板")
+
+ return panel_node
+
+ except Exception as e:
+ print(f"✗ 创建3D实时数据面板失败: {e}")
+ return None
+
+ def create3DModelInfoPanel(self, model):
+ """为模型创建3D信息面板"""
+ try:
+ # 确保父节点已设置
+ if self.info_panel_manager.parent is None and hasattr(self, 'world'):
+ self.info_panel_manager.setParent(self.world.render)
+
+ # 获取模型信息
+ model_name = model.getName() if hasattr(model, 'getName') else 'Unknown'
+ num_children = model.getNumChildren() if hasattr(model, 'getNumChildren') else 0
+
+ # 创建面板内容
+ content = f"模型名称: {model_name}\n子节点数: {num_children}\n类型: {type(model).__name__}"
+
+ # 创建或更新面板
+ panel_node = self.info_panel_manager.create3DInfoPanel(
+ panel_id="model_info_3d",
+ position=(2, 0, 0), # 默认放在模型旁边
+ size=(0.35, 0.25),
+ bg_color=(0.15, 0.15, 0.25, 0.95), # 蓝紫色背景
+ border_color=(0.3, 0.3, 0.7, 1.0), # 蓝色边框
+ title_color=(0.5, 0.8, 1.0, 1.0), # 浅蓝色标题
+ content_color=(0.95, 0.95, 0.95, 1.0)
+ )
+
+ # 更新面板内容为模型特定信息
+ self.info_panel_manager.update3DPanelContent("model_info_3d",
+ title="模型信息",
+ content=content)
+
+ # 设置标签
+ panel_node.setTag("element_type", "info_panel_3d")
+ panel_node.setTag("is_scene_element", "1")
+ panel_node.setTag("supports_3d_position_editing", "1") # 支持3D位置编辑
+
+ print(f"✓ 已创建3D模型信息面板: {model_name}")
+
+ return panel_node
+
+ except Exception as e:
+ print(f"✗ 创建3D模型信息面板失败: {e}")
+ return None
+
+ # 在绑定方法的部分添加3D面板方法
+ property_panel_instance.create3DRealtimeDataPanel = types.MethodType(create3DRealtimeDataPanel,
+ property_panel_instance)
+ property_panel_instance.create3DModelInfoPanel = types.MethodType(create3DModelInfoPanel,
+ property_panel_instance)
+
# 将新方法绑定到实例
- import types
# ... (原有绑定保持不变)
property_panel_instance.createHTTPInfoPanel = types.MethodType(createHTTPInfoPanel, property_panel_instance)
property_panel_instance.updateHTTPInfoPanel = types.MethodType(updateHTTPInfoPanel, property_panel_instance)
+ def serializePanelData(self, panel_id):
+ """序列化面板数据用于保存"""
+ if panel_id not in self.panels:
+ return None
+
+ panel_data = self.panels[panel_id]
+ props = panel_data['properties']
+
+ # 获取面板类型
+ panel_type = "2d"
+ if panel_data['node'].hasTag("gui_type"):
+ gui_type = panel_data['node'].getTag("gui_type")
+ if "3d" in gui_type.lower():
+ panel_type = "3d"
+
+ # 构建序列化数据
+ serialized_data = {
+ 'panel_id': panel_id,
+ 'panel_type': panel_type,
+ 'position': props.get('position', (0, 0) if panel_type == "2d" else (0, 0, 0)),
+ 'size': props.get('size', (1.0, 0.6)),
+ 'bg_color': props.get('bg_color', (0.15, 0.15, 0.15, 0.9)),
+ 'border_color': props.get('border_color', (0.3, 0.3, 0.3, 1.0)),
+ 'title_color': props.get('title_color', (1.0, 1.0, 1.0, 1.0)),
+ 'content_color': props.get('content_color', (0.9, 0.9, 0.9, 1.0)),
+ 'title': panel_data['title_label'].getText() if 'title_label' in panel_data else "信息面板",
+ 'content': panel_data[
+ 'content_label'].getText() if 'content_label' in panel_data else "" if 'content_node' not in panel_data else
+ panel_data['content_node'].getText(),
+ 'font_path': props.get('font', None),
+ 'bg_image': props.get('bg_image', None),
+ 'visible': not panel_data['node'].isHidden()
+ }
+
+ # 添加HTTP面板特有数据
+ if panel_id in self.data_sources and 'http_info' in self.data_sources[panel_id]:
+ serialized_data['http_info'] = self.data_sources[panel_id]['http_info']
+
+ return serialized_data
+
+ def getAllPanelData(self):
+ """获取所有面板的序列化数据"""
+ panel_data_list = []
+ for panel_id in self.panels:
+ data = self.serializePanelData(panel_id)
+ if data:
+ panel_data_list.append(data)
+ return panel_data_list
+
+ def recreatePanelFromData(self, panel_data):
+ """从序列化数据重新创建面板"""
+ try:
+ panel_id = panel_data['panel_id']
+ panel_type = panel_data['panel_type']
+ position = panel_data['position']
+ size = panel_data['size']
+
+ # 重建面板
+ if panel_type == "3d":
+ panel_node = self.create3DInfoPanel(
+ panel_id=panel_id,
+ position=position,
+ size=size,
+ bg_color=panel_data.get('bg_color', (0.15, 0.15, 0.15, 0.9)),
+ border_color=panel_data.get('border_color', (0.3, 0.3, 0.3, 1.0)),
+ title_color=panel_data.get('title_color', (1.0, 1.0, 1.0, 1.0)),
+ content_color=panel_data.get('content_color', (0.9, 0.9, 0.9, 1.0)),
+ visible=panel_data.get('visible', True),
+ font=panel_data.get('font_path', None),
+ bg_image=panel_data.get('bg_image', None)
+ )
+
+ # 更新内容
+ self.update3DPanelContent(
+ panel_id,
+ title=panel_data.get('title', '信息面板'),
+ content=panel_data.get('content', '')
+ )
+ else:
+ panel_node = self.createInfoPanel(
+ panel_id=panel_id,
+ position=(position[0], position[1]) if len(position) >= 2 else (0, 0),
+ size=size,
+ bg_color=panel_data.get('bg_color', (0.15, 0.15, 0.15, 0.9)),
+ border_color=panel_data.get('border_color', (0.3, 0.3, 0.3, 1.0)),
+ title_color=panel_data.get('title_color', (1.0, 1.0, 1.0, 1.0)),
+ content_color=panel_data.get('content_color', (0.9, 0.9, 0.9, 1.0)),
+ visible=panel_data.get('visible', True),
+ font=panel_data.get('font_path', None),
+ bg_image=panel_data.get('bg_image', None)
+ )
+
+ # 更新内容
+ self.updatePanelContent(
+ panel_id,
+ title=panel_data.get('title', '信息面板'),
+ content=panel_data.get('content', '')
+ )
+
+ # 设置标签
+ if panel_node:
+ panel_node.setTag("element_type", "info_panel")
+ panel_node.setTag("is_scene_element", "1")
+ panel_node.setTag("supports_3d_position_editing", "1")
+
+ # 如果是HTTP面板，重新注册数据源
+ if 'http_info' in panel_data:
+ http_info = panel_data['http_info']
+ self.createHTTPInfoPanel(
+ panel_id=panel_id,
+ url=http_info['url'],
+ method=http_info.get('method', 'GET'),
+ headers=http_info.get('headers', None),
+ data=http_info.get('data', None),
+ position=position,
+ size=size,
+ update_interval=self.data_sources.get(panel_id, {}).get('interval',
+ 30.0) if panel_id in self.data_sources else 30.0
+ )
+
+ print(f"✓ 信息面板 {panel_id} 已重建")
+ return panel_node
+
+ except Exception as e:
+ print(f"✗ 重建信息面板 {panel_data.get('panel_id', 'unknown')} 失败: {e}")
+ import traceback
+ traceback.print_exc()
+ return None
+
# 示例数据源函数
def getRealtimeData():
@@ -777,6 +1316,7 @@ def add_methods_to_property_panel(property_panel_instance):
"""
为 property_panel 实例添加 DirectGUI 信息面板支持
"""
+ import types
# 添加信息面板管理器作为类属性
if not hasattr(property_panel_instance, 'info_panel_manager'):
@@ -982,7 +1522,6 @@ def add_methods_to_property_panel(property_panel_instance):
property_panel_instance.removeInfoPanel = types.MethodType(removeInfoPanel, property_panel_instance)
property_panel_instance.setupInfoPanelManager = types.MethodType(setupInfoPanelManager, property_panel_instance)
-
def fetchHTTPData(url, method="GET", headers=None, data=None, timeout=5):
"""
获取HTTP数据的通用函数
diff --git a/core/collision_manager.py b/core/collision_manager.py
index 041571bf..6c4b3e73 100644
--- a/core/collision_manager.py
+++ b/core/collision_manager.py
@@ -309,40 +309,81 @@ class CollisionManager:
CollisionPlane, CollisionPolygon, Plane, Vec3
)
- bounds = model.getBounds()
- if bounds.isEmpty():
+ # 获取考虑变换后的实际尺寸和中心
+ transformed_info = self._getTransformedModelInfo(model)
+ if not transformed_info:
# 默认小球体
return CollisionSphere(Point3(0, 0, 0), 1.0)
- center = bounds.getCenter()
- radius = bounds.getRadius()
+ center = transformed_info['center']
+ radius = transformed_info['radius']
+ actual_size = transformed_info['size']
+ scale_factor = transformed_info['scale_factor']
# 自动选择最适合的形状
if shape_type == 'auto':
- shape_type = self._determineOptimalShape(model, bounds)
+ shape_type = self._determineOptimalShape(model, transformed_info)
if shape_type == 'sphere':
- return CollisionSphere(center, kwargs.get('radius', radius))
+ # 优化球形碰撞体
+ sphere_radius = kwargs.get('radius', radius)
+
+ # 支持位置偏移
+ pos_offset = kwargs.get('position_offset', Vec3(0, 0, 0))
+ sphere_center = Point3(center.x + pos_offset.x, center.y + pos_offset.y, center.z + pos_offset.z)
+
+ return CollisionSphere(sphere_center, sphere_radius)
elif shape_type == 'box':
- # 创建包围盒
- min_point = bounds.getMin()
- max_point = bounds.getMax()
+ # 优化盒型碰撞体 - 更精确的尺寸和位置控制（考虑缩放）
+ # 获取自定义尺寸，如果没有提供则使用变换后的实际尺寸
+ width = kwargs.get('width', actual_size.x)
+ length = kwargs.get('length', actual_size.y)
+ height = kwargs.get('height', actual_size.z)
+
+ # 支持位置偏移
+ pos_offset = kwargs.get('position_offset', Vec3(0, 0, 0))
+ box_center = Point3(center.x + pos_offset.x, center.y + pos_offset.y, center.z + pos_offset.z)
+
+ # 计算盒子的最小和最大点（基于偏移后的中心）
+ half_width = width / 2
+ half_length = length / 2
+ half_height = height / 2
+
+ min_point = Point3(box_center.x - half_width, box_center.y - half_length, box_center.z - half_height)
+ max_point = Point3(box_center.x + half_width, box_center.y + half_length, box_center.z + half_height)
return CollisionBox(min_point, max_point)
elif shape_type == 'capsule':
- # 创建胶囊体（适合角色）
- height = kwargs.get('height', (bounds.getMax().z - bounds.getMin().z))
- radius = kwargs.get('radius', min(bounds.getRadius() * 0.5, height * 0.3))
- point_a = Point3(center.x, center.y, bounds.getMin().z + radius)
- point_b = Point3(center.x, center.y, bounds.getMax().z - radius)
- return CollisionCapsule(point_a, point_b, radius)
+ # 优化胶囊体碰撞 - 更合理的比例和位置控制（考虑缩放）
+ # 使用变换后的实际高度，或自定义高度
+ custom_height = kwargs.get('height', actual_size.z)
+
+ # 更合理的半径计算：基于变换后模型宽度的平均值
+ default_radius = min(actual_size.x, actual_size.y) / 2.5 # 稍微小于模型的宽度
+ custom_radius = kwargs.get('radius', min(default_radius, custom_height * 0.4))
+
+ # 支持位置偏移
+ pos_offset = kwargs.get('position_offset', Vec3(0, 0, 0))
+ capsule_center = Point3(center.x + pos_offset.x, center.y + pos_offset.y, center.z + pos_offset.z)
+
+ # 计算胶囊体的两个端点（确保半径不会超出高度）
+ effective_height = max(custom_height, custom_radius * 2.1) # 确保高度至少是半径的2倍多一点
+ point_a = Point3(capsule_center.x, capsule_center.y, capsule_center.z - effective_height/2 + custom_radius)
+ point_b = Point3(capsule_center.x, capsule_center.y, capsule_center.z + effective_height/2 - custom_radius)
+ return CollisionCapsule(point_a, point_b, custom_radius)
elif shape_type == 'plane':
- # 创建平面（适合地面、墙面）
+ # 优化平面碰撞 - 支持位置偏移和更灵活的法向量
normal = kwargs.get('normal', Vec3(0, 0, 1))
- point = kwargs.get('point', center)
- plane = Plane(normal, point)
+
+ # 支持位置偏移
+ pos_offset = kwargs.get('position_offset', Vec3(0, 0, 0))
+ plane_point = kwargs.get('point', Point3(center.x + pos_offset.x, center.y + pos_offset.y, center.z + pos_offset.z))
+
+ # 标准化法向量
+ normal.normalize()
+ plane = Plane(normal, plane_point)
return CollisionPlane(plane)
elif shape_type == 'polygon':
@@ -364,13 +405,13 @@ class CollisionManager:
collision_poly = CollisionPolygon(*[Point3(*v) for v in vertices])
return collision_poly
else:
- print("⚠️ 多边形至少需要3个顶点，回退到球体")
+ #print("⚠️ 多边形至少需要3个顶点，回退到球体")
return CollisionSphere(center, radius)
- def _determineOptimalShape(self, model, bounds):
+ def _determineOptimalShape(self, model, transformed_info):
"""根据模型特征自动确定最适合的碰撞体形状"""
- # 获取模型尺寸比例
- size = bounds.getMax() - bounds.getMin()
+ # 获取变换后的模型尺寸比例
+ size = transformed_info['size']
max_dim = max(size.x, size.y, size.z)
min_dim = min(size.x, size.y, size.z)
@@ -399,6 +440,87 @@ class CollisionManager:
else: # 其他用包围盒
return 'box'
+ def _getTransformedModelInfo(self, model):
+ """获取考虑变换后的模型信息
+
+ Args:
+ model: 模型节点
+
+ Returns:
+ dict: 包含变换后的尺寸、中心、半径等信息
+ """
+ try:
+ # 获取原始包围盒
+ bounds = model.getBounds()
+ if bounds.isEmpty():
+ return None
+
+ # 获取模型的变换矩阵
+ transform = model.getTransform()
+ scale = model.getScale()
+
+ # 计算缩放因子（取三轴缩放的平均值）
+ scale_factor = (abs(scale.x) + abs(scale.y) + abs(scale.z)) / 3.0
+
+ # 获取原始尺寸
+ original_size = bounds.getMax() - bounds.getMin()
+
+ # 应用缩放到尺寸
+ actual_size = Vec3(
+ original_size.x * abs(scale.x),
+ original_size.y * abs(scale.y),
+ original_size.z * abs(scale.z)
+ )
+
+ # 获取变换后的中心点（在世界坐标系中）
+ original_center = bounds.getCenter()
+ if hasattr(model, 'getPos'):
+ # 模型在世界坐标系中的位置
+ world_center = model.getPos(model.getParent() if model.getParent() else model)
+ center = Point3(world_center.x, world_center.y, world_center.z)
+ else:
+ # 如果无法获取世界位置，使用原始中心
+ center = original_center
+
+ # 计算变换后的半径（考虑缩放）
+ original_radius = bounds.getRadius()
+ transformed_radius = original_radius * scale_factor
+
+ # 调试信息
+ print(f"🔍 模型 {model.getName()} 变换信息:")
+ print(f" 原始尺寸: {original_size}")
+ print(f" 缩放因子: {scale}")
+ print(f" 变换后尺寸: {actual_size}")
+ print(f" 变换后半径: {transformed_radius:.2f}")
+
+ return {
+ 'center': center,
+ 'radius': transformed_radius,
+ 'size': actual_size,
+ 'scale_factor': scale_factor,
+ 'original_size': original_size,
+ 'scale': scale,
+ 'transform': transform
+ }
+
+ except Exception as e:
+ print(f"⚠️ 获取模型变换信息失败: {e}")
+ # 回退到原始包围盒
+ bounds = model.getBounds()
+ if bounds.isEmpty():
+ return None
+
+ original_size = bounds.getMax() - bounds.getMin()
+ return {
+ 'center': bounds.getCenter(),
+ 'radius': bounds.getRadius(),
+ 'size': original_size,
+ 'scale_factor': 1.0,
+ 'original_size': original_size,
+ 'scale': Vec3(1, 1, 1),
+ 'transform': None
+ }
+
def createMouseRay(self, screen_x, screen_y, mask_types=['SELECTABLE']):
"""创建鼠标射线"""
# 组合掩码
diff --git a/core/event_handler.py b/core/event_handler.py
index ff7b17c2..be0f6cc1 100644
--- a/core/event_handler.py
+++ b/core/event_handler.py
@@ -167,7 +167,7 @@ class EventHandler:
picker.addCollider(pickerNP, queue)
picker.traverse(self.world.render)
- print(f"碰撞检测结果数量: {queue.getNumEntries()}")
+ #print(f"碰撞检测结果数量: {queue.getNumEntries()}")
# 射线检测结果处理
hitPos = None
@@ -184,13 +184,13 @@ class EventHandler:
self.showClickRay(worldNearPoint, worldFarPoint, hitPos)
# 优先检查是否点击了坐标轴
- print(f"检查坐标轴点击: 坐标轴存在={bool(self.world.selection.gizmo)}")
+ #print(f"检查坐标轴点击: 坐标轴存在={bool(self.world.selection.gizmo)}")
if self.world.selection.gizmo:
- print("准备检查坐标轴点击...")
+ #print("准备检查坐标轴点击...")
try:
gizmoAxis = self.world.selection.checkGizmoClick(x, y)
if gizmoAxis:
- print(f"✓ 检测到坐标轴点击: {gizmoAxis}")
+ #print(f"✓ 检测到坐标轴点击: {gizmoAxis}")
# 开始坐标轴拖拽
self.world.selection.startGizmoDrag(gizmoAxis, x, y)
pickerNP.removeNode()
@@ -203,16 +203,16 @@ class EventHandler:
traceback.print_exc()
print("继续处理模型选择...")
- print("继续处理碰撞结果...")
+ #print("继续处理碰撞结果...")
if hitPos and hitNode:
- print(f"✓ 检测到碰撞，开始处理点击事件")
- print(f"GUI编辑模式: {self.world.guiEditMode}")
- print(f"当前工具: {self.world.currentTool}")
+ #print(f"✓ 检测到碰撞，开始处理点击事件")
+ #print(f"GUI编辑模式: {self.world.guiEditMode}")
+ #print(f"当前工具: {self.world.currentTool}")
# 处理GUI编辑模式
if self.world.guiEditMode:
- print("处理GUI编辑模式点击")
+ #print("处理GUI编辑模式点击")
# 检查是否点击了GUI元素
clickedGUI = self.world.gui_manager.findClickedGUI(hitNode)
if clickedGUI:
@@ -411,103 +411,6 @@ class EventHandler:
import traceback
traceback.print_exc()
-
- def mousePressEventRight(self,evt):
- """处理鼠标右键按下事件"""
- print(f"当前工具: {self.world.currentTool}")
-
- # 检查是否是地形编辑模式
- if self.world.currentTool == "地形编辑":
- self._handleTerrainEdit(evt, "subtract") # 降低地形
- return
-
- # 其他右键处理逻辑可以在这里添加
- print("鼠标右键事件处理")
-
- def _handleTerrainEdit(self,evt,operation):
- try:
- x = evt.get('x',0)
- y = evt.get('y',0)
-
- winWidth,winHeight = self.world.getWindowSize()
-
- mx = 2.0 * x/float(winWidth) - 1.0
- my = 1.0 -2.0*y/float(winHeight)
-
- nearPoint = Point3()
- farPoint = Point3()
- self.world.cam.node().getLens().extrude(Point2(mx, my), nearPoint, farPoint)
-
- worldNearPoint = self.world.render.getRelativePoint(self.world.cam, nearPoint)
- worldFarPoint = self.world.render.getRelativePoint(self.world.cam, farPoint)
-
- picker = CollisionTraverser()
- queue = CollisionHandlerQueue()
-
- pickerNode = CollisionNode('terrain_edit_ray')
- pickerNP = self.world.cam.attachNewNode(pickerNode)
-
- from panda3d.core import BitMask32
- pickerNode.setFromCollideMask(BitMask32.allOn()) # 检查所有碰撞
-
- # 使用相机坐标系的点创建射线
- direction = farPoint - nearPoint
- direction.normalize()
- pickerNode.addSolid(CollisionRay(nearPoint, direction))
-
- picker.addCollider(pickerNP, queue)
- picker.traverse(self.world.render)
- print(f"地形碰撞检测结果数量: {queue.getNumEntries()}")
-
- # 射线检测结果处理
- hitPos = None
- hitNode = None
-
- if queue.getNumEntries() > 0:
- # 遍历所有碰撞结果，找到地形节点
- for i in range(queue.getNumEntries()):
- entry = queue.getEntry(i)
- collided_node = entry.getIntoNodePath()
- print(f"碰撞到节点: {collided_node.getName()}")
-
- # 检查是否是地形节点
- for terrain_info in self.world.terrain_manager.terrains:
- terrain_node = terrain_info['node']
- if collided_node == terrain_node or terrain_node.isAncestorOf(collided_node):
- hitPos = entry.getSurfacePoint(self.world.render)
- hitNode = collided_node
- print(f"找到地形节点: {terrain_node.getName()}")
-
- # 修改地形高度
- x_pos, y_pos = hitPos.getX(), hitPos.getY()
- success = self.world.modifyTerrainHeight(
- terrain_info, x_pos, y_pos, radius=3.0, strength=0.3, operation=operation)
-
- if success:
- print(f"✓ 地形编辑成功: {operation} at ({x_pos:.2f}, {y_pos:.2f})")
- # 显示射线
- self.showClickRay(worldNearPoint, worldFarPoint, hitPos)
- else:
- print("✗ 地形编辑失败")
- break
-
- if hitPos:
- break
-
- if not hitPos:
- print("没有检测到地形碰撞")
- # 显示射线（无碰撞）
- self.showClickRay(worldNearPoint, worldFarPoint)
-
- # 清理碰撞检测节点
- pickerNP.removeNode()
- print("地形编辑处理完成")
-
- except Exception as e:
- print(f"地形编辑处理出错: {e}")
- import traceback
- traceback.print_exc()
-
def _handleSelectionClick(self, hitNode):
"""处理选择工具的点击事件"""
print(f"开始处理选择点击，碰撞节点: {hitNode.getName()}")
@@ -541,43 +444,52 @@ class EventHandler:
selectedModel = model
print(f"找到父模型: {selectedModel.getName()}")
break
-
+
if selectedModel:
break
current = current.getParent()
if selectedModel:
- print(f"✓ 最终选中模型: {selectedModel.getName()}")
+ #print(f"✓ 最终选中模型: {selectedModel.getName()}")
+ self.world.selection.handleMouseClick(selectedModel)
# 更新选择状态并显示选择框和坐标轴
self.world.selection.updateSelection(selectedModel)
# 在树形控件中查找并选中对应的项
if self.world.interface_manager.treeWidget:
- print("查找树形控件中的对应项...")
+ #print("查找树形控件中的对应项...")
root = self.world.interface_manager.treeWidget.invisibleRootItem()
foundItem = None
-
+
for i in range(root.childCount()):
sceneItem = root.child(i)
if sceneItem.text(0) == "场景":
- print(f"在场景节点下查找...")
+ #print(f"在场景节点下查找...")
foundItem = self.world.interface_manager.findTreeItem(selectedModel, sceneItem)
if foundItem:
print(f"✓ 在树形控件中找到对应项: {foundItem.text(0)}")
+ try:
+ self.world.interface_manager.treeWidget.itemClicked.disconnect()
+ except TypeError:
+ pass
+
self.world.interface_manager.treeWidget.setCurrentItem(foundItem)
- self.world.property_panel.updatePropertyPanel(foundItem)
+
+ self.world.interface_manager.treeWidget.itemClicked.connect(
+ self.world.interface_manager.onTreeItemClicked)
else:
print("× 在树形控件中没有找到对应项")
break
-
+
if not foundItem:
print("× 没有找到场景节点或对应的树形项")
else:
print("× 树形控件不存在")
else:
print("× 没有找到可选择的模型节点")
+ self.world.selection.updateSelection(None)
def mouseReleaseEventLeft(self, evt):
"""处理鼠标左键释放事件"""
diff --git a/core/patrol_system.py b/core/patrol_system.py
new file mode 100644
index 00000000..ab951b47
--- /dev/null
+++ b/core/patrol_system.py
@@ -0,0 +1,495 @@
+from direct.showbase.ShowBaseGlobal import globalClock
+from direct.task.TaskManagerGlobal import taskMgr
+from panda3d.core import Point3, Vec3
+import math
+
+
+class PatrolSystem:
+ """巡检系统类"""
+
+ def __init__(self, world):
+ """初始化巡检系统
+
+ Args:
+ world: 核心世界对象引用
+ """
+ self.world = world
+
+ # 巡检状态
+ self.is_patrolling = False
+ self.patrol_points = [] # 巡检点列表 [(pos, hpr, wait_time), ...]
+ self.current_patrol_index = 0
+ self.patrol_task = None
+
+ # 巡检参数
+ self.patrol_speed = 5.0 # 巡检移动速度（单位/秒）
+ self.patrol_turn_speed = 90.0 # 转向速度（度/秒）
+ self.patrol_wait_timer = 0.0
+ self.patrol_state = "moving" # "moving", "turning_to_target", "waiting", "turning_back"
+
+ # 相机状态保存
+ self.original_cam_pos = None
+ self.original_cam_hpr = None
+
+ print("✓ 巡检系统初始化完成")
+
+ def add_patrol_point(self, position, heading=None, wait_time=3.0):
+ if heading is None:
+ if self.patrol_points:
+ last_pos = self.patrol_points[-1][0]
+ direction_x = position[0] - last_pos.x
+ direction_y = position[1] - last_pos.y
+ direction_z = position[2] - last_pos.z
+
+ import math
+ h=math.degrees(math.atan2(-direction_x,-direction_y))
+
+ distance_xy = math.sqrt(direction_x**2+direction_y**2)
+ p = math.degrees(math.atan2(direction_z,distance_xy))
+ p = max(-89,min(89,p))
+
+ r=0
+
+ heading = (h,p,r)
+
+ else:
+ # 使用当前相机朝向
+ current_hpr = self.world.cam.getHpr()
+ heading = (current_hpr.x, current_hpr.y, current_hpr.z)
+
+ pos = Point3(position[0], position[1], position[2])
+ hpr = Vec3(heading[0], heading[1], heading[2])
+
+ self.patrol_points.append((pos, hpr, wait_time))
+ print(f"✓ 添加巡检点 {len(self.patrol_points)}: 位置{position}, 朝向{heading}, 停留{wait_time}秒")
+
+ # 在 PatrolSystem 类中添加以下方法
+
+ def add_auto_heading_patrol_point(self, position, wait_time=3.0):
+ """添加自动计算朝向的巡检点（朝向路径前进方向）
+
+ Args:
+ position: 相机位置 (x, y, z)
+ wait_time: 在该点停留时间（秒）
+ """
+ heading = None # 将自动计算朝向
+
+ # 复用原有的 add_patrol_point 方法
+ self.add_patrol_point(position, heading, wait_time)
+
+ def add_patrol_point_looking_at(self, position, look_at_position, wait_time=3.0):
+ """添加朝向指定位置的巡检点
+
+ Args:
+ position: 相机位置 (x, y, z)
+ look_at_position: 相机朝向的目标位置 (x, y, z)
+ wait_time: 在该点停留时间（秒）
+ """
+ import math
+
+ # 计算从当前位置到目标位置的方向向量
+ direction_x = look_at_position[0] - position[0]
+ direction_y = look_at_position[1] - position[1]
+ direction_z = look_at_position[2] - position[2]
+
+ # 计算HPR朝向
+ h = math.degrees(math.atan2(-direction_x, -direction_y))
+
+ distance_xy = math.sqrt(direction_x ** 2 + direction_y ** 2)
+ p = math.degrees(math.atan2(direction_z, distance_xy))
+ p = max(-89, min(89, p)) # 限制pitch角度在合理范围内
+
+ r = 0 # roll通常为0
+
+ heading = (h, p, r)
+ self.add_patrol_point(position, heading, wait_time)
+
+ def clear_patrol_points(self):
+ """清空所有巡检点"""
+ self.patrol_points = []
+ print("✓ 巡检点已清空")
+
+ def set_patrol_speed(self, move_speed, turn_speed=None):
+ """设置巡检速度
+
+ Args:
+ move_speed: 移动速度（单位/秒）
+ turn_speed: 转向速度（度/秒），如果为None则保持当前值
+ """
+ self.patrol_speed = move_speed
+ if turn_speed is not None:
+ self.patrol_turn_speed = turn_speed
+ print(f"✓ 巡检速度已设置: 移动{move_speed}, 转向{turn_speed or self.patrol_turn_speed}")
+
+ def start_patrol(self):
+ """开始巡检"""
+ if not self.patrol_points:
+ print("✗ 没有设置巡检点，无法开始巡检")
+ return False
+
+ if self.is_patrolling:
+ print("⚠ 巡检已在进行中")
+ return True
+
+ # 保存当前相机状态
+ self.original_cam_pos = Point3(self.world.cam.getPos())
+ self.original_cam_hpr = Vec3(self.world.cam.getHpr())
+
+ # 重置巡检状态
+ self.current_patrol_index = 0
+ self.patrol_state = "moving"
+ self.patrol_wait_timer = 0.0
+ self.is_patrolling = True
+
+ # 启动巡检任务
+ if self.patrol_task:
+ taskMgr.remove(self.patrol_task)
+ self.patrol_task = taskMgr.add(self._patrol_task, "patrol_task")
+
+ print(f"✓ 开始巡检，共{len(self.patrol_points)}个巡检点")
+ return True
+
+ def stop_patrol(self):
+ """停止巡检"""
+ if not self.is_patrolling:
+ print("⚠ 巡检未在进行中")
+ return False
+
+ # 停止巡检任务
+ if self.patrol_task:
+ taskMgr.remove(self.patrol_task)
+ self.patrol_task = None
+
+ self.is_patrolling = False
+ self.patrol_state = "moving"
+ self.patrol_wait_timer = 0.0
+
+ print("✓ 巡检已停止")
+ return True
+
+ def pause_patrol(self):
+ """暂停巡检"""
+ if not self.is_patrolling:
+ print("⚠ 巡检未在进行中")
+ return False
+
+ if self.patrol_task:
+ taskMgr.remove(self.patrol_task)
+ self.patrol_task = None
+
+ print("✓ 巡检已暂停")
+ return True
+
+ def resume_patrol(self):
+ """恢复巡检"""
+ if self.is_patrolling:
+ print("⚠ 巡检已在进行中")
+ return False
+
+ if not self.patrol_points:
+ print("✗ 没有设置巡检点")
+ return False
+
+ self.is_patrolling = True
+ self.patrol_task = taskMgr.add(self._patrol_task, "patrol_task")
+
+ print("✓ 巡检已恢复")
+ return True
+
+ def reset_to_original_position(self):
+ """重置相机到原始位置"""
+ if self.original_cam_pos and self.original_cam_hpr:
+ self.world.cam.setPos(self.original_cam_pos)
+ self.world.cam.setHpr(self.original_cam_hpr)
+ print("✓ 相机已重置到原始位置")
+ return True
+ else:
+ print("✗ 没有保存的原始位置")
+ return False
+
+ def _patrol_task(self, task):
+ """巡检主任务"""
+ try:
+ if not self.is_patrolling or not self.patrol_points:
+ return task.done
+
+ # 获取当前巡检点
+ current_point = self.patrol_points[self.current_patrol_index]
+ target_pos, target_hpr, wait_time = current_point
+
+ # 根据当前状态执行不同操作
+ if self.patrol_state == "moving":
+ self._handle_moving_state(target_pos)
+ elif self.patrol_state == "turning_to_target":
+ self._handle_turning_to_target_state(target_hpr)
+ elif self.patrol_state == "waiting":
+ self._handle_waiting_state(wait_time)
+ elif self.patrol_state == "turning_back":
+ self._handle_turning_back_state()
+
+ return task.cont
+
+ except Exception as e:
+ print(f"巡检任务出错: {e}")
+ import traceback
+ traceback.print_exc()
+ return task.done
+
+ def _handle_moving_state(self, target_pos):
+ """处理移动状态"""
+ current_pos = self.world.cam.getPos()
+ distance = (target_pos - current_pos).length()
+
+ if distance < 0.1: # 到达目标点
+ print(f"✓ 到达巡检点 {self.current_patrol_index + 1}")
+ self.patrol_state = "turning_to_target"
+ return
+
+ # 计算移动方向和距离
+ direction = target_pos - current_pos
+ direction.normalize()
+
+ # 计算目标朝向（看向目标点）
+ target_hpr = self._look_at_to_hpr(direction)
+ current_hpr = self.world.cam.getHpr()
+
+ # 平滑转向到目标朝向
+ h_diff = self._normalize_angle(target_hpr.x - current_hpr.x)
+ p_diff = self._normalize_angle(target_hpr.y - current_hpr.y)
+ r_diff = self._normalize_angle(target_hpr.z - current_hpr.z)
+
+ # 计算本帧应转动的角度
+ dt = globalClock.getDt()
+ turn_amount = self.patrol_turn_speed * dt
+
+ # 逐步转向目标角度
+ new_hpr = Vec3(current_hpr)
+
+ if abs(h_diff) > turn_amount:
+ new_hpr.x += turn_amount if h_diff > 0 else -turn_amount
+ else:
+ new_hpr.x = target_hpr.x
+
+ if abs(p_diff) > turn_amount:
+ new_hpr.y += turn_amount if p_diff > 0 else -turn_amount
+ else:
+ new_hpr.y = target_hpr.y
+
+ if abs(r_diff) > turn_amount:
+ new_hpr.z += turn_amount if r_diff > 0 else -turn_amount
+ else:
+ new_hpr.z = target_hpr.z
+
+ self.world.cam.setHpr(new_hpr)
+
+ # 计算本帧应移动的距离
+ move_distance = self.patrol_speed * dt
+
+ # 如果移动距离大于剩余距离，则直接移动到目标点
+ if move_distance >= distance:
+ self.world.cam.setPos(target_pos)
+ else:
+ # 否则按方向移动
+ new_pos = current_pos + direction * move_distance
+ self.world.cam.setPos(new_pos)
+
+ def _handle_turning_to_target_state(self, target_hpr):
+ """处理转向目标状态"""
+ # 检查是否需要朝向下一个点
+ if target_hpr == "look_next":
+ # 计算朝向下一个点的方向
+ next_index = (self.current_patrol_index + 1) % len(self.patrol_points)
+ next_point_pos = self.patrol_points[next_index][0]
+
+ current_pos = self.world.cam.getPos()
+ direction = next_point_pos - current_pos
+ direction.normalize()
+
+ # 计算目标朝向
+ target_hpr = self._look_at_to_hpr(direction)
+
+ current_hpr = self.world.cam.getHpr()
+
+ # 计算角度差
+ h_diff = self._normalize_angle(target_hpr.x - current_hpr.x)
+ p_diff = self._normalize_angle(target_hpr.y - current_hpr.y)
+ r_diff = self._normalize_angle(target_hpr.z - current_hpr.z)
+
+ # 检查是否已完成转向
+ if abs(h_diff) < 1.0 and abs(p_diff) < 1.0 and abs(r_diff) < 1.0:
+ print(f"✓ 完成转向，开始停留")
+ self.patrol_state = "waiting"
+ self.patrol_wait_timer = 0.0
+ return
+
+ # 计算本帧应转动的角度
+ dt = globalClock.getDt()
+ turn_amount = self.patrol_turn_speed * dt
+
+ # 逐步转向目标角度
+ new_hpr = Vec3(current_hpr)
+
+ if abs(h_diff) > turn_amount:
+ new_hpr.x += turn_amount if h_diff > 0 else -turn_amount
+ else:
+ new_hpr.x = target_hpr.x
+
+ if abs(p_diff) > turn_amount:
+ new_hpr.y += turn_amount if p_diff > 0 else -turn_amount
+ else:
+ new_hpr.y = target_hpr.y
+
+ if abs(r_diff) > turn_amount:
+ new_hpr.z += turn_amount if r_diff > 0 else -turn_amount
+ else:
+ new_hpr.z = target_hpr.z
+
+ self.world.cam.setHpr(new_hpr)
+
+ def _handle_waiting_state(self, wait_time):
+ """处理等待状态"""
+ self.patrol_wait_timer += globalClock.getDt()
+
+ if self.patrol_wait_timer >= wait_time:
+ print(f"✓ 停留结束，准备转回原朝向")
+ self.patrol_state = "turning_back"
+
+ # 修改 core/patrol_system.py 中的 _handle_turning_back_state 方法
+
+ def _handle_turning_back_state(self):
+ """处理转回原朝向状态"""
+ # 直接完成转向状态，进入移动状态
+ print(f"✓ 停留结束，开始移动到下一个点")
+ # 移动到下一个巡检点
+ next_index = (self.current_patrol_index + 1) % len(self.patrol_points)
+ self.current_patrol_index = next_index
+ self.patrol_state = "moving"
+ return
+
+ def _normalize_angle(self, angle):
+ """规范化角度到-180到180度之间"""
+ while angle > 180:
+ angle -= 360
+ while angle < -180:
+ angle += 360
+ return angle
+
+ def _look_at_to_hpr(self, direction):
+ """将方向向量转换为HPR角度"""
+ # 简化的转换，实际应用中可能需要更精确的计算
+ h = math.degrees(math.atan2(-direction.x, -direction.y))
+ p = math.degrees(math.asin(direction.z))
+ return Vec3(h, p, 0)
+
+ def get_patrol_status(self):
+ """获取巡检状态信息"""
+ return {
+ "is_patrolling": self.is_patrolling,
+ "current_point": self.current_patrol_index,
+ "total_points": len(self.patrol_points),
+ "state": self.patrol_state,
+ "wait_timer": self.patrol_wait_timer
+ }
+
+ def list_patrol_points(self):
+ """列出所有巡检点"""
+ if not self.patrol_points:
+ print("没有设置巡检点")
+ return
+
+ print(f"巡检点列表 (共{len(self.patrol_points)}个):")
+ for i, (pos, hpr, wait_time) in enumerate(self.patrol_points):
+ current_marker = " >>>" if i == self.current_patrol_index and self.is_patrolling else ""
+ print(f" {i + 1}. 位置:({pos.x:.1f}, {pos.y:.1f}, {pos.z:.1f}) "
+ f"朝向:({hpr.x:.1f}, {hpr.y:.1f}, {hpr.z:.1f}) "
+ f"停留:{wait_time}秒{current_marker}")
+
+ def remove_patrol_point(self, index):
+ """移除指定索引的巡检点"""
+ if 0 <= index < len(self.patrol_points):
+ removed_point = self.patrol_points.pop(index)
+ print(
+ f"✓ 移除巡检点 {index + 1}: 位置({removed_point[0].x:.1f}, {removed_point[0].y:.1f}, {removed_point[0].z:.1f})")
+
+ # 调整当前索引
+ if self.current_patrol_index >= len(self.patrol_points) and self.patrol_points:
+ self.current_patrol_index = len(self.patrol_points) - 1
+ elif self.current_patrol_index >= len(self.patrol_points):
+ self.current_patrol_index = 0
+ else:
+ print(f"✗ 无效的巡检点索引: {index}")
+
+ def insert_patrol_point(self, index, position, heading=None, wait_time=3.0):
+ """在指定位置插入巡检点"""
+ if index < 0 or index > len(self.patrol_points):
+ print(f"✗ 无效的插入位置: {index}")
+ return
+
+ if heading is None:
+ # 使用当前相机朝向
+ current_hpr = self.world.cam.getHpr()
+ heading = (current_hpr.x, current_hpr.y, current_hpr.z)
+
+ pos = Point3(position[0], position[1], position[2])
+ hpr = Vec3(heading[0], heading[1], heading[2])
+
+ self.patrol_points.insert(index, (pos, hpr, wait_time))
+ print(f"✓ 在位置 {index + 1} 插入巡检点: 位置{position}, 朝向{heading}, 停留{wait_time}秒")
+
+ def update_patrol_point(self, index, position=None, heading=None, wait_time=None):
+ """更新指定巡检点的信息"""
+ if 0 <= index < len(self.patrol_points):
+ pos, hpr, wt = self.patrol_points[index]
+
+ if position is not None:
+ pos = Point3(position[0], position[1], position[2])
+ if heading is not None:
+ hpr = Vec3(heading[0], heading[1], heading[2])
+ if wait_time is not None:
+ wt = wait_time
+
+ self.patrol_points[index] = (pos, hpr, wt)
+ print(f"✓ 更新巡检点 {index + 1}")
+ else:
+ print(f"✗ 无效的巡检点索引: {index}")
+
+ def goto_patrol_point(self, index):
+ """直接跳转到指定巡检点"""
+ if not self.patrol_points:
+ print("✗ 没有设置巡检点")
+ return False
+
+ if 0 <= index < len(self.patrol_points):
+ pos, hpr, _ = self.patrol_points[index]
+ self.world.cam.setPos(pos)
+ self.world.cam.setHpr(hpr)
+ self.current_patrol_index = index
+ print(f"✓ 跳转到巡检点 {index + 1}")
+ return True
+ else:
+ print(f"✗ 无效的巡检点索引: {index}")
+ return False
+
+ def cleanup(self):
+ """清理巡检系统资源"""
+ self.stop_patrol()
+ self.clear_patrol_points()
+ self.original_cam_pos = None
+ self.original_cam_hpr = None
+ print("✓ 巡检系统资源已清理")
+
+
+# 使用示例和便捷函数
+def create_default_patrol_route(patrol_system):
+ """创建默认的巡检路线（示例）"""
+ # 清空现有巡检点
+ patrol_system.clear_patrol_points()
+
+ # 添加一些示例巡检点
+ patrol_system.add_patrol_point((0, -20, 5), (0, -15, 0), 2.0) # 点1：前方低位置
+ patrol_system.add_patrol_point((0, 0, 10), (0, -30, 0), 3.0) # 点2：中央高位置
+ patrol_system.add_patrol_point((15, 10, 5), (-45, -10, 0), 2.5) # 点3：右侧位置
+ patrol_system.add_patrol_point((-15, 10, 5), (45, -10, 0), 2.5) # 点4：左侧位置
+
+ print("✓ 默认巡检路线已创建")
+
diff --git a/core/script_system.py b/core/script_system.py
index abb206d3..d9aa465c 100644
--- a/core/script_system.py
+++ b/core/script_system.py
@@ -253,7 +253,7 @@ class ScriptLoader:
for component in components_to_remove:
self.script_manager.remove_script_from_object(component.game_object, script_name)
-
+
# 从sys.modules中移除
module = self.loaded_modules[script_name]
if module.__name__ in sys.modules:
@@ -294,6 +294,31 @@ class ScriptLoader:
return len(changed_scripts) > 0
+ def find_script_file(self, script_name: str) -> Optional[str]:
+ """根据脚本名称查找脚本文件路径"""
+ # 首先检查已加载的脚本
+ if script_name in self.loaded_modules:
+ module = self.loaded_modules[script_name]
+ if hasattr(module, '__file__') and module.__file__:
+ return module.__file__
+
+ # 在已知的文件路径中查找
+ for file_path in self.file_mtimes.keys():
+ file_name = os.path.splitext(os.path.basename(file_path))[0]
+ if file_name == script_name:
+ return file_path
+
+ # 在脚本目录中查找
+ scripts_dir = self.script_manager.scripts_directory
+ if os.path.exists(scripts_dir):
+ for file_name in os.listdir(scripts_dir):
+ if file_name.endswith('.py'):
+ base_name = os.path.splitext(file_name)[0]
+ if base_name == script_name:
+ return os.path.join(scripts_dir, file_name)
+
+ return None
+
class ScriptAPI:
"""脚本API - 提供给脚本使用的API接口"""
@@ -671,18 +696,62 @@ class {class_name}(ScriptBase):
return False
script_components = self.object_scripts[game_object]
+ removed = False
+
for component in script_components[:]: # 复制列表以避免修改时出错
if component.script_instance.__class__.__name__ == script_name:
# 从引擎移除
self.engine.remove_script_component(component)
# 从对象脚本列表移除
script_components.remove(component)
+ removed = True
print(f"✓ 从对象 {game_object.getName()} 移除脚本: {script_name}")
- return True
+
+
+ if not script_components:
+ del self.object_scripts[game_object]
+
+ # 更新节点上保存的脚本信息标签
+ if removed:
+ self._update_node_script_tags_after_removal(game_object, script_name)
- return False
-
+ return removed
+
+ def _update_node_script_tags_after_removal(self, game_object, removed_script_name):
+ """在移除脚本后更新节点标签"""
+ try:
+ # 获取对象上剩余的脚本
+ remaining_scripts = self.get_scripts_on_object(game_object)
+
+ if not remaining_scripts:
+ # 如果没有其他脚本，清除所有脚本标签
+ if game_object.hasTag("has_scripts"):
+ game_object.clearTag("has_scripts")
+ if game_object.hasTag("scripts_info"):
+ game_object.clearTag("scripts_info")
+ print(f"✓ 清除节点 {game_object.getName()} 的所有脚本标签")
+ else:
+ # 如果还有其他脚本，更新脚本信息标签
+ script_info_list = []
+ for script_component in remaining_scripts:
+ script_name = script_component.script_name
+ script_class = script_component.script_instance.__class__
+ script_file = self.loader.find_script_file(script_name) or ""
+
+ script_info_list.append({
+ "name": script_name,
+ "file": script_file
+ })
+
+ import json
+ game_object.setTag("has_scripts", "true")
+ game_object.setTag("scripts_info", json.dumps(script_info_list, ensure_ascii=False))
+ print(f"✓ 更新节点 {game_object.getName()} 的脚本标签信息，剩余 {len(script_info_list)} 个脚本")
+
+ except Exception as e:
+ print(f"更新节点标签失败: {e}")
+
def get_scripts_on_object(self, game_object) -> List[ScriptComponent]:
"""获取对象上的所有脚本"""
return self.object_scripts.get(game_object, [])
@@ -744,6 +813,36 @@ class {class_name}(ScriptBase):
print("==================\n")
+ def save_object_scripts(self,game_object,node_data:dict):
+ try:
+ if game_object in self.object_scripts:
+ scripts_data = []
+ for script_commponent in self.object_scripts[game_object]:
+ script_info = {
+ 'script_name':script_commponent.script_name,
+ 'enabled':script_commponent.enabled,
+ 'script_class':script_commponent.script_instance.__class__.__name__
+ }
+ scripts_data.append(script_info)
+ if scripts_data:
+ node_data['scripts'] = scripts_data
+ print(f"✓ 保存了 {len(scripts_data)} 个脚本到对象 {game_object.getName()}")
+ except Exception as e:
+ print(f"保存对象脚本信息失败: {e}")
+ traceback.print_exc()
+
+ # def restore_object_scripts(self,game_object,node_data:dict):
+ # try:
+ # if 'scripts' in node_data:
+ # scripts_data = node_data['scripts']
+ # restored_count = 0
+ # for script_info in scripts_data:
+ # script_name = script_info.get('script_name')
+ # enabled = script_info.get('enabled',True)
+ #
+ # #检查脚本是否可用
+ # if script_name in self.loader.script_classes:
+ #为
# 添加全局便捷函数，让脚本更容易使用API
def get_script_api():
diff --git a/core/selection.py b/core/selection.py
index 7cef719c..8a3302aa 100644
--- a/core/selection.py
+++ b/core/selection.py
@@ -8,6 +8,7 @@
- 射线检测和碰撞检测
"""
from PIL.ImageChops import lighter
+from direct.showbase.ShowBaseGlobal import globalClock
from panda3d.core import (Vec3, Point3, Point2, LineSegs, ColorAttrib, RenderState,
DepthTestAttrib, CollisionTraverser, CollisionHandlerQueue,
CollisionNode, CollisionRay, GeomNode, BitMask32, Material, LColor, DepthWriteAttrib,
@@ -63,9 +64,21 @@ class SelectionSystem:
"z": (1.0, 1.0, 0.0, 1.0) # 黄色高亮
}
+ #性能优化相关
+ self._optimized_node = False
+ self._last_update_time = 0
+ self._cached_bounds = {}
+ self._gizmo_update_interval = 0.1
+ self._selection_box_update_interval = 0.2
+
self._current_cursor = None
self._default_cursor = None
+ self._last_click_time = 0
+ self._double_click_threshold = 0.3
+ self._last_clicked_node = None
+ self._double_click_task = None
+
print("✓ 选择和变换系统初始化完成")
# ==================== 光标设置 ====================
def _setCursor(self,cursor_type):
@@ -112,7 +125,7 @@ class SelectionSystem:
def createSelectionBox(self, nodePath):
"""为选中的节点创建选择框"""
try:
- print(f" 开始创建选择框，目标节点: {nodePath.getName()}")
+ #print(f" 开始创建选择框，目标节点: {nodePath.getName()}")
# 如果已有选择框，先移除
if self.selectionBox:
@@ -127,17 +140,17 @@ class SelectionSystem:
# 创建选择框作为render的子节点，但会实时跟踪目标节点
self.selectionBox = self.world.render.attachNewNode("selectionBox")
self.selectionBoxTarget = nodePath # 保存目标节点引用
- print(f" 选择框节点创建完成: {self.selectionBox}")
+ #print(f" 选择框节点创建完成: {self.selectionBox}")
# 启动选择框更新任务
taskMgr.add(self.updateSelectionBoxTask, "updateSelectionBox")
- print(" 选择框更新任务已启动")
+ #print(" 选择框更新任务已启动")
# 初始更新选择框
- print(" 开始初始化选择框几何体...")
- self.updateSelectionBoxGeometry()
+ #print(" 开始初始化选择框几何体...")
+ #self.updateSelectionBoxGeometry()
- print(f" ✓ 为节点 {nodePath.getName()} 创建了选择框")
+ #print(f" ✓ 为节点 {nodePath.getName()} 创建了选择框")
except Exception as e:
print(f" ✗ 创建选择框失败: {str(e)}")
@@ -212,7 +225,7 @@ class SelectionSystem:
return
# 获取边界框的最小和最大点（世界坐标）
- print(f"世界边界框: min={minPoint}, max={maxPoint}")
+ #print(f"世界边界框: min={minPoint}, max={maxPoint}")
# 创建线段对象
lines = LineSegs()
@@ -271,51 +284,58 @@ class SelectionSystem:
traceback.print_exc()
def updateSelectionBoxTask(self, task):
- """选择框更新任务"""
+ """选择框更新任务 - 平衡性能和实时性"""
try:
- if not hasattr(self,'_last_selection_box_update'):
+ update_interval = 0.1
+
+ if not hasattr(self, '_last_selection_box_update'):
self._last_selection_box_update = 0
import time
current_time = time.time()
- if current_time - self._last_selection_box_update < 0.1:
+ if current_time - self._last_selection_box_update < update_interval:
return task.cont
self._last_selection_box_update = current_time
- #检查目标节点是否已被删除
+ # 检查目标节点是否已被删除
self.checkAndClearIfTargetDeleted()
if not self.selectionBox or not self.selectionBoxTarget:
- return task.done # 结束任务
+ return task.done
# 检查目标节点是否还存在
if self.selectionBoxTarget.isEmpty():
self.clearSelectionBox()
return task.done
- # 获取目标节点在世界坐标系中的当前边界框（使用正确的API）
- currentMinPoint = Point3()
- currentMaxPoint = Point3()
- if not self.selectionBoxTarget.calcTightBounds(currentMinPoint, currentMaxPoint, self.world.render):
- return task.cont
+ # 检查目标节点是否发生了变化（位置、旋转、缩放）
+ current_transform = self._getNodeTransformKey(self.selectionBoxTarget)
- # 检查边界框是否发生变化（位置或大小）
- if (not hasattr(self, '_lastMinPoint') or not hasattr(self, '_lastMaxPoint') or
- self._lastMinPoint != currentMinPoint or self._lastMaxPoint != currentMaxPoint):
-
- # 更新选择框几何体
+ if (not hasattr(self, '_last_transform_key') or
+ self._last_transform_key != current_transform):
+ # 节点发生了变化，更新选择框
self.updateSelectionBoxGeometry()
+ self._last_transform_key = current_transform
- # 保存当前边界框信息
- self._lastMinPoint = currentMinPoint
- self._lastMaxPoint = currentMaxPoint
-
- return task.cont # 继续任务
+ return task.cont
except Exception as e:
print(f"选择框更新任务出错: {str(e)}")
return task.done
+ def _getNodeTransformKey(self, node):
+ """获取节点变换的关键信息，用于快速比较"""
+ try:
+ # 获取节点的关键变换信息
+ pos = node.getPos(self.world.render)
+ hpr = node.getHpr(self.world.render)
+ scale = node.getScale(self.world.render)
+
+ # 返回一个可以比较的元组
+ return (pos.x, pos.y, pos.z, hpr.x, hpr.y, hpr.z, scale.x, scale.y, scale.z)
+ except:
+ return None
+
def clearSelectionBox(self):
"""清除选择框"""
if self.selectionBox:
@@ -335,7 +355,7 @@ class SelectionSystem:
def createGizmo(self, nodePath):
"""为选中的节点创建坐标轴工具 - 保留箭头版本"""
try:
- print(f" 开始创建坐标轴，目标节点: {nodePath.getName()}")
+ #print(f" 开始创建坐标轴，目标节点: {nodePath.getName()}")
# 如果已有坐标轴，先移除
if self.gizmo:
@@ -350,6 +370,22 @@ class SelectionSystem:
self.gizmo = self.world.render.attachNewNode("gizmo")
self.gizmoTarget = nodePath
+ # 添加标识标签，便于识别
+ self.gizmo.setTag("is_gizmo", "1")
+ if hasattr(nodePath, 'getName'):
+ self.gizmo.setTag("gizmo_target", nodePath.getName())
+
+ # 为各轴添加标签
+ if hasattr(self, 'gizmoXAxis') and self.gizmoXAxis:
+ self.gizmoXAxis.setTag("is_gizmo", "1")
+ self.gizmoXAxis.setTag("gizmo_axis", "x")
+ if hasattr(self, 'gizmoYAxis') and self.gizmoYAxis:
+ self.gizmoYAxis.setTag("is_gizmo", "1")
+ self.gizmoYAxis.setTag("gizmo_axis", "y")
+ if hasattr(self, 'gizmoZAxis') and self.gizmoZAxis:
+ self.gizmoZAxis.setTag("is_gizmo", "1")
+ self.gizmoZAxis.setTag("gizmo_axis", "z")
+
# 设置位置和朝向
minPoint = Point3()
maxPoint = Point3()
@@ -385,7 +421,7 @@ class SelectionSystem:
# 只启动一次更新任务
taskMgr.add(self.updateGizmoTask, "updateGizmo")
- print(f" ✓ 为节点 {nodePath.getName()} 创建了坐标轴")
+ #print(f" ✓ 为节点 {nodePath.getName()} 创建了坐标轴")
except Exception as e:
print(f"创建坐标轴失败: {str(e)}")
@@ -431,7 +467,7 @@ class SelectionSystem:
else:
gizmo_model = self.world.loader.loadModel(path)
if gizmo_model:
- print(f"成功加载模型: {path}")
+ #print(f"成功加载模型: {path}")
break
except:
continue
@@ -877,7 +913,7 @@ class SelectionSystem:
handle_node = children[0]
if not handle_node:
- print(f"未找到{axis}轴的处理模型")
+ #print(f"未找到{axis}轴的处理模型")
return
# 创建或获取材质
@@ -985,7 +1021,7 @@ class SelectionSystem:
handle_node = children[0]
if not handle_node:
- print(f"未找到{axis}轴的处理模型")
+ # print(f"未找到{axis}轴的处理模型")
return
# 创建或获取材质
@@ -999,7 +1035,7 @@ class SelectionSystem:
)
mat.setBaseColor(adjusted_color)
- mat.setEmission(Vec4(1, 1, 1, 1.0)) # 自发光
+ #mat.setEmission(Vec4(1, 1, 1, 1.0)) # 自发光
# 应用材质
handle_node.setMaterial(mat, 1)
@@ -1177,7 +1213,7 @@ class SelectionSystem:
return self.checkGizmoClickFallback(mouseX, mouseY)
# 计算点击阈值
- click_threshold = 30 # 增大检测范围
+ click_threshold = 15 # 增大检测范围
# 检测各个轴，对于端点在屏幕外的轴提供回退方案
def getClickDetectionPoint(axis_name, original_screen_pos):
@@ -1206,10 +1242,10 @@ class SelectionSystem:
distance = self.distanceToLine(
(mouseX, mouseY), center_screen, axis_screen
)
- print(f"{axis_label}距离: {distance:.2f}")
+ #print(f"{axis_label}距离: {distance:.2f}")
if distance < click_threshold:
- print(f"✓ 点击了{axis_label}")
+ #print(f"✓ 点击了{axis_label}")
return axis_name
return None
@@ -1657,14 +1693,12 @@ class SelectionSystem:
if parent_node and parent_node != self.world.render:
try:
- if parent_node.getTransform().hasMat():
- transform_mat = parent_node.getMat(self.world.render)
- if not transform_mat.isSingular():
- world_axis_vector = transform_mat.xformVec(local_axis_vector)
- else:
- print("警告: 检测到奇异变换矩阵，使用默认轴向量")
+ #获取变换矩阵
+ transfrom_mat = parent_node.getMat(self.world.render)
+ if transfrom_mat.is_identity() or self._isMatrixValid(transfrom_mat):
+ world_axis_vector = transfrom_mat.xformVec(local_axis_vector)
else:
- print("警告: 父节点没有有效的变换矩阵，使用默认轴向量")
+ print("警告: 检测到无效变换矩阵，使用默认轴向量")
except Exception as e:
print(f"变换计算出错: {e}，使用默认轴向量")
else:
@@ -1812,6 +1846,23 @@ class SelectionSystem:
import traceback
traceback.print_exc()
+ def _isMatrixValid(self, matrix):
+ """检查矩阵是否有效，替代 isSingular 方法"""
+ try:
+ # 检查矩阵元素是否为有效数字
+ for i in range(4):
+ for j in range(4):
+ element = matrix.getCell(i, j)
+ # 检查是否为 NaN 或无穷大
+ if str(element) == 'nan' or str(element) == 'inf' or str(element) == '-inf':
+ return False
+ # 检查是否过大
+ if abs(element) > 1e10:
+ return False
+ return True
+ except:
+ return False
+
def _safeUpdatePropertyPanel(self):
"""安全地更新属性面板"""
try:
@@ -1871,58 +1922,110 @@ class SelectionSystem:
# ==================== 选择管理 ====================
def updateSelection(self, nodePath):
- """更新选择状态"""
- print(f"\n=== 更新选择状态 ===")
+ try:
+ if self.selectedNode == nodePath:
+ return
+ print(f"\n=== 更新选择状态 ===")
+
+ # 如果正在删除节点，避免更新选择
+ if hasattr(self, '_deleting_node') and self._deleting_node:
+ print("正在删除节点，跳过选择更新")
+ print("=== 选择状态更新完成 ===\n")
+ return
+
+ node_name = "None"
+ if nodePath and not nodePath.isEmpty():
+ node_name = nodePath.getName()
+ print(f"新选择的节点: {node_name}")
+
+ self.selectedNode = nodePath
+ # 添加兼容性属性
+ self.selectedObject = nodePath
+
+ if nodePath and not nodePath.isEmpty():
+ node_name = nodePath.getName()
+ #print(f"开始为节点 {node_name} 创建选择框和坐标轴...")
+
+ # 创建选择框
+ #print("创建选择框...")
+ self.createSelectionBox(nodePath)
+ if self.selectionBox:
+ box_name = "Unknown"
+ if self.selectionBox and not self.selectionBox.isEmpty():
+ box_name = self.selectionBox.getName()
+ #print(f"✓ 选择框创建成功: {box_name}")
+ else:
+ print("× 选择框创建失败")
+
+ # 创建坐标轴
+ #print("创建坐标轴...")
+ self.createGizmo(nodePath)
+ if self.gizmo:
+ gizmo_name = "Unknown"
+ if self.gizmo and not self.gizmo.isEmpty():
+ gizmo_name = self.gizmo.getName()
+ #print(f"✓ 坐标轴创建成功: {gizmo_name}")
+ else:
+ print("× 坐标轴创建失败")
+
+ print(f"✓ 选中了节点: {node_name}")
+ else:
+ print("清除选择...")
+ self.clearSelectionBox()
+ self.clearGizmo()
+ print("✓ 取消选择")
+
+ #当取消选择时，同步清空树形控件的选中状态
+ if (hasattr(self.world,'interface_manager')and
+ self.world.interface_manager and
+ self.world.interface_manager.treeWidget):
+ self.world.interface_manager.treeWidget.setCurrentItem(None)
+ print("✓ 树形控件选中状态已清空")
- # 如果正在删除节点，避免更新选择
- if hasattr(self, '_deleting_node') and self._deleting_node:
- print("正在删除节点，跳过选择更新")
print("=== 选择状态更新完成 ===\n")
- return
+ except Exception as e:
+ print(f"更新选择状态失败{str(e)}")
+ import traceback
+ traceback.print_exc()
- node_name = "None"
- if nodePath and not nodePath.isEmpty():
- node_name = nodePath.getName()
- print(f"新选择的节点: {node_name}")
+ def _updateSelectionVisuals(self, nodePath):
+ """更新选择的视觉效果（选择框和坐标轴）"""
+ try:
+ if nodePath and not nodePath.isEmpty():
+ node_name = nodePath.getName()
+ print(f"开始为节点 {node_name} 创建选择框和坐标轴...")
- self.selectedNode = nodePath
- # 添加兼容性属性
- self.selectedObject = nodePath
+ # 创建选择框
+ print("创建选择框...")
+ self.createSelectionBox(nodePath)
+ if self.selectionBox:
+ box_name = "Unknown"
+ if self.selectionBox and not self.selectionBox.isEmpty():
+ box_name = self.selectionBox.getName()
+ print(f"✓ 选择框创建成功: {box_name}")
+ else:
+ print("× 选择框创建失败")
- if nodePath and not nodePath.isEmpty():
- node_name = nodePath.getName()
- print(f"开始为节点 {node_name} 创建选择框和坐标轴...")
+ # 创建坐标轴
+ print("创建坐标轴...")
+ self.createGizmo(nodePath)
+ if self.gizmo:
+ gizmo_name = "Unknown"
+ if self.gizmo and not self.gizmo.isEmpty():
+ gizmo_name = self.gizmo.getName()
+ print(f"✓ 坐标轴创建成功: {gizmo_name}")
+ else:
+ print("× 坐标轴创建失败")
- # 创建选择框
- print("创建选择框...")
- self.createSelectionBox(nodePath)
- if self.selectionBox:
- box_name = "Unknown"
- if self.selectionBox and not self.selectionBox.isEmpty():
- box_name = self.selectionBox.getName()
- print(f"✓ 选择框创建成功: {box_name}")
+ print(f"✓ 选中了节点: {node_name}")
else:
- print("× 选择框创建失败")
+ print("清除选择...")
+ self.clearSelectionBox()
+ self.clearGizmo()
+ print("✓ 取消选择")
- # 创建坐标轴
- print("创建坐标轴...")
- self.createGizmo(nodePath)
- if self.gizmo:
- gizmo_name = "Unknown"
- if self.gizmo and not self.gizmo.isEmpty():
- gizmo_name = self.gizmo.getName()
- print(f"✓ 坐标轴创建成功: {gizmo_name}")
- else:
- print("× 坐标轴创建失败")
-
- print(f"✓ 选中了节点: {node_name}")
- else:
- print("清除选择...")
- self.clearSelectionBox()
- self.clearGizmo()
- print("✓ 取消选择")
-
- print("=== 选择状态更新完成 ===\n")
+ except Exception as e:
+ print(f"更新选择视觉效果失败: {e}")
def getSelectedNode(self):
"""获取当前选中的节点"""
@@ -2010,7 +2113,7 @@ class SelectionSystem:
collision_np.hide() # 隐藏碰撞体，只用于检测
- print(f"✓ 成功创建 {axis_name} 轴碰撞体")
+ #print(f"✓ 成功创建 {axis_name} 轴碰撞体")
except Exception as e:
print(f"创建{axis_name}轴碰撞体失败: {e}")
@@ -2098,4 +2201,583 @@ class SelectionSystem:
if not collision_node.isEmpty():
print(f" - 碰撞体标签: {collision_node.getTag('gizmo_axis')}")
else:
- print(f"{axis_name.upper()}轴节点不存在")
\ No newline at end of file
+ print(f"{axis_name.upper()}轴节点不存在")
+
+ def focusCameraOnSelectedNodeAdvanced(self):
+ """高级版的摄像机聚焦功能，包含平滑动画效果"""
+ try:
+ if not self.selectedNode or self.selectedNode.isEmpty():
+ print("没有选中的节点，无法聚焦")
+ return False
+
+ # 获取选中节点的边界框
+ minPoint = Point3()
+ maxPoint = Point3()
+
+ if not self.selectedNode.calcTightBounds(minPoint, maxPoint, self.world.render):
+ print("无法计算选中节点的边界框，使用节点为位置作为替代方案")
+ node_pos = self.selectedNode.getPos(self.world.render)
+ optimal_distance = 10.0
+ current_cam_pos = self.world.cam.getPos()
+ view_direction = node_pos - current_cam_pos
+ if view_direction.length()<0.001:
+ view_direction = Vec3(5,-5,2)
+ view_direction.normalize()
+ target_cam_pos = node_pos - (view_direction * optimal_distance)
+
+ temp_node =self.world.render.attachNewNode("temp_lookat_target")
+ temp_node.setPos(node_pos)
+ dummy_cam = self.world.render.attachNewNode("dummy_camera")
+ dummy_cam.setPos(target_cam_pos)
+ dummy_cam.lookAt(temp_node)
+ target_cam_hpr = Vec3(dummy_cam.getHpr())
+
+ temp_node.removeNode()
+ dummy_cam.removeNode()
+
+ currrent_cam_pos = Point3(self.world.cam.getPos())
+ current_cam_hpr = Vec3(self.world.cam.getHpr())
+ self._startCameraFocusAnimation(current_cam_pos,target_cam_pos,current_cam_hpr,target_cam_hpr)
+ print(f"开始聚焦到节点(使用位置): {self.selectedNode.getName()}")
+ return True
+
+ # 计算节点中心点和大小
+ center = Point3(
+ (minPoint.x + maxPoint.x) * 0.5,
+ (minPoint.y + maxPoint.y) * 0.5,
+ (minPoint.z + maxPoint.z) * 0.5
+ )
+
+ # 计算节点的对角线长度
+ size = (maxPoint - minPoint).length()
+
+ # 如果节点太小，使用默认大小
+ if size < 0.01:
+ size = 1.0
+
+ # 获取当前摄像机位置和朝向
+ current_cam_pos = Point3(self.world.cam.getPos())
+ current_cam_hpr = Vec3(self.world.cam.getHpr())
+
+ # 计算观察方向
+ view_direction = current_cam_pos - center
+ if view_direction.length() < 0.001:
+ view_direction = Vec3(5, -5, 2)
+
+ view_direction.normalize()
+
+ # 计算合适的观察距离
+ optimal_distance = max(size * 2.0, 5.0)
+
+ # 计算目标摄像机位置
+ target_cam_pos = center + (view_direction * optimal_distance)
+
+ # 计算目标朝向（不直接使用lookAt，而是计算目标HPR）
+ # 创建临时节点用于计算目标朝向
+ temp_node = self.world.render.attachNewNode("temp_lookat_target")
+ temp_node.setPos(center)
+
+ # 创建另一个临时节点用于计算朝向
+ dummy_cam = self.world.render.attachNewNode("dummy_camera")
+ dummy_cam.setPos(target_cam_pos)
+ dummy_cam.lookAt(temp_node)
+ target_cam_hpr = Vec3(dummy_cam.getHpr())
+
+ # 清理临时节点
+ temp_node.removeNode()
+ dummy_cam.removeNode()
+
+ # 使用任务来实现平滑移动动画
+ self._startCameraFocusAnimation(current_cam_pos, target_cam_pos,
+ current_cam_hpr, target_cam_hpr)
+
+ print(f"开始聚焦到节点: {self.selectedNode.getName()}")
+ return True
+
+ except Exception as e:
+ print(f"高级聚焦功能失败: {str(e)}")
+ import traceback
+ traceback.print_exc()
+ return False
+
+ def _startCameraFocusAnimation(self, start_pos, end_pos, start_hpr, end_hpr):
+ """启动摄像机聚焦动画"""
+ try:
+ # 创建动画任务
+ class CameraFocusData:
+ def __init__(self, start_pos, end_pos, start_hpr, end_hpr):
+ self.start_pos = Point3(start_pos) # 确保是Point3类型
+ self.end_pos = Point3(end_pos) # 确保是Point3类型
+ self.start_hpr = Vec3(start_hpr) # 确保是Vec3类型
+ self.end_hpr = Vec3(end_hpr) # 确保是Vec3类型
+ self.elapsed_time = 0.0
+ self.duration = 0.8 # 增加动画持续时间到0.8秒，让动画更平滑
+
+ self._camera_focus_data = CameraFocusData(start_pos, end_pos, start_hpr, end_hpr)
+
+ # 移除之前的任务（如果存在）
+ taskMgr.remove("cameraFocusTask")
+
+ # 添加新任务
+ taskMgr.add(self._cameraFocusTask, "cameraFocusTask")
+
+ except Exception as e:
+ print(f"启动摄像机聚焦动画失败: {e}")
+
+ def _normalizeAngle(self, angle):
+ """规范化角度到-180到180度之间"""
+ while angle > 180:
+ angle -= 360
+ while angle < -180:
+ angle += 360
+ return angle
+
+ def _cameraFocusTask(self, task):
+ """摄像机聚焦动画任务"""
+ try:
+ if not hasattr(self, '_camera_focus_data'):
+ return task.done
+
+ data = self._camera_focus_data
+ data.elapsed_time += globalClock.getDt()
+
+ # 计算插值因子
+ t = min(1.0, data.elapsed_time / data.duration)
+
+ # 使用更平滑的插值函数
+ smooth_t = t * t * (3 - 2 * t) # 平滑步进插值
+
+ # 手动实现lerp功能
+ def lerp_point3(start, end, factor):
+ return Point3(
+ start.x + (end.x - start.x) * factor,
+ start.y + (end.y - start.y) * factor,
+ start.z + (end.z - start.z) * factor
+ )
+
+ # 角度插值需要特殊处理，确保选择最短路径
+ def lerp_hpr(start, end, factor):
+ # 规范化角度
+ start_x = self._normalizeAngle(start.x)
+ start_y = self._normalizeAngle(start.y)
+ start_z = self._normalizeAngle(start.z)
+
+ end_x = self._normalizeAngle(end.x)
+ end_y = self._normalizeAngle(end.y)
+ end_z = self._normalizeAngle(end.z)
+
+ # 计算最短旋转路径
+ diff_x = self._normalizeAngle(end_x - start_x)
+ diff_y = self._normalizeAngle(end_y - start_y)
+ diff_z = self._normalizeAngle(end_z - start_z)
+
+ # 插值
+ result_x = start_x + diff_x * factor
+ result_y = start_y + diff_y * factor
+ result_z = start_z + diff_z * factor
+
+ # 再次规范化
+ result_x = self._normalizeAngle(result_x)
+ result_y = self._normalizeAngle(result_y)
+ result_z = self._normalizeAngle(result_z)
+
+ return Vec3(result_x, result_y, result_z)
+
+ # 计算当前位置和朝向
+ current_pos = lerp_point3(data.start_pos, data.end_pos, smooth_t)
+ current_hpr = lerp_hpr(data.start_hpr, data.end_hpr, smooth_t)
+
+ # 应用到摄像机
+ self.world.cam.setPos(current_pos)
+ self.world.cam.setHpr(current_hpr)
+
+ # 检查是否完成
+ if t >= 1.0:
+ if hasattr(self, '_camera_focus_data'):
+ delattr(self, '_camera_focus_data')
+ print("摄像机聚焦动画完成")
+ return task.done
+
+ return task.cont
+
+ except Exception as e:
+ print(f"摄像机聚焦任务出错: {e}")
+ import traceback
+ traceback.print_exc()
+ return task.done
+
+ def _smoothCameraMoveTask(self, task):
+ """平滑摄像机移动任务"""
+ try:
+ if not hasattr(self, '_smooth_camera_move_data'):
+ return task.done
+
+ data = self._smooth_camera_move_data
+ data.elapsed_time += globalClock.getDt()
+
+ # 计算插值因子
+ t = min(1.0, data.elapsed_time / data.duration)
+
+ # 使用平滑插值
+ smooth_t = t * t * (3 - 2 * t)
+
+ # 角度插值需要特殊处理
+ def lerp_hpr(start, end, factor):
+ # 规范化角度
+ start_x = self._normalizeAngle(start.x)
+ start_y = self._normalizeAngle(start.y)
+ start_z = self._normalizeAngle(start.z)
+
+ end_x = self._normalizeAngle(end.x)
+ end_y = self._normalizeAngle(end.y)
+ end_z = self._normalizeAngle(end.z)
+
+ # 计算最短旋转路径
+ diff_x = self._normalizeAngle(end_x - start_x)
+ diff_y = self._normalizeAngle(end_y - start_y)
+ diff_z = self._normalizeAngle(end_z - start_z)
+
+ # 插值
+ result_x = start_x + diff_x * factor
+ result_y = start_y + diff_y * factor
+ result_z = start_z + diff_z * factor
+
+ return Vec3(result_x, result_y, result_z)
+
+ # 计算当前位置和朝向
+ current_pos = Point3(
+ data.start_pos.x + (data.end_pos.x - data.start_pos.x) * smooth_t,
+ data.start_pos.y + (data.end_pos.y - data.start_pos.y) * smooth_t,
+ data.start_pos.z + (data.end_pos.z - data.start_pos.z) * smooth_t
+ )
+
+ current_hpr = lerp_hpr(data.start_hpr, data.end_hpr, smooth_t)
+
+ # 应用到摄像机
+ self.world.cam.setPos(current_pos)
+ self.world.cam.setHpr(current_hpr)
+
+ # 检查是否完成
+ if t >= 1.0:
+ if hasattr(self, '_smooth_camera_move_data'):
+ delattr(self, '_smooth_camera_move_data')
+ print("摄像机平滑移动完成")
+ return task.done
+
+ return task.cont
+
+ except Exception as e:
+ print(f"平滑摄像机移动任务出错: {e}")
+ import traceback
+ traceback.print_exc()
+ return task.done
+
+ def handleMouseClick(self, nodePath, mouseX=None, mouseY=None):
+ """处理鼠标点击事件 - 支持坐标轴双击聚焦"""
+ try:
+ # 如果正在删除节点，忽略鼠标点击
+ if hasattr(self, '_deleting_node') and self._deleting_node:
+ print("正在删除节点，忽略鼠标点击")
+ return
+
+ import time
+ current_time = time.time()
+
+ # 检查是否点击了坐标轴
+ is_gizmo_click = False
+ target_node = nodePath
+
+ # 判断是否点击了坐标轴
+ if (nodePath and hasattr(nodePath, 'getName') and
+ (nodePath.getName().startswith("gizmo") or
+ "gizmo" in nodePath.getName().lower() or
+ (hasattr(nodePath, 'hasTag') and nodePath.hasTag("is_gizmo")))):
+ is_gizmo_click = True
+ # 如果有选中的模型，使用选中的模型作为聚焦目标
+ if self.selectedNode and not self.selectedNode.isEmpty():
+ target_node = self.selectedNode
+ print(f"检测到坐标轴点击，使用目标节点: {target_node.getName() if target_node else 'None'}")
+
+ # 检查是否为双击（同一节点且在时间阈值内）
+ is_double_click = (self._last_clicked_node == target_node and
+ target_node is not None and
+ current_time - self._last_click_time < self._double_click_threshold)
+
+ if is_double_click:
+ # 双击 detected
+ node_name = target_node.getName() if target_node else "None"
+ print(f"检测到双击节点: {node_name}")
+
+ # 无论是点击模型还是坐标轴，都执行聚焦
+ if target_node and not target_node.isEmpty():
+ print(f"双击聚焦到节点: {target_node.getName()}")
+ if self.selectedNode != target_node:
+ self.updateSelection(target_node)
+ else:
+ self.focusCameraOnSelectedNodeAdvanced()
+ else:
+ print("双击事件：没有有效的目标节点")
+
+ # 重置状态以避免三击等误触发
+ self._last_click_time = 0
+ self._last_clicked_node = None
+ else:
+ # 单击，更新状态
+ self._last_click_time = current_time
+ self._last_clicked_node = target_node
+
+ # 如果点击的是坐标轴，保持当前选择不变
+ if is_gizmo_click:
+ print("坐标轴单击，保持当前选择")
+ else:
+ # 正常的单击选择
+ self.updateSelection(nodePath)
+
+ except Exception as e:
+ print(f"处理鼠标点击事件失败: {e}")
+
+ def _onDoubleClick(self, nodePath):
+ """双击事件处理"""
+ try:
+ # 获取实际要聚焦的目标节点
+ target_node = nodePath
+
+ # 如果是坐标轴，确保使用关联的模型作为目标
+ if (nodePath and hasattr(nodePath, 'hasTag') and
+ nodePath.hasTag("is_gizmo")):
+ if self.selectedNode and not self.selectedNode.isEmpty():
+ target_node = self.selectedNode
+ print(f"坐标轴双击，聚焦到关联模型: {target_node.getName()}")
+ else:
+ print("坐标轴双击，但没有关联的选中模型")
+ return
+
+ if target_node and not target_node.isEmpty():
+ print(f"双击聚焦到节点: {target_node.getName()}")
+ # 更新选择（如果需要）
+ if self.selectedNode != target_node:
+ self.updateSelection(target_node)
+
+ # 执行聚焦
+ self.focusCameraOnSelectedNodeAdvanced()
+ else:
+ print("双击事件：没有有效的目标节点")
+
+ except Exception as e:
+ print(f"双击事件处理失败: {e}")
+
+ # 添加一个更精确的双击检测方法
+
+ def checkDoubleClick(self, nodePath):
+ """检查是否为双击，返回布尔值"""
+ try:
+ import time
+ current_time = time.time()
+
+ # 必须是同一节点且在时间阈值内
+ is_double_click = (self._last_clicked_node == nodePath and
+ nodePath is not None and
+ current_time - self._last_click_time < self._double_click_threshold)
+
+ if is_double_click:
+ # 重置状态
+ self._last_click_time = 0
+ self._last_clicked_node = None
+ return True
+ else:
+ # 更新状态
+ self._last_click_time = current_time
+ self._last_clicked_node = nodePath
+ return False
+
+ except Exception as e:
+ print(f"双击检测失败: {e}")
+ return False
+
+ # 添加一个定时重置方法，用于清除长时间未完成的双击状态
+
+ def _resetDoubleClickState(self):
+ """重置双击状态"""
+ self._last_click_time = 0
+ self._last_clicked_node = None
+
+ # 添加一个任务来自动重置双击状态
+
+ def _startDoubleClickResetTask(self):
+ """启动双击状态重置任务"""
+ if self._double_click_task:
+ taskMgr.remove(self._double_click_task)
+
+ self._double_click_task = taskMgr.doMethodLater(
+ self._double_click_threshold * 2, # 等待2倍阈值时间
+ self._resetDoubleClickStateTask,
+ "resetDoubleClickState"
+ )
+
+ def _resetDoubleClickStateTask(self, task):
+ """任务：重置双击状态"""
+ self._resetDoubleClickState()
+ self._double_click_task = None
+ return task.done
+
+ # 修改 updateSelection 方法以集成双击检测
+
+ # def updateSelection(self, nodePath):
+ # """更新选择状态"""
+ # print(f"\n=== 更新选择状态 ===")
+ #
+ # # 如果正在删除节点，避免更新选择
+ # if hasattr(self, '_deleting_node') and self._deleting_node:
+ # print("正在删除节点，跳过选择更新")
+ # print("=== 选择状态更新完成 ===\n")
+ # return
+ #
+ # node_name = "None"
+ # if nodePath and not nodePath.isEmpty():
+ # node_name = nodePath.getName()
+ # print(f"新选择的节点: {node_name}")
+ #
+ # # 检查是否为双击
+ # is_double_click = self.checkDoubleClick(nodePath)
+ # if is_double_click:
+ # print(f"检测到双击 {node_name}，执行聚焦")
+ # # 启动聚焦（在下一帧执行，确保选择状态已更新）
+ # taskMgr.doMethodLater(0.01, self._delayedFocusTask, "delayedFocus")
+ #
+ # self.selectedNode = nodePath
+ # # 添加兼容性属性
+ # self.selectedObject = nodePath
+ #
+ # if nodePath and not nodePath.isEmpty():
+ # node_name = nodePath.getName()
+ # print(f"开始为节点 {node_name} 创建选择框和坐标轴...")
+ #
+ # # 创建选择框
+ # print("创建选择框...")
+ # self.createSelectionBox(nodePath)
+ # if self.selectionBox:
+ # box_name = "Unknown"
+ # if self.selectionBox and not self.selectionBox.isEmpty():
+ # box_name = self.selectionBox.getName()
+ # print(f"✓ 选择框创建成功: {box_name}")
+ # else:
+ # print("× 选择框创建失败")
+ #
+ # # 创建坐标轴
+ # print("创建坐标轴...")
+ # self.createGizmo(nodePath)
+ # if self.gizmo:
+ # gizmo_name = "Unknown"
+ # if self.gizmo and not self.gizmo.isEmpty():
+ # gizmo_name = self.gizmo.getName()
+ # print(f"✓ 坐标轴创建成功: {gizmo_name}")
+ # else:
+ # print("× 坐标轴创建失败")
+ #
+ # print(f"✓ 选中了节点: {node_name}")
+ # else:
+ # print("清除选择...")
+ # self.clearSelectionBox()
+ # self.clearGizmo()
+ # print("✓ 取消选择")
+ #
+ # print("=== 选择状态更新完成 ===\n")
+
+ def _delayedFocusTask(self, task):
+ """延迟执行聚焦任务"""
+ try:
+ self.focusCameraOnSelectedNodeAdvanced()
+ except Exception as e:
+ print(f"延迟聚焦任务失败: {e}")
+ return task.done
+
+ # 添加一个更智能的双击检测方法，考虑鼠标位置
+
+ def checkDoubleClickWithPosition(self, nodePath, mouse_x=None, mouse_y=None):
+ """检查是否为双击，同时考虑鼠标位置"""
+ try:
+ import time
+ current_time = time.time()
+
+ # 如果没有提供鼠标位置，直接使用基本双击检测
+ if mouse_x is None or mouse_y is None:
+ return self.checkDoubleClick(nodePath)
+
+ # 检查节点和时间
+ time_diff = current_time - self._last_click_time
+ is_same_node = (self._last_clicked_node == nodePath)
+
+ # 如果是同一节点且在时间阈值内，认为是双击
+ if is_same_node and time_diff < self._double_click_threshold:
+ # 重置状态
+ self._last_click_time = 0
+ self._last_clicked_node = None
+ return True
+ else:
+ # 更新状态
+ self._last_click_time = current_time
+ self._last_clicked_node = nodePath
+ return False
+
+ except Exception as e:
+ print(f"带位置的双击检测失败: {e}")
+ return False
+
+ # 添加一个公共方法来设置双击阈值
+
+ def setDoubleClickThreshold(self, threshold_seconds):
+ """设置双击时间阈值"""
+ if threshold_seconds > 0:
+ self._double_click_threshold = threshold_seconds
+ print(f"双击阈值已设置为: {threshold_seconds} 秒")
+ else:
+ print("无效的双击阈值")
+
+ # 添加一个方法来手动触发双击聚焦（可用于测试或其他触发方式）
+
+ def triggerDoubleClickFocus(self, nodePath=None):
+ """手动触发双击聚焦"""
+ try:
+ target_node = nodePath if nodePath else self.selectedNode
+ if target_node and not target_node.isEmpty():
+ print(f"手动触发聚焦到节点: {target_node.getName()}")
+ if self.selectedNode != target_node:
+ self.updateSelection(target_node)
+ self.focusCameraOnSelectedNodeAdvanced()
+ return True
+ else:
+ print("没有有效的目标节点进行聚焦")
+ return False
+ except Exception as e:
+ print(f"手动触发聚焦失败: {e}")
+ return False
+
+ def cleanup(self):
+ """清理选择系统资源"""
+ # 清理双击任务
+ if self._double_click_task:
+ taskMgr.remove(self._double_click_task)
+ self._double_click_task = None
+
+ # 清理其他资源
+ self.clearSelectionBox()
+ self.clearGizmo()
+ def clearSelection(self):
+ """清除当前选择"""
+ try:
+ self.selectedNode = None
+ self.selectedObject = None
+ self.clearSelectionBox()
+ self.clearGizmo()
+
+ # 清除树形控件中的选择
+ if (hasattr(self.world, 'interface_manager') and
+ self.world.interface_manager and
+ hasattr(self.world.interface_manager, 'treeWidget') and
+ self.world.interface_manager.treeWidget):
+ self.world.interface_manager.treeWidget.setCurrentItem(None)
+
+ print("已清除选择")
+ except Exception as e:
+ print(f"清除选择失败: {e}")
+
diff --git a/core/terrain_manager.py b/core/terrain_manager.py
index cfd85590..edbec218 100644
--- a/core/terrain_manager.py
+++ b/core/terrain_manager.py
@@ -1,9 +1,13 @@
# core/terrain_manager.py
import time
+import urllib
+
from panda3d.core import GeoMipTerrain, PNMImage, Texture, Vec3, NodePath
from panda3d.core import Filename, Material, ColorAttrib, AmbientLight, DirectionalLight
import os
+from scene import util
+
class TerrainManager:
"""地形管理类"""
@@ -31,106 +35,151 @@ class TerrainManager:
return None
try:
- # 创建GeoMipTerrain对象
- terrain_name = f"terrain_{len(self.terrains)}_{int(time.time() * 1000000) % 10000}"
- terrain = GeoMipTerrain(terrain_name)
+ print(f"🔆 开始创建高度图地形")
- # 加载高度图
- height_image = PNMImage(Filename.fromOsSpecific(heightmap_path))
-
- # 检查并调整图像尺寸为2的幂次方加1
- width, height = height_image.getXSize(), height_image.getYSize()
- print(f"原始图像尺寸: {width}x{height}")
-
- # 找到最接近的有效尺寸
- valid_sizes = [17, 33, 65, 129, 257, 513, 1025, 2049]
- target_size = 129 # 默认尺寸
-
- # 选择最接近的尺寸
- max_dim = max(width, height)
- for size in valid_sizes:
- if size >= max_dim:
- target_size = size
- break
- else:
- target_size = valid_sizes[-1] # 使用最大尺寸
-
- # 如果需要，调整图像尺寸
- if width != target_size or height != target_size:
- print(f"调整图像尺寸从 {width}x{height} 到 {target_size}x{target_size}")
- # 使用正确的图像缩放方法
- resized_image = PNMImage(target_size, target_size)
- resized_image.quickFilterFrom(height_image)
- height_image = resized_image
-
- # 使用正确的方法设置高度图
- terrain.setHeightfield(height_image)
-
- # 设置地形参数
- terrain.setBruteforce(True) # 使用LOD
-
- terrain.setBlockSize(32)
- # terrain.setNearFarThreshold(50.0,200.0)
-
- # 生成地形
- terrain.generate()
-
- # 获取地形节点
- terrain_node = terrain.getRoot()
-
- if terrain_node.isEmpty():
- print("错误：无法生成有效的地形节点")
+ # 获取树形控件
+ tree_widget = self._get_tree_widget()
+ if not tree_widget:
+ print("❌ 无法访问树形控件")
return None
- node_name = f"Terrain_{os.path.basename(heightmap_path)}_{len(self.terrains)}"
- terrain_node.setName(node_name)
+ # 获取目标父节点列表
+ target_parents = tree_widget.get_target_parents_for_creation()
+ if not target_parents:
+ print("❌ 没有找到有效的父节点")
+ return None
- center_offset = (target_size - 1) / 2
- terrain_node.setPos(-center_offset * scale[0], -center_offset * scale[1], -5)
+ created_terrains = []
+ try:
+ parent_item, parent_node = target_parents[0]
- # 设置缩放
- terrain_node.setScale(scale[0], scale[1], scale[2])
+ # 创建GeoMipTerrain对象
+ terrain_name = f"terrain_{len(self.terrains)}_{int(time.time() * 1000000) % 10000}"
+ terrain = GeoMipTerrain(terrain_name)
- # 将地形添加到场景中
- terrain_node.reparentTo(self.world.render)
+ # 加载高度图
+ height_image = PNMImage(Filename.fromOsSpecific(heightmap_path))
- from panda3d.core import BitMask32
- # 设置地形节点的碰撞掩码
- terrain_node.setCollideMask(BitMask32.bit(2)) # 使用第2位作为地形碰撞掩码
- # 为地形的所有子节点也设置碰撞掩码
- for child in terrain_node.getChildren():
- child.setCollideMask(BitMask32.bit(2))
+ # 检查并调整图像尺寸为2的幂次方加1
+ width, height = height_image.getXSize(), height_image.getYSize()
+ print(f"原始图像尺寸: {width}x{height}")
- # 添加材质
- self._applyTerrainMaterial(terrain_node)
+ # 找到最接近的有效尺寸
+ valid_sizes = [17, 33, 65, 129, 257, 513, 1025, 2049]
+ target_size = 129 # 默认尺寸
- terrain_node.setPythonTag("selectable", True)
+ # 选择最接近的尺寸
+ max_dim = max(width, height)
+ for size in valid_sizes:
+ if size >= max_dim:
+ target_size = size
+ break
+ else:
+ target_size = valid_sizes[-1] # 使用最大尺寸
- # 保存地形信息（包括高度图的副本）
- terrain_info = {
- 'terrain': terrain,
- 'node': terrain_node,
- 'heightmap': heightmap_path,
- 'heightfield': height_image, # 保存高度图副本
- 'scale': scale,
- 'name': node_name
- }
+ # 如果需要，调整图像尺寸
+ if width != target_size or height != target_size:
+ print(f"调整图像尺寸从 {width}x{height} 到 {target_size}x{target_size}")
+ # 使用正确的图像缩放方法
+ resized_image = PNMImage(target_size, target_size)
+ resized_image.quickFilterFrom(height_image)
+ height_image = resized_image
- self.terrains.append(terrain_info)
+ # 使用正确的方法设置高度图
+ terrain.setHeightfield(height_image)
- # 更新场景树（再次检查节点是否有效）
- if not terrain_node.isEmpty() and hasattr(self.world, 'scene_manager') and hasattr(self.world.scene_manager,
- 'updateSceneTree'):
- try:
- self.world.scene_manager.updateSceneTree()
- except Exception as e:
- print(f"警告: 更新场景树时出错: {e}")
+ # 设置地形参数
+ terrain.setBruteforce(True) # 使用LOD
- print(f"✓ 成功从 {heightmap_path} 创建地形")
- return terrain_info
+ terrain.setBlockSize(32)
+ # terrain.setNearFarThreshold(50.0,200.0)
+
+ # 生成地形
+ terrain.generate()
+
+ # 获取地形节点
+ terrain_node = terrain.getRoot()
+
+ if terrain_node.isEmpty():
+ print("错误：无法生成有效的地形节点")
+ return None
+
+ terrain_node.setTag("is_scene_element", "1")
+ terrain_node.setTag("tree_item_type", "TERRAIN_NODE")
+
+ node_name = f"Terrain_{os.path.basename(heightmap_path)}_{len(self.terrains)}"
+ terrain_node.setName(node_name)
+
+ center_offset = (target_size - 1) / 2
+ terrain_node.setPos(-center_offset * scale[0], -center_offset * scale[1], -5)
+
+ # 设置缩放
+ terrain_node.setScale(scale[0], scale[1], scale[2])
+
+ # 将地形添加到场景中
+ terrain_node.reparentTo(parent_node)
+
+ from panda3d.core import BitMask32
+ # 设置地形节点的碰撞掩码
+ terrain_node.setCollideMask(BitMask32.bit(2)) # 使用第2位作为地形碰撞掩码
+ # 为地形的所有子节点也设置碰撞掩码
+ for child in terrain_node.getChildren():
+ child.setCollideMask(BitMask32.bit(2))
+
+ # 添加材质
+ self._applyTerrainMaterial(terrain_node)
+
+ terrain_node.setPythonTag("selectable", True)
+
+ # 保存地形信息（包括高度图的副本）
+ terrain_info = {
+ 'terrain': terrain,
+ 'node': terrain_node,
+ 'heightmap': heightmap_path,
+ 'heightfield': height_image, # 保存高度图副本
+ 'scale': scale,
+ 'name': node_name
+ }
+
+ self.terrains.append(terrain_info)
+
+ print(f"✅ 为 {parent_item.text(0)} 创建高度图地形: {terrain_name}")
+
+ # 在Qt树形控件中添加对应节点
+ qt_item = tree_widget.add_node_to_tree_widget(terrain_node, parent_item, "TERRAIN_NODE")
+ if qt_item:
+ created_terrains.append((terrain_node, qt_item))
+ else:
+ created_terrains.append((terrain_node, None))
+ print("⚠️ Qt树节点添加失败，但Panda3D对象已创建")
+
+ except Exception as e:
+ print(f"❌ 为 {parent_item.text(0)} 创建高度图地形: {str(e)}")
+ return None
+
+ # 处理创建结果
+ if not created_terrains:
+ print("❌ 没有成功创建任何高度图地形")
+ return None
+
+ # 选中最后创建的光源
+ if created_terrains:
+ last_light_np, last_qt_item = created_terrains[-1]
+ if last_qt_item:
+ tree_widget.setCurrentItem(last_qt_item)
+ # 更新选择和属性面板
+ tree_widget.update_selection_and_properties(last_light_np, last_qt_item)
+
+ print(f"🎉 总共创建了 {len(created_terrains)} 个高度图地形")
+
+ # 返回值处理
+ if len(created_terrains) == 1:
+ return created_terrains[0][0] # 单个光源返回NodePath
+ else:
+ return [light_np for light_np, _ in created_terrains] # 多个光源返回列表
except Exception as e:
- print(f"创建地形时出错: {e}")
+ print(f"❌ 创建高度图地形过程失败: {str(e)}")
import traceback
traceback.print_exc()
return None
@@ -138,84 +187,129 @@ class TerrainManager:
def createFlatTerrain(self, size=(0.3, 0.3), resolution=129):
"""创建平面地形"""
try:
- # 确保分辨率是2的幂次方加1 (如129, 257, 513等)
- valid_resolutions = [17, 33, 65, 129, 257, 513, 1025]
- if resolution not in valid_resolutions:
- # 找到最接近的有效分辨率
- closest_res = min(valid_resolutions, key=lambda x: abs(x - resolution))
- print(f"警告: 分辨率 {resolution} 不是有效的地形分辨率，使用 {closest_res}")
- resolution = closest_res
+ print(f"🔆 开始创建平面地形")
- # 创建GeoMipTerrain对象
- terrain_name = f"flat_terrain_{len(self.terrains)}_{int(time.time() * 1000000) % 10000}"
- terrain = GeoMipTerrain(terrain_name)
-
- # 创建一个平面高度图，尺寸必须是2^n+1
- height_image = PNMImage(resolution, resolution)
- height_image.fill(0.5) # 设置为中等高度 (0.0-1.0范围)
-
- # 使用正确的方法设置高度图
- terrain.setHeightfield(height_image)
- terrain.setBruteforce(True) # 设置LOD
-
- # 设置地形参数
- terrain.setBlockSize(32) # 设置块大小
-
- # 生成地形
- terrain.generate()
-
- # 获取地形节点
- terrain_node = terrain.getRoot()
-
- if terrain_node.isEmpty():
- print("错误：无法生成有效的平面地形节点")
+ # 获取树形控件
+ tree_widget = self._get_tree_widget()
+ if not tree_widget:
+ print("❌ 无法访问树形控件")
return None
- node_name = f"FlatTerrain_{len(self.terrains)}_{int(time.time() * 1000000) % 10000}"
- terrain_node.setName(node_name)
+ # 获取目标父节点列表
+ target_parents = tree_widget.get_target_parents_for_creation()
+ if not target_parents:
+ print("❌ 没有找到有效的父节点")
+ return None
- center_offset = (resolution - 1) / 2
- terrain_node.setPos(-center_offset * size[0], -center_offset * size[1], 0)
+ created_terrains = []
- # 将地形添加到场景中
- terrain_node.reparentTo(self.world.render)
+ try:
+ parent_item, parent_node = target_parents[0]
+ # 确保分辨率是2的幂次方加1 (如129, 257, 513等)
+ valid_resolutions = [17, 33, 65, 129, 257, 513, 1025]
+ if resolution not in valid_resolutions:
+ # 找到最接近的有效分辨率
+ closest_res = min(valid_resolutions, key=lambda x: abs(x - resolution))
+ print(f"警告: 分辨率 {resolution} 不是有效的地形分辨率，使用 {closest_res}")
+ resolution = closest_res
- # 为地形添加碰撞体
- from panda3d.core import BitMask32
- # 设置地形节点的碰撞掩码
- terrain_node.setCollideMask(BitMask32.bit(2)) # 使用第2位作为地形碰撞掩码
- # 为地形的所有子节点也设置碰撞掩码
- for child in terrain_node.getChildren():
- child.setCollideMask(BitMask32.bit(2))
+ # 创建GeoMipTerrain对象
+ terrain_name = f"flat_terrain_{len(self.terrains)}_{int(time.time() * 1000000) % 10000}"
+ terrain = GeoMipTerrain(terrain_name)
- # 添加材质
- self._applyTerrainMaterial(terrain_node)
+ # 创建一个平面高度图，尺寸必须是2^n+1
+ height_image = PNMImage(resolution, resolution)
+ height_image.fill(0.5) # 设置为中等高度 (0.0-1.0范围)
- # 保存地形信息（包括高度图）
- terrain_info = {
- 'terrain': terrain,
- 'node': terrain_node,
- 'heightmap': None,
- 'heightfield': height_image, # 保存高度图
- 'scale': (size[0], size[1], 50),
- 'name': node_name
- }
+ # 使用正确的方法设置高度图
+ terrain.setHeightfield(height_image)
+ terrain.setBruteforce(True) # 设置LOD
- self.terrains.append(terrain_info)
+ # 设置地形参数
+ terrain.setBlockSize(32) # 设置块大小
- # 更新场景树（再次检查节点是否有效）
- if not terrain_node.isEmpty() and hasattr(self.world, 'scene_manager') and hasattr(self.world.scene_manager,
- 'updateSceneTree'):
- try:
- self.world.scene_manager.updateSceneTree()
- except Exception as e:
- print(f"警告: 更新场景树时出错: {e}")
+ # 生成地形
+ terrain.generate()
- print(f"✓ 成功创建平面地形，大小: {size}, 分辨率: {resolution}")
- return terrain_info
+ # 获取地形节点
+ terrain_node = terrain.getRoot()
+
+ if terrain_node.isEmpty():
+ print("错误：无法生成有效的平面地形节点")
+ return None
+
+ terrain_node.setTag("is_scene_element", "1")
+ terrain_node.setTag("tree_item_type", "TERRAIN_NODE")
+
+ node_name = f"FlatTerrain_{len(self.terrains)}_{int(time.time() * 1000000) % 10000}"
+ terrain_node.setName(node_name)
+
+ center_offset = (resolution - 1) / 2
+ terrain_node.setPos(-center_offset * size[0], -center_offset * size[1], 0)
+
+ # 将地形添加到场景中
+ terrain_node.reparentTo(parent_node)
+
+ # 为地形添加碰撞体
+ from panda3d.core import BitMask32
+ # 设置地形节点的碰撞掩码
+ terrain_node.setCollideMask(BitMask32.bit(2)) # 使用第2位作为地形碰撞掩码
+ # 为地形的所有子节点也设置碰撞掩码
+ for child in terrain_node.getChildren():
+ child.setCollideMask(BitMask32.bit(2))
+
+ # 添加材质
+ self._applyTerrainMaterial(terrain_node)
+
+ # 保存地形信息（包括高度图）
+ terrain_info = {
+ 'terrain': terrain,
+ 'node': terrain_node,
+ 'heightmap': None,
+ 'heightfield': height_image, # 保存高度图
+ 'scale': (size[0], size[1], 50),
+ 'name': node_name
+ }
+
+ self.terrains.append(terrain_info)
+
+ print(f"✅ 为 {parent_item.text(0)} 创建平面地形: {terrain_name}")
+
+ # 在Qt树形控件中添加对应节点
+ qt_item = tree_widget.add_node_to_tree_widget(terrain_node, parent_item, "TERRAIN_NODE")
+ if qt_item:
+ created_terrains.append((terrain_node, qt_item))
+ else:
+ created_terrains.append((terrain_node, None))
+ print("⚠️ Qt树节点添加失败，但Panda3D对象已创建")
+
+ except Exception as e:
+ print(f"❌ 为 {parent_item.text(0)} 创建平面地形: {str(e)}")
+ return None
+
+ # 处理创建结果
+ if not created_terrains:
+ print("❌ 没有成功创建任何平面地形")
+ return None
+
+ # 选中最后创建的光源
+ if created_terrains:
+ last_light_np, last_qt_item = created_terrains[-1]
+ if last_qt_item:
+ tree_widget.setCurrentItem(last_qt_item)
+ # 更新选择和属性面板
+ tree_widget.update_selection_and_properties(last_light_np, last_qt_item)
+
+ print(f"🎉 总共创建了 {len(created_terrains)} 个平面地形")
+
+ # 返回值处理
+ if len(created_terrains) == 1:
+ return created_terrains[0][0] # 单个光源返回NodePath
+ else:
+ return [light_np for light_np, _ in created_terrains] # 多个光源返回列表
except Exception as e:
- print(f"创建平面地形时出错: {e}")
+ print(f"❌ 创建平面地形过程失败: {str(e)}")
import traceback
traceback.print_exc()
return None
@@ -390,7 +484,6 @@ class TerrainManager:
print(f"✓ 地形高度已修改: 位置({x}, {y}), 半径{radius}, 操作{operation}")
print(f"✓ 重新设置了地形碰撞体")
-
return modified
except Exception as e:
@@ -405,14 +498,17 @@ class TerrainManager:
# 从场景中移除地形节点
terrain_node = terrain_info['node']
if terrain_node and not terrain_node.isEmpty():
- terrain_node.removeNode()
+ tree_widget = self._get_tree_widget()
+ if tree_widget:
+ tree_widget.delete_items(tree_widget.selectedItems())
+ # terrain_node.removeNode()
+ #
+ # # 从列表中移除
+ # self.terrains.remove(terrain_info)
- # 从列表中移除
- self.terrains.remove(terrain_info)
-
- # 更新场景树
- if hasattr(self.world, 'scene_manager') and hasattr(self.world.scene_manager, 'updateSceneTree'):
- self.world.scene_manager.updateSceneTree()
+ # # 更新场景树
+ # if hasattr(self.world, 'scene_manager') and hasattr(self.world.scene_manager, 'updateSceneTree'):
+ # self.world.scene_manager.updateSceneTree()
print(f"✓ 地形已删除: {terrain_info.get('name', 'Unknown')}")
@@ -461,6 +557,7 @@ class TerrainManager:
if terrain_info in self.terrains:
terrain_node = terrain_info['node']
if terrain_node and os.path.exists(texture_path):
+ texture_path = util.normalize_model_path(texture_path)
# 加载纹理
texture = self.world.loader.loadTexture(texture_path)
if texture:
@@ -476,3 +573,88 @@ class TerrainManager:
except Exception as e:
print(f"应用地形纹理时出错: {e}")
return False
+
+ def saveTerrainData(self, terrain_info, filename):
+ """保存地形数据到文件"""
+ try:
+ terrain_node = terrain_info['node']
+ heightfield = terrain_info['heightfield']
+
+ # 保存高度图到文件
+ if heightfield:
+ # 创建保存路径
+ terrain_dir = os.path.join(os.path.dirname(filename), "terrains")
+ if not os.path.exists(terrain_dir):
+ os.makedirs(terrain_dir)
+
+ # 生成唯一的地形文件名
+ terrain_filename = f"terrain_{terrain_info.get('name', 'unnamed')}_{int(time.time())}.png"
+ terrain_path = os.path.join(terrain_dir, terrain_filename)
+
+ # 保存高度图
+ heightfield.write(Filename.fromOsSpecific(terrain_path))
+
+ # 保存地形信息到标签
+ terrain_node.setTag("terrain_heightmap_path", terrain_path)
+ terrain_node.setTag("terrain_scale", str(terrain_info['scale']))
+
+ print(f"✓ 地形数据已保存: {terrain_path}")
+ return terrain_path
+ return None
+ except Exception as e:
+ print(f"保存地形数据时出错: {e}")
+ return None
+
+ def _recreateTerrain(self, terrain_node):
+ """重新创建地形"""
+ try:
+ print(f"重新创建地形: {terrain_node.getName()}")
+
+ # 获取保存的地形信息
+ heightmap_path = terrain_node.getTag("terrain_heightmap_path") if terrain_node.hasTag(
+ "terrain_heightmap_path") else None
+ scale_str = terrain_node.getTag("terrain_scale") if terrain_node.hasTag("terrain_scale") else "(1, 1, 1)"
+
+ # 解析缩放信息
+ try:
+ scale_str = scale_str.strip("()")
+ scale_values = [float(x.strip()) for x in scale_str.split(",")]
+ scale = (scale_values[0], scale_values[1], scale_values[2]) if len(scale_values) >= 3 else (1, 1, 1)
+ except:
+ scale = (1, 1, 1)
+
+ # 恢复位置信息
+ if terrain_node.hasTag("transform_pos"):
+ try:
+ pos_str = terrain_node.getTag("transform_pos")
+ pos_str = pos_str.replace('LVecBase3f', '').replace('LPoint3f', '').strip('()')
+ pos_values = [float(x.strip()) for x in pos_str.split(',')]
+ if len(pos_values) >= 3:
+ terrain_node.setPos(pos_values[0], pos_values[1], pos_values[2])
+ except Exception as e:
+ print(f"恢复地形位置失败: {e}")
+
+ # 如果有高度图路径，重新创建地形
+ if heightmap_path and os.path.exists(heightmap_path):
+ # 使用现有方法重新创建地形
+ new_terrain = self.createTerrainFromHeightMap(heightmap_path, scale)
+ if new_terrain:
+ # 删除旧的地形节点
+ if not terrain_node.isEmpty():
+ terrain_node.removeNode()
+ return new_terrain
+
+ # 如果没有高度图或创建失败，创建一个平面地形作为替代
+ print("使用平面地形作为替代")
+ new_terrain = self.createFlatTerrain(size=(scale[0], scale[1]), resolution=129)
+ if new_terrain:
+ # 删除旧的地形节点
+ if not terrain_node.isEmpty():
+ terrain_node.removeNode()
+ return new_terrain
+
+ return terrain_node
+ except Exception as e:
+ print(f"重新创建地形失败: {e}")
+ return terrain_node
+
diff --git a/core/tool_manager.py b/core/tool_manager.py
index 4f5f4cdf..a0906215 100644
--- a/core/tool_manager.py
+++ b/core/tool_manager.py
@@ -5,6 +5,7 @@ class ToolManager:
"""初始化工具管理器"""
self.world = world
self.currentTool = "选择" # 默认工具为选择工具
+ print(f"当前工具: {self.currentTool}")
def setCurrentTool(self, tool):
"""设置当前工具"""
diff --git a/core/world.py b/core/world.py
index 4860ad50..0f4ec28a 100644
--- a/core/world.py
+++ b/core/world.py
@@ -288,6 +288,8 @@ class CoreWorld(Panda3DWorld):
self.cam.setPos(0, -50, 20)
self.cam.lookAt(0, 0, 0)
self.camLens.setFov(80)
+ self.cam.setTag("is_scene_element", "1")
+ self.cam.setTag("tree_item_type", "CAMERA_NODE")
print("✓ 相机设置完成")
def _setupLighting(self):
@@ -319,18 +321,61 @@ class CoreWorld(Panda3DWorld):
# 创建地板节点
self.ground = self.render.attachNewNode(cm.generate())
self.ground.setP(-90)
- self.ground.setZ(-0.1)
+ self.ground.setZ(-1.0)
self.ground.setColor(0.8, 0.8, 0.8, 1)
+ # self.ground.setTag("is_scene_element", "1")
+ # self.ground.setTag("tree_item_type", "SCENE_NODE")
# 创建支持贴图的材质
mat = Material()
mat.setName("GroundMaterial")
color = LColor(1, 1, 1, 0.8)
mat.set_base_color(color)
- mat.set_roughness(0.5) # 设置合适的初始粗糙度
+ mat.set_roughness(1) # 设置合适的初始粗糙度
mat.set_metallic(0.5) # 设置较低的初始金属性
self.ground.set_material(mat)
+ #创建第二个相同的地面，位置稍有偏移
+ self.ground2 = self.render.attachNewNode(cm.generate())
+ self.ground2.setH(-90)
+ self.ground2.setZ(-1.0)
+ self.ground2.setX(50) # 在X轴方向偏移
+ self.ground2.setZ(49) # 在X轴方向偏移
+ self.ground2.setColor(0.8, 0.8, 0.8, 1)
+ self.ground2.set_material(mat)
+
+ # 创建第三个相同的地面，位置在另一个方向
+ self.ground3 = self.render.attachNewNode(cm.generate())
+ self.ground3.setH(90)
+ self.ground3.setZ(-1.0)
+ self.ground3.setX(-50) # 在X轴负方向偏移
+ self.ground3.setZ(49) # 在X轴负方向偏移
+ self.ground3.setColor(0.8, 0.8, 0.8, 1)
+ self.ground3.set_material(mat)
+
+ self.ground4 = self.render.attachNewNode(cm.generate())
+ # self.ground3.setR(90)
+ self.ground4.setZ(-1.0)
+ self.ground4.setY(50) # 在X轴负方向偏移
+ self.ground4.setZ(49) # 在X轴负方向偏移
+ self.ground4.setColor(0.8, 0.8, 0.8, 1)
+ self.ground4.set_material(mat)
+
+ self.ground5 = self.render.attachNewNode(cm.generate())
+ self.ground5.setP(180)
+ self.ground5.setZ(-1)
+ self.ground5.setY(-50) # 在X轴负方向偏移
+ self.ground5.setZ(49) # 在X轴负方向偏移
+ self.ground5.setColor(0.8, 0.8, 0.8, 1)
+ self.ground5.set_material(mat)
+
+ self.ground6 = self.render.attachNewNode(cm.generate())
+ self.ground6.setP(90)
+ self.ground6.setZ(-1)
+ self.ground6.setZ(99) # 在X轴负方向偏移
+ self.ground6.setColor(0.8, 0.8, 0.8, 1)
+ self.ground6.set_material(mat)
+
# 应用默认PBR效果，确保支持贴图
try:
if hasattr(self, 'render_pipeline') and self.render_pipeline:
@@ -347,6 +392,72 @@ class CoreWorld(Panda3DWorld):
},
50
)
+ # 为其他两个地面也应用相同的效果
+ self.render_pipeline.set_effect(
+ self.ground2,
+ "effects/default.yaml",
+ {
+ "normal_mapping": True,
+ "render_gbuffer": True,
+ "alpha_testing": False,
+ "parallax_mapping": False,
+ "render_shadow": True,
+ "render_envmap": True
+ },
+ 50
+ )
+ self.render_pipeline.set_effect(
+ self.ground3,
+ "effects/default.yaml",
+ {
+ "normal_mapping": True,
+ "render_gbuffer": True,
+ "alpha_testing": False,
+ "parallax_mapping": False,
+ "render_shadow": True,
+ "render_envmap": True
+ },
+ 50
+ )
+ self.render_pipeline.set_effect(
+ self.ground4,
+ "effects/default.yaml",
+ {
+ "normal_mapping": True,
+ "render_gbuffer": True,
+ "alpha_testing": False,
+ "parallax_mapping": False,
+ "render_shadow": True,
+ "render_envmap": True
+ },
+ 50
+ )
+ self.render_pipeline.set_effect(
+ self.ground5,
+ "effects/default.yaml",
+ {
+ "normal_mapping": True,
+ "render_gbuffer": True,
+ "alpha_testing": False,
+ "parallax_mapping": False,
+ "render_shadow": True,
+ "render_envmap": True
+ },
+ 50
+ )
+ self.render_pipeline.set_effect(
+ self.ground6,
+ "effects/default.yaml",
+ {
+ "normal_mapping": True,
+ "render_gbuffer": True,
+ "alpha_testing": False,
+ "parallax_mapping": False,
+ "render_shadow": True,
+ "render_envmap": True
+ },
+ 50
+ )
print("✓ 地板PBR效果已应用")
else:
print("⚠️ RenderPipeline未初始化，地板将使用基础渲染")
diff --git a/demo/test_gizmo_drag.py b/demo/test_gizmo_drag.py
index 81718bc3..4a1b39d2 100644
--- a/demo/test_gizmo_drag.py
+++ b/demo/test_gizmo_drag.py
@@ -359,7 +359,7 @@ class GizmoDragTestWorld(Panda3DWorld):
distance = distance_to_line(
(mouseX, mouseY), center_screen, axis_screen
)
- print(f"{axis_label}距离: {distance:.2f}")
+ #print(f"{axis_label}距离: {distance:.2f}")
if distance < click_threshold:
print(f"✓ 点击了{axis_label}")
diff --git a/gui/gui_manager.py b/gui/gui_manager.py
index babc94c2..cfd10728 100644
--- a/gui/gui_manager.py
+++ b/gui/gui_manager.py
@@ -24,78 +24,80 @@ except ImportError:
WEB_ENGINE_AVAILABLE = False
print("⚠️ QtWebEngineWidgets 不可用，Cesium 集成功能将被禁用")
- def createGUI3DImage(self, pos=(0, 0, 0), image_path=None, size=1.0):
- from panda3d.core import CardMaker, Material, LColor,TransparencyAttrib
-
- # 参数类型检查和转换
- if isinstance(size, (list, tuple)):
- if len(size) >= 2:
- x_size, y_size = float(size[0]), float(size[1])
- else:
- x_size = y_size = float(size[0]) if size else 1.0
- else:
- x_size = y_size = float(size)
-
- # 创建卡片
- cm = CardMaker('gui_3d_image')
- cm.setFrame(-x_size/2, x_size/2, -y_size/2, y_size/2)
-
- # 创建3D图像节点
- image_node = self.world.render.attachNewNode(cm.generate())
- image_node.setPos(*pos)
-
- # 为3D图像创建独立的材质
- material = Material(f"image-material-{len(self.gui_elements)}")
- material.setBaseColor(LColor(1, 1, 1, 1))
- material.setDiffuse(LColor(1, 1, 1, 1))
- material.setAmbient(LColor(0.5, 0.5, 0.5, 1))
- material.setSpecular(LColor(0.1, 0.1, 0.1, 1.0))
- material.setShininess(10.0)
- material.setEmission(LColor(0, 0, 0, 1)) # 无自发光
- image_node.setMaterial(material, 1)
-
- image_node.setTransparency(TransparencyAttrib.MAlpha)
-
- # 如果提供了图像路径，则加载纹理
- if image_path:
- self.update3DImageTexture(image_node, image_path)
-
- # 应用PBR效果（如果可用）
- try:
- if hasattr(self, 'render_pipeline') and self.render_pipeline:
- self.render_pipeline.set_effect(
- image_node,
- "effects/default.yaml",
- {
- "normal_mapping": True,
- "render_gbuffer": True,
- "alpha_testing": False,
- "parallax_mapping": False,
- "render_shadow": False,
- "render_envmap": True,
- "disable_children_effects": True
- },
- 50
- )
- print("✓ GUI 3D图像PBR效果已应用")
- except Exception as e:
- print(f"⚠️ GUI 3D图像PBR效果应用失败: {e}")
-
- # 为GUI元素添加标识（效仿3D文本方法）
- image_node.setTag("gui_type", "3d_image")
- image_node.setTag("gui_id", f"3d_image_{len(self.gui_elements)}")
- if image_path:
- image_node.setTag("gui_image_path", image_path)
- image_node.setTag("is_gui_element", "1")
-
- self.gui_elements.append(image_node)
-
- # 更新场景树
- if hasattr(self.world, 'updateSceneTree'):
- self.world.updateSceneTree()
-
- print(f"✓ 3D图像创建完成: {image_path or '无纹理'} (世界位置: {pos})")
- return image_node
+ # def createGUI3DImage(self, pos=(0, 0, 0), image_path=None, size=1.0):
+ # from panda3d.core import CardMaker, Material, LColor,TransparencyAttrib
+ #
+ # # 参数类型检查和转换
+ # if isinstance(size, (list, tuple)):
+ # if len(size) >= 2:
+ # x_size, y_size = float(size[0]), float(size[1])
+ # else:
+ # x_size = y_size = float(size[0]) if size else 1.0
+ # else:
+ # x_size = y_size = float(size)
+ #
+ # # 创建卡片
+ # cm = CardMaker('gui_3d_image')
+ # cm.setFrame(-x_size/2, x_size/2, -y_size/2, y_size/2)
+ #
+ # # 创建3D图像节点
+ # image_node = self.world.render.attachNewNode(cm.generate())
+ # image_node.setPos(*pos)
+ #
+ # # 为3D图像创建独立的材质
+ # material = Material(f"image-material-{len(self.gui_elements)}")
+ # material.setBaseColor(LColor(1, 1, 1, 1))
+ # material.setDiffuse(LColor(1, 1, 1, 1))
+ # material.setAmbient(LColor(0.5, 0.5, 0.5, 1))
+ # material.setSpecular(LColor(0.1, 0.1, 0.1, 1.0))
+ # material.setShininess(10.0)
+ # material.setEmission(LColor(0, 0, 0, 1)) # 无自发光
+ # image_node.setMaterial(material, 1)
+ #
+ # image_node.setTransparency(TransparencyAttrib.MAlpha)
+ #
+ # # 如果提供了图像路径，则加载纹理
+ # if image_path:
+ # self.update3DImageTexture(image_node, image_path)
+ #
+ # # 应用PBR效果（如果可用）
+ # try:
+ # if hasattr(self, 'render_pipeline') and self.render_pipeline:
+ # self.render_pipeline.set_effect(
+ # image_node,
+ # "effects/default.yaml",
+ # {
+ # "normal_mapping": True,
+ # "render_gbuffer": True,
+ # "alpha_testing": False,
+ # "parallax_mapping": False,
+ # "render_shadow": False,
+ # "render_envmap": True,
+ # "disable_children_effects": True
+ # },
+ # 50
+ # )
+ # print("✓ GUI 3D图像PBR效果已应用")
+ # except Exception as e:
+ # print(f"⚠️ GUI 3D图像PBR效果应用失败: {e}")
+ #
+ # # 为GUI元素添加标识（效仿3D文本方法）
+ # image_node.setTag("gui_type", "3d_image")
+ # image_node.setTag("gui_id", f"3d_image_{len(self.gui_elements)}")
+ # image_node.setTag("is_scene_element", "1")
+ # image_node.setTag("tree_item_type", "GUI_3DIMAGE")
+ # if image_path:
+ # image_node.setTag("gui_image_path", image_path)
+ # image_node.setTag("is_gui_element", "1")
+ #
+ # self.gui_elements.append(image_node)
+ #
+ # # 更新场景树
+ # if hasattr(self.world, 'updateSceneTree'):
+ # self.world.updateSceneTree()
+ #
+ # print(f"✓ 3D图像创建完成: {image_path or '无纹理'} (世界位置: {pos})")
+ # return image_node
class GUIManager:
"""GUI元素管理系统类"""
@@ -124,7 +126,7 @@ class GUIManager:
# ==================== GUI元素创建方法 ====================
- def createGUIButton(self, pos=(0, 0, 0), text="按钮", size=0.1):
+ def createGUIButton(self, pos=(0, 0, 0), text="按钮", size=(0.1,0.1,0.1)):
"""创建2D GUI按钮 - 支持多选创建和GUI父子关系，优化版本"""
try:
from direct.gui.DirectGui import DirectButton
@@ -180,17 +182,35 @@ class GUIManager:
text_font=self.world.getChineseFont() if self.world.getChineseFont() else None,
rolloverSound=None,
clickSound=None,
- parent=parent_gui_node # 设置GUI父节点
+ parent=parent_gui_node
)
+ if not hasattr(button,'_tags'):
+ button._tags = {}
+
+ # button._tags["gui_type"] = "button"
+ # button._tags["gui_id"] = f"button_{len(self.gui_elements)}"
+ # button._tags["gui_text"] = text
+ # button._tags["is_gui_element"] = "1"
+ # button._tags["is_scene_element"] = "1"
+ # button._tags["saved_gui_type"] = "button"
+ # button._tags["gui_element_type"] = "button"
+ # button._tags["created_by_user"] = "1"
+ # button._tags["name"] = button_name
+ # button.setName(button_name)
+
# 设置节点标签
button.setTag("gui_type", "button")
button.setTag("gui_id", f"button_{len(self.gui_elements)}")
button.setTag("gui_text", text)
button.setTag("is_gui_element", "1")
- button.setTag("is_scene_element", "1")
+ button.setTag("is_scene_element", "1") # 确保这个标签被设置
+ button.setTag("tree_item_type", "GUI_BUTTON")
+ button.setTag("saved_gui_type", "button") # 添加这个标签以确保兼容性
+ button.setTag("gui_element_type", "button")
button.setTag("created_by_user", "1")
button.setTag("gui_parent_type", "gui" if parent_gui_node else "3d")
+ button.setTag("name", button_name)
button.setName(button_name)
# 如果有GUI父节点，建立引用关系
@@ -200,6 +220,7 @@ class GUIManager:
# 添加到GUI元素列表
self.gui_elements.append(button)
+ button.reparentTo(self.world.aspect2d)
print(f"✅ 为 {parent_item.text(0)} 创建GUI按钮成功: {button_name}")
@@ -221,11 +242,11 @@ class GUIManager:
return None
# 选中最后创建的按钮并更新场景树
- if created_buttons:
- last_button, last_qt_item = created_buttons[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- tree_widget.update_selection_and_properties(last_button, last_qt_item)
+ # if created_buttons:
+ # last_button, last_qt_item = created_buttons[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # tree_widget.update_selection_and_properties(last_button, last_qt_item)
print(f"🎉 总共创建了 {len(created_buttons)} 个GUI按钮")
@@ -301,9 +322,11 @@ class GUIManager:
label.setTag("gui_id", f"label_{len(self.gui_elements)}")
label.setTag("gui_text", text)
label.setTag("is_gui_element", "1")
+ label.setTag("tree_item_type", "GUI_LABEL")
label.setTag("is_scene_element", "1")
label.setTag("created_by_user", "1")
label.setTag("gui_parent_type", "gui" if parent_gui_node else "3d")
+ label.setTag("name",label_name)
label.setName(label_name)
# 如果有GUI父节点，建立引用关系
@@ -334,11 +357,11 @@ class GUIManager:
return None
# 选中最后创建的标签并更新场景树
- if created_labels:
- last_label, last_qt_item = created_labels[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- tree_widget.update_selection_and_properties(last_label, last_qt_item)
+ # if created_labels:
+ # last_label, last_qt_item = created_labels[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # tree_widget.update_selection_and_properties(last_label, last_qt_item)
print(f"🎉 总共创建了 {len(created_labels)} 个GUI标签")
@@ -394,6 +417,10 @@ class GUIManager:
parent_gui_node = None
print(f"📎 挂载到3D父节点: {parent_item.text(0)}")
+ font = None
+ if hasattr(self.world,'getChineseFont'):
+ font = self.world.getChineseFont()
+
entry = DirectEntry(
text="",
pos=gui_pos,
@@ -404,7 +431,9 @@ class GUIManager:
numLines=1,
width=12,
focus=0,
- parent=parent_gui_node # 设置GUI父节点
+ parent=parent_gui_node, # 设置GUI父节点
+ text_font = font,
+ frameSize=(-0.1,0.1,-0.05,0.05)
)
# 设置节点标签
@@ -412,9 +441,11 @@ class GUIManager:
entry.setTag("gui_id", f"entry_{len(self.gui_elements)}")
entry.setTag("gui_placeholder", placeholder)
entry.setTag("is_gui_element", "1")
+ entry.setTag("tree_item_type", "GUI_ENTRY")
entry.setTag("is_scene_element", "1")
entry.setTag("created_by_user", "1")
entry.setTag("gui_parent_type", "gui" if parent_gui_node else "3d")
+ entry.setTag("name",entry_name)
entry.setName(entry_name)
# 如果有GUI父节点，建立引用关系
@@ -445,11 +476,11 @@ class GUIManager:
return None
# 选中最后创建的输入框并更新场景树
- if created_entries:
- last_entry, last_qt_item = created_entries[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- tree_widget.update_selection_and_properties(last_entry, last_qt_item)
+ # if created_entries:
+ # last_entry, last_qt_item = created_entries[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # tree_widget.update_selection_and_properties(last_entry, last_qt_item)
print(f"🎉 总共创建了 {len(created_entries)} 个GUI输入框")
@@ -509,7 +540,11 @@ class GUIManager:
cm = CardMaker('gui-2d-image')
cm.setFrame(-size, size, -size, size)
- image_node = self.world.aspect2d.attachNewNode(cm.generate())
+ # image_node = self.world.aspect2d.attachNewNode(cm.generate())
+ if parent_gui_node:
+ image_node = parent_gui_node.attachNewNode(cm.generate())
+ else:
+ image_node = self.world.aspect2d.attachNewNode(cm.generate())
image_node.setPos(gui_pos)
image_node.setBin('fixed', 0)
image_node.setDepthWrite(False)
@@ -522,6 +557,7 @@ class GUIManager:
# 如果提供了图像路径，则加载纹理
if image_path:
try:
+ image_node.setTag("image_path", image_path)
texture = self.world.loader.loadTexture(image_path)
if texture:
image_node.setTexture(texture, 1)
@@ -541,8 +577,10 @@ class GUIManager:
image_node.setTag("gui_text", f"2D图片_{len(self.gui_elements)}")
image_node.setTag("is_gui_element", "1")
image_node.setTag("is_scene_element", "1")
+ image_node.setTag("tree_item_type", "GUI_IMAGE")
image_node.setTag("created_by_user", "1")
image_node.setTag("gui_parent_type", "gui" if parent_gui_node else "3d")
+ image_node.setTag("name",image_name)
image_node.setName(image_name)
# 如果有GUI父节点，建立引用关系
@@ -573,11 +611,11 @@ class GUIManager:
return None
# 选中最后创建的按钮并更新场景树
- if created_2dimage:
- last_button, last_qt_item = created_2dimage[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- tree_widget.update_selection_and_properties(last_button, last_qt_item)
+ # if created_2dimage:
+ # last_button, last_qt_item = created_2dimage[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # tree_widget.update_selection_and_properties(last_button, last_qt_item)
print(f"🎉 总共创建了 {len(created_2dimage)} 个GUI按钮")
@@ -692,7 +730,9 @@ class GUIManager:
textNodePath.setTag("gui_text", text)
textNodePath.setTag("is_gui_element", "1")
textNodePath.setTag("is_scene_element", "1")
+ textNodePath.setTag("tree_item_type", "GUI_3DTEXT")
textNodePath.setTag("created_by_user", "1")
+ textNodePath.setTag("name", text_name)
# 添加到GUI元素列表
self.gui_elements.append(textNodePath)
@@ -717,11 +757,11 @@ class GUIManager:
return None
# 选中最后创建的文本并更新场景树
- if created_texts:
- last_text, last_qt_item = created_texts[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- tree_widget.update_selection_and_properties(last_text, last_qt_item)
+ # if created_texts:
+ # last_text, last_qt_item = created_texts[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # tree_widget.update_selection_and_properties(last_text, last_qt_item)
print(f"🎉 总共创建了 {len(created_texts)} 个3D文本")
@@ -740,6 +780,7 @@ class GUIManager:
def createGUI3DImage(self, pos=(0, 0, 0), image_path=None, size=1.0):
"""创建3D空间图片"""
try:
+
from panda3d.core import TextNode
from PyQt5.QtCore import Qt
@@ -779,7 +820,8 @@ class GUIManager:
cm.setFrame(-x_size / 2, x_size / 2, -y_size / 2, y_size / 2)
# 创建3D图像节点
- image_node = self.world.render.attachNewNode(cm.generate())
+ # image_node = self.world.render.attachNewNode(cm.generate())
+ image_node = parent_node.attachNewNode(cm.generate())
image_node.setPos(*pos)
# 为3D图像创建独立的材质
@@ -824,10 +866,12 @@ class GUIManager:
image_node.setTag("gui_type", "3d_image")
image_node.setTag("gui_id", f"3d_image_{len(self.gui_elements)}")
if image_path:
- image_node.setTag("gui_image_path", image_path)
+ image_node.setTag("image_path", image_path)
image_node.setTag("is_gui_element", "1")
image_node.setTag("is_scene_element", "1")
+ image_node.setTag("tree_item_type", "GUI_3DIMAGE")
image_node.setTag("created_by_user", "1")
+ image_node.setTag("name",image_name)
# 添加到GUI元素列表
self.gui_elements.append(image_node)
@@ -852,11 +896,11 @@ class GUIManager:
return None
# 选中最后创建的文本并更新场景树
- if created_3dimage:
- last_image, last_qt_item = created_3dimage[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- tree_widget.update_selection_and_properties(last_image, last_qt_item)
+ # if created_3dimage:
+ # last_image, last_qt_item = created_3dimage[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # tree_widget.update_selection_and_properties(last_image, last_qt_item)
print(f"🎉 总共创建了 {len(created_3dimage)} 个3D文本")
@@ -872,7 +916,7 @@ class GUIManager:
traceback.print_exc()
return None
- def createVideoScreen(self, pos=(0, 0, 0), size=0.2, video_path=None):
+ def createVideoScreen(self, pos=(0, 0, 0), size=1, video_path=None):
"""创建3D视频播放屏幕 - 添加占位符纹理支持"""
try:
from panda3d.core import CardMaker, TransparencyAttrib, Texture, TextureStage
@@ -895,7 +939,7 @@ class GUIManager:
size = float(size)
except (ValueError, TypeError):
print(f"⚠️ 尺寸参数无效，使用默认值 0.2，原始值: {size}")
- size = 0.2
+ size = 0.2*5
print(f"📺 开始创建视频屏幕，位置: {pos}, 尺寸: {size}, 视频路径: {video_path}")
@@ -944,7 +988,9 @@ class GUIManager:
video_screen.setTag("gui_text", f"视频屏幕_{len(self.gui_elements)}")
video_screen.setTag("is_gui_element", "1")
video_screen.setTag("is_scene_element", "1")
+ video_screen.setTag("tree_item_type", "GUI_VIDEO_SCREEN")
video_screen.setTag("created_by_user", "1")
+ video_screen.setTag("name",screen_name)
# 设置视频路径标签
if video_path and os.path.exists(video_path):
@@ -1042,12 +1088,12 @@ class GUIManager:
return None
# 选中最后创建的视频屏幕
- if created_videoscreens:
- last_screen_np, last_qt_item = created_videoscreens[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- # 更新选择和属性面板
- tree_widget.update_selection_and_properties(last_screen_np, last_qt_item)
+ # if created_videoscreens:
+ # last_screen_np, last_qt_item = created_videoscreens[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # # 更新选择和属性面板
+ # tree_widget.update_selection_and_properties(last_screen_np, last_qt_item)
print(f"🎉 总共创建了 {len(created_videoscreens)} 个视频屏幕")
@@ -1125,6 +1171,7 @@ class GUIManager:
# 检查是否有播放方法
if hasattr(movie_texture, 'play'):
try:
+ self.loadVideoFile(video_screen, video_screen.getTag("video_path"))
movie_texture.play()
print(f"▶️ 继续播放视频: {video_screen.getName()}")
return True
@@ -1135,9 +1182,7 @@ class GUIManager:
print(f"⚠️ 纹理对象没有播放方法: {video_screen.getName()}")
return False
else:
- print(f"❌ 视频屏幕没有关联的视频纹理: {video_screen.getName()}")
- self._debugVideoScreenTextures(video_screen)
- return False
+ self.loadVideoFile(video_screen,video_screen.getTag("video_path"))
except Exception as e:
print(f"❌ 播放视频失败: {e}")
import traceback
@@ -1264,7 +1309,6 @@ class GUIManager:
def loadVideoFile(self, video_screen, video_path):
"""为视频屏幕加载新的视频文件"""
try:
- from panda3d.core import Texture, TextureStage
import os
if not os.path.exists(video_path):
@@ -1422,8 +1466,6 @@ class GUIManager:
print(f"⚠️ 尺寸参数无效，使用默认值 0.2，原始值: {size}, 错误: {e}")
size = 0.2
- print(f"📺 开始创建2D视频屏幕，位置: {pos}, 尺寸: {size}, 视频路径: {video_path}")
-
# 获取树形控件
tree_widget = self._get_tree_widget()
if not tree_widget:
@@ -1450,7 +1492,7 @@ class GUIManager:
frameColor=(1, 1, 1, 1), # 默认背景色
pos=(pos[0] * 0.1, 0, pos[1] * 0.1), # 转换为屏幕坐标
parent=parent_node if tree_widget.is_gui_element(parent_node) else self.world.aspect2d,
- suppressMouse=True
+ suppressMouse=True,
)
video_screen.setName(screen_name)
@@ -1458,19 +1500,18 @@ class GUIManager:
# 设置透明度支持
video_screen.setTransparency(TransparencyAttrib.MAlpha)
- # 设置2D视频屏幕特有的标签
+ #设置2D视频屏幕特有的标签
video_screen.setTag("gui_type", "2d_video_screen")
video_screen.setTag("gui_id", f"2d_video_screen_{len(self.gui_elements)}")
video_screen.setTag("gui_text", f"2D视频屏幕_{len(self.gui_elements)}")
video_screen.setTag("is_gui_element", "1")
video_screen.setTag("is_scene_element", "1")
+ video_screen.setTag("tree_item_type", "GUI_2D_VIDEO_SCREEN")
video_screen.setTag("created_by_user", "1")
+ video_screen.setTag("name",screen_name)
- # 设置视频路径标签
- if video_path and os.path.exists(video_path):
- video_screen.setTag("video_path", video_path)
- else:
- video_screen.setTag("video_path", "")
+ video_screen.setTag("video_path", video_path if video_path else "")
+ print(f"🔧 设置2D视频屏幕标签 - video_path: {video_path if video_path else '空'}")
# 关键修改：预先创建一个占位符纹理，为后续视频播放做准备
placeholder_texture = Texture(f"placeholder_video_texture_{len(self.gui_elements)}")
@@ -1543,12 +1584,12 @@ class GUIManager:
return None
# 选中最后创建的视频屏幕
- if created_videoscreens:
- last_screen_np, last_qt_item = created_videoscreens[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- # 更新选择和属性面板
- tree_widget.update_selection_and_properties(last_screen_np, last_qt_item)
+ # if created_videoscreens:
+ # last_screen_np, last_qt_item = created_videoscreens[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # # 更新选择和属性面板
+ # tree_widget.update_selection_and_properties(last_screen_np, last_qt_item)
print(f"🎉 总共创建了 {len(created_videoscreens)} 个2D视频屏幕")
@@ -1569,7 +1610,11 @@ class GUIManager:
try:
import os
- if not os.path.exists(video_path):
+ video_screen.setTag("video_path",video_path)
+ path = video_screen.getTag("video_path")
+ print(f"🔧 更新2D视频屏幕标签 - video_path: {path}")
+
+ if not video_path or not os.path.exists(video_path):
print(f"❌ 2D视频文件不存在: {video_path}")
return False
@@ -1581,7 +1626,6 @@ class GUIManager:
# 保存视频纹理引用
video_screen.setPythonTag("movie_texture", movie_texture)
- video_screen.setTag("video_path", video_path)
print(f"✅ 成功加载新2D视频: {video_path}")
return True
@@ -1776,6 +1820,7 @@ class GUIManager:
# 设置标签以便识别和管理
sphere_np.setTag("gui_type", "spherical_video")
sphere_np.setTag("is_gui_element", "1")
+ sphere_np.setTag("tree_item_type", "GUI_SPHERICAL_VIDEO")
sphere_np.setTag("video_path", video_path or "")
sphere_np.setTag("original_radius", str(radius))
@@ -1808,12 +1853,12 @@ class GUIManager:
return None
# 选中最后创建的球形视频
- if created_spherical_videos:
- last_sphere_np, last_qt_item = created_spherical_videos[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- # 更新选择和属性面板
- tree_widget.update_selection_and_properties(last_sphere_np, last_qt_item)
+ # if created_spherical_videos:
+ # last_sphere_np, last_qt_item = created_spherical_videos[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # # 更新选择和属性面板
+ # tree_widget.update_selection_and_properties(last_sphere_np, last_qt_item)
print(f"🎉 总共创建了 {len(created_spherical_videos)} 个球形视频")
@@ -1988,6 +2033,7 @@ class GUIManager:
virtual_screen.setTag("gui_text", text)
virtual_screen.setTag("is_gui_element", "1")
virtual_screen.setTag("is_scene_element", "1")
+ virtual_screen.setTag("tree_item_type", "GUI_VirtualScreen")
virtual_screen.setTag("created_by_user", "1")
# 添加到GUI元素列表
@@ -2013,12 +2059,12 @@ class GUIManager:
return None
# 选中最后创建的虚拟屏幕
- if created_screens:
- last_screen_np, last_qt_item = created_screens[-1]
- if last_qt_item:
- tree_widget.setCurrentItem(last_qt_item)
- # 更新选择和属性面板
- tree_widget.update_selection_and_properties(last_screen_np, last_qt_item)
+ # if created_screens:
+ # last_screen_np, last_qt_item = created_screens[-1]
+ # if last_qt_item:
+ # tree_widget.setCurrentItem(last_qt_item)
+ # # 更新选择和属性面板
+ # tree_widget.update_selection_and_properties(last_screen_np, last_qt_item)
print(f"🎉 总共创建了 {len(created_screens)} 个虚拟屏幕")
@@ -2070,7 +2116,9 @@ class GUIManager:
pass
return None
+ # 暂无滑块功能
def createGUISlider(self, pos=(0, 0, 0), text="滑块", scale=0.3):
+ pass
"""创建2D GUI滑块"""
from direct.gui.DirectGui import DirectSlider
@@ -2105,19 +2153,22 @@ class GUIManager:
"""删除GUI元素"""
try:
if gui_element in self.gui_elements:
- # 移除GUI元素
- if hasattr(gui_element, 'removeNode'):
- gui_element.removeNode()
- elif hasattr(gui_element, 'destroy'):
- gui_element.destroy()
-
- # 从列表中移除
- self.gui_elements.remove(gui_element)
+ # # 移除GUI元素
+ # if hasattr(gui_element, 'removeNode'):
+ # gui_element.removeNode()
+ # elif hasattr(gui_element, 'destroy'):
+ # gui_element.destroy()
+ #
+ # # 从列表中移除
+ # self.gui_elements.remove(gui_element)
# 更新场景树
# 安全地调用updateSceneTree
- if hasattr(self.world, 'updateSceneTree'):
- self.world.updateSceneTree()
+ tree_widget = self._get_tree_widget()
+ if tree_widget:
+ tree_widget.delete_items(tree_widget.selectedItems())
+ # if hasattr(self.world, 'updateSceneTree'):
+ # self.world.updateSceneTree()
print(f"删除GUI元素: {gui_element}")
return True
@@ -2910,7 +2961,7 @@ class GUIManager:
heightSpinBox.valueChanged.connect(
lambda v: self.world.gui_manager.editGUIScale(gui_element, "z", v))
transform_layout.addWidget(heightSpinBox, 4, 3)
-
+
else:
# 3D GUI组件使用世界坐标
transform_layout.addWidget(QLabel("位置"), 0, 0)
@@ -2990,11 +3041,11 @@ class GUIManager:
transform_layout.addWidget(scale_z, 3, 3)
transform_group.setLayout(transform_layout)
self._propertyLayout.addWidget(transform_group)
-
+
# 缩放属性
if hasattr(gui_element, 'getScale'):
scale = gui_element.getScale()
-
+
scaleSpinBox = QDoubleSpinBox()
scaleSpinBox.setRange(0.01, 100)
scaleSpinBox.setSingleStep(0.1)
@@ -3207,7 +3258,7 @@ class GUIManager:
try:
gui_type = gui_element.getTag("gui_type")
- if gui_type in ["3d_text", "3d_image", "video_screen","info_panel"]:
+ if gui_type in ["3d_text", "3d_image", "video_screen","info_panel","info_panel_3d"]:
current_pos = gui_element.getPos()
if axis == "x":
@@ -3220,7 +3271,7 @@ class GUIManager:
return False
gui_element.setPos(*new_pos)
- print(f"✓ 更新3D GUI元素位置: {axis}={value}")
+ #print(f"✓ 更新3D GUI元素位置: {axis}={value}")
return True
else:
print(f"✗ 不支持的GUI类型进行3D位置编辑: {gui_type}")
@@ -3241,7 +3292,7 @@ class GUIManager:
if value == 0:
value = 0.01
- if gui_type in ["3d_text", "3d_image","video_screen","virtual_screen","info_panel"]:
+ if gui_type in ["3d_text", "3d_image","video_screen","virtual_screen","info_panel","info_panel_3d"]:
# 3D元素处理
if axis == "x":
new_scale = (value, current_scale.getY(), current_scale.getZ())
diff --git a/icons/logo.png b/icons/logo.png
new file mode 100644
index 00000000..361b35c7
Binary files /dev/null and b/icons/logo.png differ
diff --git a/main.py b/main.py
index 137b8566..bd204899 100644
--- a/main.py
+++ b/main.py
@@ -22,6 +22,7 @@ from core.script_system import ScriptManager
from core.vr_manager import VRManager
from core.vr_input_handler import VRInputHandler
from core.alvr_streamer import ALVRStreamer
+from core.patrol_system import PatrolSystem
from gui.gui_manager import GUIManager
from core.terrain_manager import TerrainManager
from scene.scene_manager import SceneManager
@@ -55,7 +56,16 @@ class MyWorld(CoreWorld):
# 初始化选择和变换系统
self.selection = SelectionSystem(self)
-
+
+ # 绑定F键用于聚焦选中节点
+ self.accept("f", self.onFocusKeyPressed)
+ self.accept("F", self.onFocusKeyPressed) # 大写F
+
+ #初始化巡检系统
+ self.patrol_system = PatrolSystem(self)
+ self.accept("p",self.onPatrolKeyPressed)
+ self.accept("P",self.onPatrolKeyPressed)
+
# 初始化事件处理系统
self.event_handler = EventHandler(self)
@@ -225,7 +235,7 @@ class MyWorld(CoreWorld):
"""创建2D GUI文本输入框"""
return self.gui_manager.createGUIEntry(pos, placeholder, size)
- def createGUI3DText(self, pos=(0, 0, 0), text="3D文本", size=0.5):
+ def createGUI3DText(self, pos=(0, 0, 0), text="3D文本", size=1):
"""创建3D空间文本"""
return self.gui_manager.createGUI3DText(pos, text, size)
@@ -233,9 +243,9 @@ class MyWorld(CoreWorld):
"""创建3D图片"""
return self.gui_manager.createGUI3DImage(pos,text,size)
- def createGUI2DImage(self, pos=(0, 0, 0), image_path=None, size=0.2):
+ def createGUI2DImage(self, pos=(0, 0, 0), image_path=None, size=1):
"""创建2D GUI图片"""
- return self.gui_manager.createGUI2DImage(pos, image_path, size)
+ return self.gui_manager.createGUI2DImage(pos, image_path, size*0.2)
def createVideoScreen(self,pos=(0,0,0),size=1,video_path=None):
"""创建视频屏幕"""
@@ -492,10 +502,6 @@ class MyWorld(CoreWorld):
"""异步导入模型"""
return self.scene_manager.importModelAsync(filepath)
- def loadAnimatedModel(self, model_path, anims=None):
- """加载带动画的模型"""
- return self.scene_manager.loadAnimatedModel(model_path, anims)
-
# 材质和几何体处理方法 - 代理到scene_manager
def processMaterials(self, model):
"""处理模型材质"""
@@ -814,6 +820,97 @@ class MyWorld(CoreWorld):
"""获取碰撞统计"""
return self.collision_manager.getCollisionStatistics()
+ def setupKeyboardEvents(self):
+ """设置键盘事件"""
+ try:
+ # 绑定 F 键用于聚焦选中节点
+ self.accept("f", self.onFocusKeyPressed)
+ self.accept("F", self.onFocusKeyPressed) # 大写F
+
+ print("✓ 键盘事件绑定完成")
+
+ except Exception as e:
+ print(f"设置键盘事件失败: {e}")
+
+ def onFocusKeyPressed(self):
+ """处理 F 键按下事件"""
+ try:
+ #print("检测到 F 键按下")
+
+ # 检查是否有选中的节点
+ if hasattr(self, 'selection') and self.selection.selectedNode:
+ #print(f"当前选中节点: {self.selection.selectedNode.getName()}")
+ # 调用选择系统的聚焦功能（可以选择带动画或不带动画的版本）
+ # self.selection.focusCameraOnSelectedNode() # 无动画版本
+ self.selection.focusCameraOnSelectedNodeAdvanced() # 带动画版本
+ else:
+ print("当前没有选中任何节点")
+
+ except Exception as e:
+ print(f"处理 F 键事件失败: {e}")
+
+ def onPatrolKeyPressed(self):
+ """处理 P 键按下事件 - 控制巡检系统"""
+ try:
+ print("检测到 P 键按下")
+
+ if not self.patrol_system.is_patrolling:
+ # 如果巡检系统没有点，创建默认巡检路线
+ if not self.patrol_system.patrol_points:
+ self.createDefaultPatrolRoute()
+
+ # 开始巡检
+ if self.patrol_system.start_patrol():
+ print("✓ 巡检已开始")
+ else:
+ print("✗ 巡检启动失败")
+ else:
+ # 停止巡检
+ if self.patrol_system.stop_patrol():
+ print("✓ 巡检已停止")
+ else:
+ print("✗ 巡检停止失败")
+
+ except Exception as e:
+ print(f"处理 P 键事件失败: {e}")
+
+ def createDefaultPatrolRoute(self):
+ """创建默认巡检路线（使用自动朝向）"""
+ try:
+ # 清空现有巡检点
+ self.patrol_system.clear_patrol_points()
+
+ # 添加巡检点，使用None表示朝向下一个点
+ self.patrol_system.add_patrol_point((0, -10, 2), (0,0,0), 1.5)
+ self.patrol_system.add_patrol_point((10, -10, 2), (0,0,0), 1.5)
+ self.patrol_system.add_patrol_point((10, 5, 2), (0,0,0), 1.5)
+ self.patrol_system.add_patrol_point((10, 0, 5), (0,0,0), 1.5)
+
+ # 最后一个点可以指定特定的朝向，或者也设为None继续循环
+ self.patrol_system.add_patrol_point((0, -10, 2), None, 2.5)
+
+ print("✓ 默认自动朝向巡检路线已创建")
+ self.patrol_system.list_patrol_points()
+
+ except Exception as e:
+ print(f"创建默认自动朝向巡检路线失败: {e}")
+
+ def _serializeNode(self, node):
+ """序列化节点数据"""
+ try:
+ return self.world.scene_manager.serializeNode(node)
+ except Exception as e:
+ print(f"序列化节点失败: {e}")
+ return None
+
+ def _deserializeNode(self, node_data, parent_node):
+ """反序列化节点数据"""
+ try:
+ return self.world.scene_manager.deserializeNode(node_data, parent_node)
+ except Exception as e:
+ print(f"反序列化节点失败: {e}")
+ return None
+
# ==================== 项目管理功能代理 ====================
# 以下函数代理到project_manager模块的对应功能
@@ -830,6 +927,7 @@ def createNewProject(parent_window):
def saveProject(appw):
"""保存项目 - 代理到project_manager"""
+
world = appw.centralWidget().world
return world.project_manager.saveProject(appw)
@@ -838,19 +936,26 @@ def openProject(appw):
world = appw.centralWidget().world
return world.project_manager.openProject(appw)
+def openProjectForPath(project_path, appw):
+ """打开项目 - 代理到project_manager"""
+ world = appw.centralWidget().world
+ return world.project_manager.openProjectForPath(project_path, appw)
+
def buildPackage(appw):
"""打包项目 - 代理到project_manager"""
world = appw.centralWidget().world
return world.project_manager.buildPackage(appw)
-
-if __name__ == "__main__":
+def run(args = None):
world = MyWorld()
# 使用新的UI模块创建主窗口
from ui.main_window import setup_main_window
-
- app, main_window = setup_main_window(world)
-
+ print(f'Path is {args}')
+ app, main_window = setup_main_window(world, args)
+
# 启动应用程序
- sys.exit(app.exec_())
\ No newline at end of file
+ sys.exit(app.exec_())
+
+if __name__ == "__main__":
+ run()
\ No newline at end of file
diff --git a/project/project_manager.py b/project/project_manager.py
index e54a9995..31b2df70 100644
--- a/project/project_manager.py
+++ b/project/project_manager.py
@@ -9,7 +9,6 @@
import os
import sys
import json
-import re
import datetime
import subprocess
import shutil
@@ -47,7 +46,9 @@ class ProjectManager:
project_path = dialog.projectPath
project_name = dialog.projectName
- full_project_path = os.path.join(project_path, project_name)
+ # full_project_path = os.path.join(project_path, project_name)
+ full_project_path = os.path.normpath(os.path.join(project_path, project_name))
+ print(f"full_project_path: {full_project_path}")
try:
# 创建项目文件夹结构
@@ -72,13 +73,13 @@ class ProjectManager:
json.dump(project_config, f, ensure_ascii=False, indent=4)
print(f"项目配置文件已创建: {config_file}")
-
+
# 清空当前场景
self._clearCurrentScene()
-
+
# 自动保存初始场景
scene_file = os.path.join(scenes_path, "scene.bam")
- if self.world.scene_manager.saveScene(scene_file):
+ if self.world.scene_manager.saveScene(scene_file, project_path):
# 更新配置文件中的场景路径
project_config["scene_file"] = os.path.relpath(scene_file, full_project_path)
with open(config_file, "w", encoding="utf-8") as f:
@@ -122,57 +123,157 @@ class ProjectManager:
if not project_path:
return False
-
+
# 检查是否是有效的项目文件夹
config_file = os.path.join(project_path, "project.json")
if not os.path.exists(config_file):
QMessageBox.warning(parent_window, "警告", "选择的不是有效的项目文件夹！")
return False
-
+
# 读取项目配置
with open(config_file, "r", encoding="utf-8") as f:
project_config = json.load(f)
-
+
# 检查场景文件
scene_file = os.path.join(project_path, "scenes", "scene.bam")
- if not os.path.exists(scene_file):
- QMessageBox.warning(parent_window, "警告", "没有找到场景文件！")
- return False
-
- # 加载场景
- if self.world.scene_manager.loadScene(scene_file):
- # 更新项目配置
- 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.current_project_path = project_path
- self.project_config = project_config
-
- # 保存当前项目路径到主窗口
- parent_window.current_project_path = project_path
-
- # 更新窗口标题
- project_name = os.path.basename(project_path)
- self.updateWindowTitle(parent_window, project_name)
-
- # 更新文件浏览器
- if hasattr(parent_window, 'fileView') and hasattr(parent_window, 'fileModel'):
- parent_window.fileView.setRootIndex(parent_window.fileModel.index(project_path))
-
- QMessageBox.information(parent_window, "成功", "项目加载成功！")
- return True
- else:
- QMessageBox.warning(parent_window, "错误", "加载场景失败！")
- return False
-
+ if os.path.exists(scene_file):
+ # 加载场景
+ if self.world.scene_manager.loadScene(scene_file):
+ # 更新项目配置
+ project_config["scene_file"] = os.path.relpath(scene_file, project_path)
+
+ project_config["last_modified"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+ with open(config_file, "w", encoding="utf-8") as f:
+ json.dump(project_config, f, ensure_ascii=False, indent=4)
+
+ # 更新项目状态
+ self.current_project_path = project_path
+ self.project_config = project_config
+
+ # 保存当前项目路径到主窗口
+ parent_window.current_project_path = project_path
+
+ # 更新窗口标题
+ project_name = os.path.basename(project_path)
+ self.updateWindowTitle(parent_window, project_name)
+
+ # 更新文件浏览器
+ if hasattr(parent_window, 'fileView') and hasattr(parent_window, 'fileModel'):
+ parent_window.fileView.setRootIndex(parent_window.fileModel.index(project_path))
+
+ QMessageBox.information(parent_window, "成功", "项目加载成功！")
+ return True
+ # 检查场景文件
+ # scene_file = os.path.join(project_path, "scenes", "scene.bam")
+ # if not os.path.exists(scene_file):
+ # QMessageBox.warning(parent_window, "警告", "没有找到场景文件！")
+ # return False
+ #
+ # # 加载场景
+ # if self.world.scene_manager.loadScene(scene_file):
+ # # 更新项目配置
+ # 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.current_project_path = project_path
+ # self.project_config = project_config
+ #
+ # # 保存当前项目路径到主窗口
+ # parent_window.current_project_path = project_path
+ #
+ # # 更新窗口标题
+ # project_name = os.path.basename(project_path)
+ # self.updateWindowTitle(parent_window, project_name)
+ #
+ # # 更新文件浏览器
+ # if hasattr(parent_window, 'fileView') and hasattr(parent_window, 'fileModel'):
+ # parent_window.fileView.setRootIndex(parent_window.fileModel.index(project_path))
+ #
+ # QMessageBox.information(parent_window, "成功", "项目加载成功！")
+ # return True
+ # else:
+ # QMessageBox.warning(parent_window, "错误", "加载场景失败！")
+ # return False
+
except Exception as e:
QMessageBox.critical(parent_window, "错误", f"加载项目时发生错误：{str(e)}")
return False
-
+
+ def openProjectForPath(self, project_path, parent_window=None):
+ """通过路径打开项目
+
+ Args:
+ project_path: 项目路径
+ parent_window: 父窗口对象（可选）
+ """
+ try:
+ if not project_path:
+ return False
+ # 检查是否是有效的项目文件夹
+ config_file = os.path.join(project_path, "project.json")
+ if not os.path.exists(config_file):
+ if parent_window:
+ QMessageBox.warning(parent_window, "警告", f"选择的不是有效的项目文件夹！{project_path}")
+ else:
+ print("警告: 选择的不是有效的项目文件夹！")
+ return False
+
+ # 读取项目配置
+ with open(config_file, "r", encoding="utf-8") as f:
+ project_config = json.load(f)
+
+ # 检查场景文件
+ scene_file = os.path.join(project_path, "scenes", "scene.bam")
+ if os.path.exists(scene_file):
+ # 加载场景
+ if self.world.scene_manager.loadScene(scene_file):
+ # 更新项目配置
+ project_config["scene_file"] = os.path.relpath(scene_file, project_path)
+
+ project_config["last_modified"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+ with open(config_file, "w", encoding="utf-8") as f:
+ json.dump(project_config, f, ensure_ascii=False, indent=4)
+
+ # 更新项目状态
+ self.current_project_path = project_path
+ self.project_config = project_config
+
+ # 如果有父窗口，更新相关UI元素
+ if parent_window:
+ # 保存当前项目路径到主窗口
+ parent_window.current_project_path = project_path
+
+ # 更新窗口标题
+ project_name = os.path.basename(project_path)
+ self.updateWindowTitle(parent_window, project_name)
+
+ # 更新文件浏览器
+ if hasattr(parent_window, 'fileView') and hasattr(parent_window, 'fileModel'):
+ parent_window.fileView.setRootIndex(parent_window.fileModel.index(project_path))
+
+ QMessageBox.information(parent_window, "成功", "项目加载成功！")
+
+ print(f"项目 '{project_path}' 加载成功！")
+ return True
+ else:
+ if parent_window:
+ QMessageBox.warning(parent_window, "错误", "加载场景失败！")
+ else:
+ print("错误: 加载场景失败！")
+ return False
+
+ except Exception as e:
+ error_msg = f"加载项目时发生错误：{str(e)}"
+ if parent_window:
+ QMessageBox.critical(parent_window, "错误", error_msg)
+ else:
+ print(error_msg)
+ return False
+
def saveProject(self, parent_window):
"""保存项目"""
try:
@@ -201,7 +302,7 @@ class ProjectManager:
return False
# 保存场景
- if self.world.scene_manager.saveScene(scene_file):
+ if self.world.scene_manager.saveScene(scene_file, project_path):
# 更新项目配置文件
config_file = os.path.join(project_path, "project.json")
if os.path.exists(config_file):
diff --git a/scene/scene_manager.py b/scene/scene_manager.py
index 69ee1d49..1ad2d9ab 100644
--- a/scene/scene_manager.py
+++ b/scene/scene_manager.py
@@ -7,20 +7,24 @@
"""
import os
+import time
from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QTreeWidgetItem
from panda3d.core import (
ModelPool, ModelRoot, Filename, NodePath, GeomNode, Material, Vec4, Vec3,
- MaterialAttrib, ColorAttrib, Point3, CollisionNode, CollisionSphere,
- BitMask32, TransparencyAttrib,LColor
+ MaterialAttrib, ColorAttrib, Point3, CollisionNode, CollisionSphere,
+ BitMask32, TransparencyAttrib, LColor, TransformState
)
import json
import aiohttp
import asyncio
+import inspect
from pathlib import Path
from panda3d.egg import EggData, EggVertexPool
from direct.actor.Actor import Actor
from QPanda3D.Panda3DWorld import get_render_pipeline
+from RenderPipelineFile.rpplugins.smaa.jitters import halton_seq
from scene import util
class CesiumIntegration:
@@ -97,20 +101,29 @@ class SceneManager:
normalize_scales: 是否标准化子节点缩放（推荐开启）
auto_convert_to_glb: 是否自动将非GLB格式转换为GLB以获得更好的动画支持
"""
+
try:
print(f"\n=== 开始导入模型: {filepath} ===")
- print(f"单位转换: {'开启' if apply_unit_conversion else '关闭'}")
- print(f"自动转换GLB: {'开启' if auto_convert_to_glb else '关闭'}")
+ #print(f"单位转换: {'开启' if apply_unit_conversion else '关闭'}")
+ #print(f"自动转换GLB: {'开启' if auto_convert_to_glb else '关闭'}")
filepath = util.normalize_model_path(filepath)
original_filepath = filepath
+ # 在加载前设置忽略未知属性
+ from panda3d.core import ConfigVariableBool
+ ConfigVariableBool("model-cache-ignore-unknown-properties").setValue(True)
+
+ # 清除可能存在的模型缓存
+ from panda3d.core import ModelPool
+ ModelPool.releaseAllModels()
+
# 检查是否需要转换为GLB以获得更好的动画支持
if auto_convert_to_glb and self._shouldConvertToGLB(filepath):
- print(f"🔄 检测到需要转换的格式，尝试转换为GLB...")
+ #print(f"🔄 检测到需要转换的格式，尝试转换为GLB...")
converted_path = self._convertToGLBWithProgress(filepath)
if converted_path:
- print(f"✅ 转换成功: {converted_path}")
+ #print(f"✅ 转换成功: {converted_path}")
filepath = converted_path
# 显示成功消息
try:
@@ -125,7 +138,7 @@ class SceneManager:
# 总是重新加载模型以确保材质信息完整
# 不使用ModelPool缓存，避免材质信息丢失问题
- print("直接从文件加载模型...")
+ #print("直接从文件加载模型...")
model = self.world.loader.loadModel(filepath)
if not model:
print("加载模型失败")
@@ -133,10 +146,18 @@ class SceneManager:
# 设置模型名称
model_name = os.path.basename(filepath)
+ # 确保名称有效
+ if not model_name:
+ model_name = "imported_model"
model.setName(model_name)
-
# 将模型添加到场景
model.reparentTo(self.world.render)
+
+ # 设置模型名称
+ model_name = os.path.basename(filepath)
+ model.setName(model_name)
+
+
# 保存原始路径和转换后的路径
model.setTag("model_path", filepath)
model.setTag("original_path", original_filepath)
@@ -144,18 +165,31 @@ class SceneManager:
model.setTag("converted_from", os.path.splitext(original_filepath)[1])
model.setTag("converted_to_glb", "true")
- # 可选的单位转换（主要针对FBX）
- if apply_unit_conversion and filepath.lower().endswith('.fbx'):
- print("应用FBX单位转换（厘米到米）...")
- self._applyUnitConversion(model, 0.01)
+ # 特殊处理FBX模型
+ # if filepath.lower().endswith('.fbx'):
+ # print("检测到FBX模型，应用特殊处理...")
+ #
+ # # 将模型缩放设置为原来的1/100
+ # model.setScale(0.01)
+ # print("设置模型缩放为 0.01 (原始大小的1/100)")
+ #
+ # # 设置模型旋转为 (0, 90, 0)
+ # model.setHpr(0, 90, 0)
+ # print("设置模型旋转为 (0, 90, 0)")
- # 智能缩放标准化（处理FBX子节点的大缩放值）
- if normalize_scales and filepath.lower().endswith('.fbx'):
- print("标准化FBX模型缩放层级...")
- self._normalizeModelScales(model)
+ # # 可选的单位转换（主要针对FBX
+ # if apply_unit_conversion and filepath.lower().endswith('.fbx'):
+ # #print("应用FBX单位转换（厘米到米）...")
+ # self._applyUnitConversion(model, 0.01)
+ #
+ # # 智能缩放标准化（处理FBX子节点的大缩放值）
+ # if normalize_scales and filepath.lower().endswith('.fbx'):
+ # #print("标准化FBX模型缩放层级...")
+ # self._normalizeModelScales(model)
# 调整模型位置到地面
- self._adjustModelToGround(model)
+ model.setPos(0,0,0)
+ #self._adjustModelToGround(model)
# 创建并设置基础材质
print("\n=== 开始设置材质 ===")
@@ -168,6 +202,8 @@ class SceneManager:
# 添加文件标签用于保存/加载
model.setTag("file", model_name)
model.setTag("is_model_root", "1")
+ model.setTag("is_scene_element", "1")
+ model.setTag("tree_item_type", "IMPORTED_MODEL_NODE")
# 记录应用的处理选项
if apply_unit_conversion:
@@ -179,7 +215,29 @@ class SceneManager:
self.models.append(model)
# 更新场景树
- self.updateSceneTree()
+ # 获取树形控件并添加到Qt树中
+ tree_widget = self._get_tree_widget()
+ if tree_widget:
+ # 找到根节点项
+ root_item = None
+ for i in range(tree_widget.topLevelItemCount()):
+ item = tree_widget.topLevelItem(i)
+ if item.text(0) == "render" or item.data(0, Qt.UserRole) == self.world.render:
+ root_item = item
+ break
+
+ if root_item:
+ qt_item = tree_widget.add_node_to_tree_widget(model, root_item, "IMPORTED_MODEL_NODE")
+ if qt_item:
+ #tree_widget.setCurrentItem(qt_item)
+ # 更新选择和属性面板
+ #tree_widget.update_selection_and_properties(model, qt_item)
+ print("✅ Qt树节点添加成功")
+ else:
+ print("⚠️ Qt树节点添加失败，但Panda3D对象已创建")
+ else:
+ print("⚠️ 未找到根节点项，无法添加到Qt树")
+ #self.updateSceneTree()
print(f"=== 模型导入成功: {model_name} ===\n")
return model
@@ -188,17 +246,158 @@ class SceneManager:
print(f"导入模型失败: {str(e)}")
return None
+ def _fixModelStructure(self, model):
+ """修复模型结构"""
+ try:
+ # 使用正确的方式查找动画相关节点
+ character_nodes = model.findAllMatches("**/+Character")
+ anim_bundle_nodes = model.findAllMatches("**/+AnimBundleNode")
+
+ if character_nodes.getNumPaths() > 0 or anim_bundle_nodes.getNumPaths() > 0:
+ print(f"检测到模型{model.getName()}包含角色相节点:")
+ if character_nodes.getNumPaths() > 0:
+ print(f"CharacterNode数量：{character_nodes.getNumPaths()}")
+ if anim_bundle_nodes.getNumPaths() > 0:
+ print(f"AnimBundleNode数量: {anim_bundle_nodes.getNumPaths()}")
+
+ model.setTag("fixed_structure", "true")
+ return True
+ except Exception as e:
+ print(f"修复模型结构时出错: {e}")
+ return False
+
+ def _validateAndFixAllTransforms(self, model):
+ """递归验证并修复模型中所有节点的变换矩阵"""
+ try:
+ fixed_count = 0
+
+ # 先处理根节点
+ if not self._validateAndFixTransform(model):
+ fixed_count += 1
+
+ # 递归处理所有子节点
+ def process_children(node, depth=0):
+ nonlocal fixed_count
+ for i in range(node.getNumChildren()):
+ try:
+ child = node.getChild(i)
+ if not self._validateAndFixTransform(child):
+ fixed_count += 1
+ # 递归处理孙节点
+ process_children(child, depth + 1)
+ except Exception as e:
+ print(f"处理子节点时出错 (深度 {depth}): {e}")
+ continue
+
+ process_children(model)
+
+ if fixed_count > 0:
+ print(f"共修复了 {fixed_count} 个节点的变换")
+
+ return True
+ except Exception as e:
+ print(f"验证所有变换时出错: {e}")
+ return False
+
+ def _validateAndFixTransform(self, node_path):
+ """验证并修复单个节点的变换矩阵"""
+ try:
+ node_name = node_path.getName()
+
+ # 获取当前变换状态
+ original_pos = node_path.getPos()
+ original_hpr = node_path.getHpr()
+ original_scale = node_path.getScale()
+
+ # 检查位置是否包含无效值
+ if not original_pos.isFinite():
+ print(f"警告: 节点 {node_name} 位置包含无效值 {original_pos}，重置为 (0,0,0)")
+ node_path.setPos(0, 0, 0)
+ return False
+
+ # 检查旋转是否包含无效值
+ if not original_hpr.isFinite():
+ print(f"警告: 节点 {node_name} 旋转包含无效值 {original_hpr}，重置为 (0,0,0)")
+ node_path.setHpr(0, 0, 0)
+ return False
+
+ # 检查缩放是否包含无效值或为零
+ if not original_scale.isFinite():
+ print(f"警告: 节点 {node_name} 缩放包含无效值 {original_scale}，重置为 (1,1,1)")
+ node_path.setScale(1, 1, 1)
+ return False
+
+ # 检查缩放是否为零或接近零
+ min_scale = 1e-10
+ if (abs(original_scale.x) < min_scale or
+ abs(original_scale.y) < min_scale or
+ abs(original_scale.z) < min_scale):
+ print(f"警告: 节点 {node_name} 缩放接近零 {original_scale}，重置为 (1,1,1)")
+ node_path.setScale(1, 1, 1)
+ return False
+
+ # 检查缩放是否过大（防止异常大的缩放）
+ max_scale = 1000000 # 100万倍作为上限
+ if (abs(original_scale.x) > max_scale or
+ abs(original_scale.y) > max_scale or
+ abs(original_scale.z) > max_scale):
+ print(f"警告: 节点 {node_name} 缩放过异常 {original_scale}，重置为 (1,1,1)")
+ node_path.setScale(1, 1, 1)
+ return False
+
+ return True
+
+ except Exception as e:
+ print(f"验证/修复节点 {node_path.getName()} 变换时出错: {e}")
+ # 只在出现严重错误时才重置变换
+ try:
+ node_path.setPos(0, 0, 0)
+ node_path.setHpr(0, 0, 0)
+ node_path.setScale(1, 1, 1)
+ except:
+ pass
+ return False
+
+ def _applyModelScale(self, model, scale_factor):
+ """应用模型特定缩放
+
+ Args:
+ model: 要缩放的模型
+ scale_factor: 缩放因子
+ """
+ try:
+ print(f"应用模型缩放因子: {scale_factor}")
+
+ # 获取当前边界用于后续位置调整
+ original_bounds = model.getBounds()
+
+ # 应用缩放
+ model.setScale(scale_factor)
+
+ # 重新调整位置（因为缩放会影响边界）
+ if original_bounds and not original_bounds.isEmpty():
+ new_bounds = model.getBounds()
+ min_point = new_bounds.getMin()
+ ground_offset = -min_point.getZ()
+ model.setZ(ground_offset)
+ print(f"缩放后重新调整位置: Z偏移 = {ground_offset}")
+
+ print(f"模型缩放完成，缩放因子: {scale_factor}")
+
+ except Exception as e:
+ print(f"应用模型缩放失败: {str(e)}")
+
def _applyMaterialsToModel(self, model):
"""递归应用材质到模型的所有GeomNode"""
def apply_material(node_path, depth=0):
indent = " " * depth
try:
- print(f"{indent}处理节点: {node_path.getName()}")
- print(f"{indent}节点类型: {node_path.node().__class__.__name__}")
+ #print(f"{indent}处理节点: {node_path.getName()}")
+ #print(f"{indent}节点类型: {node_path.node().__class__.__name__}")
if isinstance(node_path.node(), GeomNode):
- print(f"{indent}发现GeomNode，处理材质")
+ #print(f"{indent}发现GeomNode，处理材质")
geom_node = node_path.node()
# 检查所有几何体的状态
@@ -210,40 +409,23 @@ class SceneManager:
if node_state.hasAttrib(MaterialAttrib.getClassType()):
mat_attrib = node_state.getAttrib(MaterialAttrib.getClassType())
node_material = mat_attrib.getMaterial()
- if node_material and node_material.hasDiffuse():
- color = node_material.getDiffuse()
- has_color = True
- print(f"{indent}从节点材质获取颜色: {color}")
+ if node_material:
+ if node_material.hasBaseColor():
+ color = node_material.getBaseColor()
+ has_color = True
+ #print(f"{indent}从节点材质获取基础颜色: {color}")
+ elif node_material.hasDiffuse():
+ color = node_material.getDiffuse()
+ has_color = True
+ #print(f"{indent}从节点材质获取漫反射颜色: {color}")
- # 检查FBX特有的属性
- for tag_key in node_path.getTagKeys():
- print(f"{indent}发现标签: {tag_key}")
- if "color" in tag_key.lower() or "diffuse" in tag_key.lower():
- tag_value = node_path.getTag(tag_key)
- print(f"{indent}颜色相关标签: {tag_key} = {tag_value}")
-
- # 如果还没找到颜色，检查几何体
+ # 检查几何体材质
if not has_color:
for i in range(geom_node.getNumGeoms()):
try:
geom = geom_node.getGeom(i)
state = geom_node.getGeomState(i)
- # 检查顶点颜色
- vdata = geom.getVertexData()
- if vdata:
- format = vdata.getFormat()
- if format:
- for j in range(format.getNumColumns()):
- try:
- column = format.getColumn(j)
- # InternalName对象需要使用getName()转换为字符串
- column_name = column.getName().getName()
- if "color" in column_name.lower():
- print(f"{indent}发现顶点颜色数据: {column_name}")
- except Exception:
- continue
-
# 检查材质属性
if state.hasAttrib(MaterialAttrib.getClassType()):
mat_attrib = state.getAttrib(MaterialAttrib.getClassType())
@@ -252,12 +434,12 @@ class SceneManager:
if orig_material.hasBaseColor():
color = orig_material.getBaseColor()
has_color = True
- print(f"{indent}从基础颜色获取: {color}")
+ #print(f"{indent}从几何体材质获取基础颜色: {color}")
break
elif orig_material.hasDiffuse():
color = orig_material.getDiffuse()
has_color = True
- print(f"{indent}从漫反射颜色获取: {color}")
+ #print(f"{indent}从几何体材质获取漫反射颜色: {color}")
break
# 检查颜色属性
@@ -266,7 +448,7 @@ class SceneManager:
if not color_attrib.isOff():
color = color_attrib.getColor()
has_color = True
- print(f"{indent}从颜色属性获取: {color}")
+ #print(f"{indent}从颜色属性获取: {color}")
break
except Exception as geom_error:
print(f"{indent}处理几何体 {i} 时出错: {geom_error}")
@@ -274,17 +456,26 @@ class SceneManager:
# 创建新材质
material = Material()
- if has_color:
- print(f"{indent}应用找到的颜色: {color}")
+ if has_color and color:
+ #print(f"{indent}应用找到的颜色: {color}")
try:
- material.setDiffuse(color)
- material.setBaseColor(color) # 同时设置基础颜色
- node_path.setColor(color)
+ # 确保颜色值有效
+ if (color.getX() == color.getX() and color.getY() == color.getY() and
+ color.getZ() == color.getZ() and color.getW() == color.getW()):
+ material.setBaseColor(color)
+ material.setDiffuse(color)
+ node_path.setColor(color)
+ else:
+ print(f"{indent}⚠️ 颜色值无效，使用默认颜色")
+ material.setBaseColor((0.8, 0.8, 0.8, 1.0))
+ material.setDiffuse((0.8, 0.8, 0.8, 1.0))
except Exception as color_error:
print(f"{indent}设置颜色时出错: {color_error}")
+ material.setBaseColor((0.8, 0.8, 0.8, 1.0))
material.setDiffuse((0.8, 0.8, 0.8, 1.0))
else:
print(f"{indent}使用默认颜色")
+ material.setBaseColor((0.8, 0.8, 0.8, 1.0))
material.setDiffuse((0.8, 0.8, 0.8, 1.0))
# 设置其他材质属性
@@ -293,15 +484,20 @@ class SceneManager:
material.setShininess(32.0)
# 应用材质
- node_path.setMaterial(material)
- print(f"{indent}几何体数量: {geom_node.getNumGeoms()}")
+ try:
+ node_path.setMaterial(material, 1) # 1表示强制应用
+ #print(f"{indent}材质应用成功")
+ except Exception as mat_error:
+ print(f"{indent}⚠️ 应用材质时出错: {mat_error}")
+
+ #print(f"{indent}几何体数量: {geom_node.getNumGeoms()}")
except Exception as node_error:
print(f"{indent}处理节点 {node_path.getName()} 时出错: {node_error}")
# 递归处理子节点
child_count = node_path.getNumChildren()
- print(f"{indent}子节点数量: {child_count}")
+ #print(f"{indent}子节点数量: {child_count}")
for i in range(child_count):
try:
child = node_path.getChild(i)
@@ -311,7 +507,7 @@ class SceneManager:
continue
# 应用材质
- print("\n开始递归应用材质...")
+ #print("\n开始递归应用材质...")
try:
apply_material(model)
except Exception as e:
@@ -321,7 +517,7 @@ class SceneManager:
def _adjustModelToGround(self, model):
"""智能调整模型到地面，但保持原有缩放结构"""
try:
- print("调整模型位置到地面...")
+ #print("调整模型位置到地面...")
# 获取模型的边界框
bounds = model.getBounds()
@@ -341,9 +537,9 @@ class SceneManager:
# 设置模型位置：X,Y居中，Z调整到地面
model.setPos(0, 0, ground_offset)
- print(f"模型边界: 最小点{min_point}, 中心{center}")
- print(f"地面偏移: {ground_offset}")
- print(f"最终位置: {model.getPos()}")
+ #print(f"模型边界: 最小点{min_point}, 中心{center}")
+ #print(f"地面偏移: {ground_offset}")
+ #print(f"最终位置: {model.getPos()}")
except Exception as e:
print(f"调整模型位置失败: {str(e)}")
@@ -373,6 +569,18 @@ class SceneManager:
# 应用缩放
model.setScale(scale_factor)
+ # 应用缩放（添加异常处理）
+ try:
+ model.setScale(scale_factor)
+ except Exception as e:
+ print(f"直接设置缩放失败: {e}，尝试使用变换状态")
+ try:
+ model.setTransform(TransformState.makeScale(scale_factor))
+ except Exception as e2:
+ print(f"使用变换状态设置缩放也失败: {e2}")
+
+ # 应用缩放后验证变换
+ self._validateAndFixTransform(model)
# 重新调整位置（因为缩放会影响边界）
if original_bounds and not original_bounds.isEmpty():
new_bounds = model.getBounds()
@@ -531,59 +739,6 @@ class SceneManager:
except Exception as e:
print(f"异步加载模型失败: {str(e)}")
- def loadAnimatedModel(self, model_path, anims=None, auto_play=True):
- """加载带动画的模型
-
- Args:
- model_path: 模型文件路径
- anims: 动画字典，格式为 {"动画名": "动画文件路径"}
- auto_play: 是否自动播放第一个动画
- """
- try:
- print(f"🎬 加载动画模型: {model_path}")
-
- # 如果没有指定动画，尝试自动检测
- if anims is None:
- anims = self._detectAnimations(model_path)
-
- # 创建Actor对象
- actor = Actor(model_path, anims)
- if actor:
- actor.reparentTo(self.world.render)
-
- # 设置碰撞检测
- self.setupCollision(actor)
-
- # 获取可用的动画列表
- available_anims = actor.getAnimNames()
- print(f"📋 检测到动画: {available_anims}")
-
- # 自动播放第一个动画
- if auto_play and available_anims:
- first_anim = available_anims[0]
- actor.loop(first_anim)
- print(f"▶️ 自动播放动画: {first_anim}")
-
- # 添加动画控制标签
- actor.setTag("animated", "true")
- actor.setTag("current_anim", first_anim)
- actor.setTag("available_anims", str(available_anims))
-
- # 调整模型位置（让它站在地面上）
- self._adjustModelPosition(actor)
-
- self.models.append(actor)
- # 更新场景树
- self.updateSceneTree()
-
- print(f"✅ 动画模型加载完成: {actor.getName()}")
- return actor
- except Exception as e:
- print(f"❌ 加载动画模型失败: {str(e)}")
- import traceback
- traceback.print_exc()
- return None
-
# ==================== 材质和几何体处理 ====================
def processMaterials(self, model):
@@ -631,6 +786,7 @@ class SceneManager:
def setupCollision(self, model):
"""为模型设置碰撞检测（增强版本）"""
try:
+
# 创建碰撞节点
cNode = CollisionNode(f'modelCollision_{model.getName()}')
@@ -701,11 +857,233 @@ class SceneManager:
# ==================== 场景保存和加载 ====================
- def saveScene(self, filename):
- """保存场景到BAM文件"""
+ def _collectGUIElementInfo(self, gui_node):
+ """收集GUI元素的信息用于保存"""
+ try:
+ # 获取GUI元素类型
+ gui_type = "unknown"
+ if hasattr(gui_node, 'hasTag') and gui_node.hasTag("gui_type"):
+ gui_type = gui_node.getTag("gui_type")
+ elif hasattr(gui_node, 'hasTag') and gui_node.hasTag("saved_gui_type"):
+ gui_type = gui_node.getTag("saved_gui_type")
+ else:
+ # 尝试从节点名称推断类型
+ name_lower = gui_node.getName().lower()
+ if "button" in name_lower:
+ gui_type = "button"
+ elif "label" in name_lower:
+ gui_type = "label"
+ elif "entry" in name_lower:
+ gui_type = "entry"
+ elif "image" in name_lower:
+ gui_type = "2d_image"
+ elif "videoscreen" in name_lower:
+ if "2d" in name_lower:
+ gui_type = "2d_video_screen"
+ else:
+ gui_type = "video_screen"
+ elif "info_panel" in name_lower:
+ if "3d" in name_lower:
+ gui_type = "info_panel_3d"
+ else:
+ gui_type = "info_panel"
+ else:
+ # 如果无法识别类型，跳过该元素
+ print(f"跳过无法识别类型的GUI元素: {gui_node.getName()}")
+ return None
+
+ gui_info = {
+ "name": gui_node.getName(),
+ "type": gui_type,
+ "position": list(gui_node.getPos()),
+ "rotation": list(gui_node.getHpr()),
+ "scale": list(gui_node.getScale()),
+ "tags": {},
+ "parent_name":None
+ }
+
+ parent = gui_node.getParent()
+ if parent and not parent.isEmpty():
+ parent_name = parent.getName()
+ if parent_name not in ["render","aspect2d","render2d"]:
+ gui_info["parent_name"] = parent_name
+
+ # 收集所有标签（仅对NodePath类型的对象）
+ if hasattr(gui_node, 'getTagNames'):
+ for tag in gui_node.getTagNames():
+ gui_info["tags"][tag] = gui_node.getTag(tag)
+ elif hasattr(gui_node, 'getTags'): # 对于DirectGUI对象
+ # DirectGUI对象使用不同的方法存储标签
+ if hasattr(gui_node, '_tags'):
+ gui_info["tags"] = gui_node._tags.copy()
+
+ # 根据类型收集特定信息
+ if gui_type == "button":
+ if hasattr(gui_node, 'get'): # DirectButton
+ gui_info["text"] = gui_node.get()
+ elif hasattr(gui_node, 'getText'): # 其他类型
+ gui_info["text"] = gui_node.getText()
+ elif hasattr(gui_node, 'hasTag') and gui_node.hasTag("gui_text"):
+ gui_info["text"] = gui_node.getTag("gui_text")
+ elif gui_type == "label":
+ if hasattr(gui_node, 'getText'):
+ gui_info["text"] = gui_node.getText()
+ elif hasattr(gui_node, 'hasTag') and gui_node.hasTag("gui_text"):
+ gui_info["text"] = gui_node.getTag("gui_text")
+ elif gui_type == "entry":
+ if hasattr(gui_node, 'get'):
+ gui_info["text"] = gui_node.get()
+ elif hasattr(gui_node, 'hasTag') and gui_node.hasTag("gui_text"):
+ gui_info["text"] = gui_node.getTag("gui_text")
+ elif gui_type == "2d_image":
+ if hasattr(gui_node, 'hasTag') and gui_node.hasTag("image_path"):
+ gui_info["image_path"] = gui_node.getTag("image_path")
+ elif hasattr(gui_node, 'hasTag') and gui_node.hasTag("gui_image_path"):
+ gui_info["image_path"] = gui_node.getTag("gui_image_path")
+ elif gui_type == "3d_text":
+ if hasattr(gui_node,'hasTag') and gui_node.hasTag("gui_text"):
+ gui_info["text"] = gui_node.getTag("gui_text")
+ elif hasattr(gui_node,'node') and hasattr(gui_node.node(),'getText'):
+ gui_info["text"] = gui_node.node().getText()
+ elif gui_type == "3d_image":
+ if hasattr(gui_node,'hasTag') and gui_node.hasTag("gui_image_path"):
+ gui_info["image_path"] = gui_node.getTag("gui_image_path")
+ elif gui_type in ["video_screen", "2d_video_screen"]:
+ if hasattr(gui_node, 'hasTag') and gui_node.hasTag("video_path"):
+ gui_info["video_path"] = gui_node.getTag("video_path")
+ gui_info["video_path"] = gui_node.getTag("video_path")
+ elif gui_type == "virtual_screen":
+ if hasattr(gui_node, 'hasTag') and gui_node.hasTag("gui_text"):
+ gui_info["text"] = gui_node.getTag("gui_text")
+ elif gui_type in ["info_panel", "info_panel_3d"]:
+ # 收集信息面板的特定信息
+ if hasattr(gui_node, 'hasTag') and gui_node.hasTag("panel_id"):
+ gui_info["panel_id"] = gui_node.getTag("panel_id")
+
+ # 收集背景图片信息
+ if hasattr(gui_node, 'hasTag') and gui_node.hasTag("bg_image_path"):
+ gui_info["bg_image_path"] = gui_node.getTag("bg_image_path")
+
+ # 如果是信息面板，收集面板数据
+ if hasattr(gui_node, 'hasTag') and gui_node.hasTag("info_panel_data"):
+ gui_info["panel_data"] = gui_node.getTag("info_panel_data")
+
+ if hasattr(self.world, 'script_manager') and self.world.script_manager:
+ try:
+ script_manager = self.world.script_manager
+ scripts = script_manager.get_scripts_on_object(gui_node)
+ if scripts:
+ gui_info["scripts"] = []
+ for script_component in scripts:
+ try:
+ script_name = script_manager.script_name
+ #获取脚本路径
+ script_class = script_component.script_instance.__class__
+ script_file = self._get_script_file_path(script_class,script_name)
+ #只有当脚本文件存在时才保存
+ if script_file and os.path.exists(script_file):
+ gui_info["scirpts"].append({
+ "name":script_name,
+ "file":script_file
+ })
+ print(f"收集脚本信息{script_name}from {script_file}")
+ else:
+ print(f"警告: 脚本文件不存在: {script_file}")
+ except Exception as e:
+ print(f"收集单个脚本信息失败{script_name},错误{e}")
+ continue
+ except Exception as e:
+ print(f"收集脚本信息失败{e}")
+
+ print(f"成功收集GUI元素信息: {gui_info}")
+ return gui_info
+ except Exception as e:
+ print(f"收集GUI元素信息失败: {e}")
+ import traceback
+ traceback.print_exc()
+ return None
+
+ def _get_script_file_path(self, script_class, script_name):
+ """
+ 获取脚本文件路径的可靠方法
+ """
+ script_file = ""
+
+ # 方法1: 使用 inspect.getfile
+ try:
+ script_file = inspect.getfile(script_class)
+ if script_file and os.path.exists(script_file):
+ return script_file
+ except:
+ pass
+
+ # 方法2: 使用 __file__ 属性
+ try:
+ if hasattr(script_class, '__file__') and script_class.__file__:
+ script_file = script_class.__file__
+ if script_file and os.path.exists(script_file):
+ return script_file
+ except:
+ pass
+
+ # 方法3: 使用模块的 __file__ 属性
+ try:
+ module = inspect.getmodule(script_class)
+ if module and hasattr(module, '__file__') and module.__file__:
+ script_file = module.__file__
+ if script_file and os.path.exists(script_file):
+ return script_file
+ except:
+ pass
+
+ # 方法4: 从脚本管理器中查找
+ try:
+ if hasattr(self.world, 'script_manager') and self.world.script_manager:
+ script_manager = self.world.script_manager
+ # 查找脚本类对应的文件路径
+ for file_path, file_mtime in script_manager.loader.file_mtimes.items():
+ # 检查文件名是否匹配脚本名
+ file_name = os.path.splitext(os.path.basename(file_path))[0]
+ if file_name == script_name:
+ if os.path.exists(file_path):
+ return file_path
+ except:
+ pass
+
+ # 方法5: 在脚本目录中查找
+ try:
+ if hasattr(self.world, 'script_manager') and self.world.script_manager:
+ script_manager = self.world.script_manager
+ scripts_dir = script_manager.scripts_directory
+
+ # 查找匹配的脚本文件
+ if os.path.exists(scripts_dir):
+ for file_name in os.listdir(scripts_dir):
+ if file_name.endswith('.py'):
+ base_name = os.path.splitext(file_name)[0]
+ if base_name == script_name:
+ full_path = os.path.join(scripts_dir, file_name)
+ if os.path.exists(full_path):
+ return full_path
+ except:
+ pass
+
+ print(f"警告: 无法获取脚本 {script_name} 的文件路径")
+ return script_file
+
+ def saveScene(self, filename,project_path):
+ """保存场景到BAM文件 - 完整版，支持GUI元素,地形"""
try:
print(f"\n=== 开始保存场景到: {filename} ===")
+ # 确保文件路径是规范化的
+ filename = os.path.normpath(filename)
+
+ # 确保目录存在
+ directory = os.path.dirname(filename)
+ if directory and not os.path.exists(directory):
+ os.makedirs(directory)
+
# 存储需要临时隐藏的节点，以便保存后恢复
nodes_to_restore = []
@@ -727,19 +1105,91 @@ class SceneManager:
node.hide()
print(f"临时隐藏选择框节点: {node.getName()}")
- # 遍历所有模型,保存材质状态和变换信息
- for model in self.models:
- # 保存变换信息（关键！）
- model.setTag("transform_pos", str(model.getPos()))
- model.setTag("transform_hpr", str(model.getHpr()))
- model.setTag("transform_scale", str(model.getScale()))
- print(f"保存模型 {model.getName()} 的变换信息:")
- print(f" 位置: {model.getPos()}")
- print(f" 旋转: {model.getHpr()}")
- print(f" 缩放: {model.getScale()}")
+ # 收集所有需要保存的节点
+ all_nodes = []
+ all_nodes.extend(self.models)
+ all_nodes.extend(self.Spotlight)
+ all_nodes.extend(self.Pointlight)
+
+ # 添加GUI元素节点
+ gui_elements = []
+ if hasattr(self.world, 'gui_elements'):
+ # 过滤掉空的或重复的GUI元素
+ unique_gui_elements = []
+ seen_names = set()
+
+ for elem in self.world.gui_elements:
+ if elem and not elem.isEmpty():
+ if not elem.isEmpty() and elem.getName() not in seen_names:
+ unique_gui_elements.append(elem)
+ seen_names.add(elem.getName())
+ gui_elements = unique_gui_elements
+
+ print(f"保存时GUI元素列表=>>>>>>>>>>>>{self.world.gui_elements}")
+ all_nodes.extend(gui_elements)
+
+ # 创建用于保存GUI信息的JSON文件路径
+ gui_info_file = filename.replace('.bam', '_gui.json')
+
+ print(self.world.gui_elements)
+ # 收集GUI元素信息（排除3D文本和3D图像）
+ gui_data = []
+ for gui_node in gui_elements:
+ gui_info = self._collectGUIElementInfo(gui_node)
+ if gui_info:
+ gui_data.append(gui_info)
+ print(f"添加GUI信息{gui_info['name']}")
+
+ # 保存GUI信息到JSON文件（确保即使没有GUI元素也创建有效的空JSON数组）
+ try:
+ import json
+ with open(gui_info_file, 'w', encoding='utf-8') as f:
+ json.dump(gui_data, f, ensure_ascii=False, indent=2)
+ print(f"✓ GUI信息已保存到: {gui_info_file}")
+ except Exception as e:
+ print(f"✗ 保存GUI信息失败: {e}")
+ import traceback
+ traceback.print_exc()
+
+ # 添加tilesets节点
+ for tileset_info in self.tilesets:
+ if tileset_info.get('node') and not tileset_info['node'].isEmpty():
+ all_nodes.append(tileset_info['node'])
+
+ # 添加Cesium tilesets节点
+ for tileset_name, tileset_info in self.cesium_integration.tilesets.items():
+ if tileset_info.get('node') and not tileset_info['node'].isEmpty():
+ all_nodes.append(tileset_info['node'])
+
+ # 保存所有节点的信息
+ for node in all_nodes:
+ if node.isEmpty():
+ continue
+
+ # 保存变换信息
+ node.setTag("transform_pos", str(node.getPos()))
+ node.setTag("transform_hpr", str(node.getHpr()))
+ node.setTag("transform_scale", str(node.getScale()))
+ print(f"保存节点 {node.getName()} 的变换信息")
+
+ # 保存父子关系信息 - 关键修改
+ parent = node.getParent()
+ if parent and not parent.isEmpty() and parent != self.world.render:
+ # 只有当父节点不是根节点且父节点是场景中的模型时才保存父子关系
+ if parent.getName() not in ["render", "aspect2d", "render2d"]:
+ # 检查父节点是否也是场景中的模型
+ is_parent_model = False
+ for model in self.models:
+ if model == parent:
+ is_parent_model = True
+ break
+
+ if is_parent_model:
+ node.setTag("parent_name", parent.getName())
+ print(f"保存节点 {node.getName()} 的父节点信息: {parent.getName()}")
# 获取当前状态
- state = model.getState()
+ state = node.getState()
# 如果有材质属性,保存为标签
if state.hasAttrib(MaterialAttrib.getClassType()):
@@ -747,26 +1197,86 @@ class SceneManager:
material = mat_attrib.getMaterial()
if material:
# 保存材质属性到标签
- model.setTag("material_ambient", str(material.getAmbient()))
- model.setTag("material_diffuse", str(material.getDiffuse()))
- model.setTag("material_specular", str(material.getSpecular()))
- model.setTag("material_emission", str(material.getEmission()))
- model.setTag("material_shininess", str(material.getShininess()))
+ node.setTag("material_ambient", str(material.getAmbient()))
+ node.setTag("material_diffuse", str(material.getDiffuse()))
+ node.setTag("material_specular", str(material.getSpecular()))
+ node.setTag("material_emission", str(material.getEmission()))
+ node.setTag("material_shininess", str(material.getShininess()))
if material.hasBaseColor():
- model.setTag("material_basecolor", str(material.getBaseColor()))
+ node.setTag("material_basecolor", str(material.getBaseColor()))
- # 如果有颜色属性,保存为标签
- if state.hasAttrib(ColorAttrib.getClassType()):
- color_attrib = state.getAttrib(ColorAttrib.getClassType())
- if not color_attrib.isOff():
- model.setTag("color", str(color_attrib.getColor()))
+ # 保存特定类型节点的额外信息
+ if node.hasTag("light_type"):
+ # 保存光源特定信息
+ light_obj = node.getPythonTag("rp_light_object")
+ if light_obj:
+ node.setTag("light_energy", str(light_obj.energy))
+ node.setTag("light_radius", str(getattr(light_obj, 'radius', 0)))
+ if hasattr(light_obj, 'fov'):
+ node.setTag("light_fov", str(light_obj.fov))
+ elif node.hasTag("element_type"):
+ element_type = node.getTag("element_type")
+ if element_type == "cesium_tileset":
+ # 保存tileset特定信息
+ if node.hasTag("tileset_url"):
+ node.setTag("saved_tileset_url", node.getTag("tileset_url"))
+ elif node.hasTag("gui_type") or node.hasTag("is_gui_element"):
+ # 保存GUI元素特定信息
+ gui_type = node.getTag("gui_type") if node.hasTag("gui_type") else \
+ node.getTag("saved_gui_type") if node.hasTag("saved_gui_type") else "unknown"
+ node.setTag("saved_gui_type", gui_type)
+
+ # 保存GUI元素的通用属性
+ if hasattr(node, 'getPythonTag'):
+ # 保存任何Python标签数据
+ for tag_name in node.getPythonTagKeys():
+ try:
+ tag_value = node.getPythonTag(tag_name)
+ node.setTag(f"python_tag_{tag_name}", str(tag_value))
+ except:
+ pass
+ elif node.hasTag("element_type") and node.getTag("element_type") == "info_panel":
+ # 保存信息面板特定信息
+ print(f"保存信息面板信息: {node.getName()}")
+ panel_id = node.getTag("panel_id") if node.hasTag("panel_id") else node.getName()
+ if hasattr(self.world, 'info_panel_manager'):
+ panel_data = self.world.info_panel_manager.serializePanelData(panel_id)
+ if panel_data:
+ import json
+ node.setTag("info_panel_data", json.dumps(panel_data, ensure_ascii=False))
+
+ if hasattr(self.world,'script_manager') and self.world.script_manager:
+ script_manager = self.world.script_manager
+ scripts = script_manager.get_scripts_on_object(node)
+ if scripts:
+ node.setTag("has_scripts", "true")
+ script_info_list = []
+ for script_component in scripts:
+ script_name = script_component.script_name
+ print(f"保存脚本信息: {script_name}")
+
+ # 获取脚本类的文件路径
+ script_class = script_component.script_instance.__class__
+ script_file = self._get_script_file_path(script_class, script_name)
+
+ script_info_list.append({
+ "name": script_name,
+ "file": script_file
+ })
+
+ # 将脚本信息保存为JSON字符串
+ import json
+ node.setTag("scripts_info", json.dumps(script_info_list, ensure_ascii=False))
+ print(f"为节点 {node.getName()} 保存了 {len(script_info_list)} 个脚本")
try:
print("--- 打印当前场景图 (render) ---")
self.world.render.ls()
print("---------------------------------")
+
+ self.take_screenshot(project_path)
# 保存场景
- success = self.world.render.writeBamFile(filename)
+ success = self.world.render.writeBamFile(Filename.fromOsSpecific(filename))
if success:
print(f"✓ 场景保存成功: {filename}")
@@ -774,6 +1284,7 @@ class SceneManager:
print("✗ 场景保存失败")
return success
+
finally:
# 恢复之前隐藏的节点
for item in nodes_to_restore:
@@ -791,29 +1302,139 @@ class SceneManager:
traceback.print_exc()
return False
+ def take_screenshot(self, projectpath):
+ """
+ 截图并保存到指定的完整路径
+
+ Args:
+ full_path (str): 完整的文件保存路径，包括文件名和扩展名
+
+ Returns:
+ bool: 截图是否成功
+ """
+ try:
+ from panda3d.core import Filename
+ import os
+
+ print(f"\n=== 截图保存: {projectpath} ===")
+
+ # 确保目录存在
+ directory = os.path.dirname(projectpath)
+ if directory and not os.path.exists(directory):
+ os.makedirs(directory)
+ print(f"创建目录: {directory}")
+
+ # 规范化路径
+ filename = os.path.basename(os.path.normpath(projectpath))
+ filename = f'{filename}.png'
+ print(f'project_path: {projectpath}')
+ print(f'project_name: {filename}')
+ full_path = os.path.normpath(os.path.join(projectpath, filename))
+ p3d_filename = Filename.from_os_specific(full_path)
+ # 使用 Panda3D 的截图功能
+ success = self.world.win.saveScreenshot(p3d_filename)
+
+ if success:
+ print(f"✅ 成功截图并保存到: {full_path}")
+ return True
+ else:
+ print(f"❌ 截图保存失败: {full_path}")
+ return False
+
+ except Exception as e:
+ print(f"保存截图时发生错误: {str(e)}")
+ import traceback
+ traceback.print_exc()
+ return False
+
def loadScene(self, filename):
"""从BAM文件加载场景"""
try:
print(f"\n=== 开始加载场景: {filename} ===")
+ # 确保文件路径是规范化的
+ filename = os.path.normpath(filename)
+
+ # 检查文件是否存在
+ if not os.path.exists(filename):
+ print(f"场景文件不存在: {filename}")
+ return False
+
+ tree_widget = self._get_tree_widget()
# 清除当前场景
print("\n清除当前场景...")
for model in self.models:
- model.removeNode()
- self.models.clear()
+ tree_widget.delete_item(model)
- # 清理可能存在的辅助节点（坐标轴、选择框等）
+ # 清除灯光
+ for light_node in self.Spotlight:
+ tree_widget.delete_item(light_node)
+
+ for light_node in self.Pointlight:
+ tree_widget.delete_item(light_node)
+
+ for terrain in self.world.terrain_manager.terrains:
+ tree_widget.delete_item(terrain)
+
+ # 清除tilesets
+ for tileset_info in self.tilesets:
+ tree_widget.delete_item(tileset_info['node'])
+
+ for light in self.Spotlight:
+ if not light.isEmpty():
+ light.removeNode()
+ self.Spotlight.clear()
+
+ for light in self.Pointlight:
+ if not light.isEmpty():
+ light.removeNode()
+ self.Pointlight.clear()
+
+ # 清理tilesets
+ for tileset_info in self.tilesets:
+ if tileset_info['node'] and not tileset_info['node'].isEmpty():
+ tileset_info['node'].removeNode()
+ self.tilesets.clear()
+
+ # 清理Cesium tilesets
+ for tileset_name, tileset_info in list(self.cesium_integration.tilesets.items()):
+ if tileset_info['node'] and not tileset_info['node'].isEmpty():
+ tileset_info['node'].removeNode()
+ self.cesium_integration.tilesets.clear()
+
+ for gui in self.world.gui_elements:
+ if not gui.isEmpty():
+ gui.removeNode()
+ self.world.gui_elements.clear()
+
+ if hasattr(self.world,'info_panel_manager'):
+ self.world.info_panel_manager.removeAllPanels()
+
+ # 清理可能存在的辅助节点
self._cleanupAuxiliaryNodes()
# 加载场景
- scene = self.world.loader.loadModel(filename)
+ scene = self.world.loader.loadModel(Filename.fromOsSpecific(filename))
if not scene:
+ print("场景加载失败")
return False
+ tree_widget.create_model_items(scene)
# 遍历场景中的所有模型节点
+ # 用于存储处理后的灯光节点，避免重复处理
+ processed_lights = []
+ # 用于存储处理后的GUI元素，避免重复处理
+
+ #存储所有加载的节点，用于后续处理父子关系
+ loaded_nodes = {} #name->nodePath映射
+
+ # 遍历场景中的所有节点
def processNode(nodePath, depth=0):
indent = " " * depth
- print(f"{indent}处理节点: {nodePath.getName()}")
+ print(f"{indent}处理节点: {nodePath.getName()} (类型: {type(nodePath.node()).__name__})")
+
+ #存储节点以便后续处理父子关系
+ loaded_nodes[nodePath.getName()] = nodePath
# 跳过render节点的递归
if nodePath.getName() == "render" and depth > 0:
@@ -830,68 +1451,68 @@ class SceneManager:
print(f"{indent}跳过相机节点: {nodePath.getName()}")
return
- # 跳过辅助节点（坐标轴和选择框）
+ # 跳过辅助节点
if nodePath.getName().startswith(("gizmo", "selectionBox")):
print(f"{indent}跳过辅助节点: {nodePath.getName()}")
return
if nodePath.getName() in ['SceneRoot'] or \
- any(keyword in nodePath.getName() for keyword in ["Skybox","skybox"]):
+ any(keyword in nodePath.getName() for keyword in ["Skybox", "skybox"]):
print(f"{indent}跳过环境节点：{nodePath.getName()}")
return
- if isinstance(nodePath.node(), ModelRoot):
- print(f"{indent}找到模型根节点!")
+ # 检查是否是用户创建的场景元素
+ is_scene_element = (
+ nodePath.hasTag("is_scene_element") or
+ nodePath.hasTag("is_model_root") or
+ nodePath.hasTag("light_type") or
+ nodePath.hasTag("gui_type") or # 检查gui_type标签
+ nodePath.hasTag("is_gui_element") or
+ nodePath.hasTag("saved_gui_type") or
+ (nodePath.hasTag("element_type") and nodePath.getTag("element_type") == "info_panel")
+ )
+
+ # 特殊处理：检查节点名称是否包含GUI相关关键词
+ is_potential_gui = any(keyword in nodePath.getName().lower() for keyword in
+ ["gui", "button", "label", "entry", "image", "video", "screen", "text"])
+
+ if is_scene_element or is_potential_gui:
+ print(f"{indent}找到场景元素节点: {nodePath.getName()}")
+
+ # 如果是潜在的GUI元素但没有标签，添加基本标签
+ if is_potential_gui and not (nodePath.hasTag("gui_type") or nodePath.hasTag("is_gui_element")):
+ print(f"{indent}为潜在GUI元素添加标签: {nodePath.getName()}")
+ nodePath.setTag("is_gui_element", "1")
+ nodePath.setTag("is_scene_element", "1")
+ # 尝试从名称推断类型
+ name_lower = nodePath.getName().lower()
+ if "button" in name_lower:
+ nodePath.setTag("gui_type", "button")
+ elif "label" in name_lower:
+ nodePath.setTag("gui_type", "label")
+ elif "entry" in name_lower:
+ nodePath.setTag("gui_type", "entry")
+ elif "image" in name_lower:
+ nodePath.setTag("gui_type", "image")
+ elif "video" in name_lower or "screen" in name_lower:
+ nodePath.setTag("gui_type", "video_screen")
+ else:
+ nodePath.setTag("gui_type", "unknown")
# 清除现有材质状态
nodePath.clearMaterial()
nodePath.clearColor()
- # 创建新材质
- material = Material()
-
- # 从标签恢复材质属性
- def parseColor(color_str):
- """解析颜色字符串为Vec4"""
- try:
- # 移除LVecBase4f标记，只保留数值
- color_str = color_str.replace('LVecBase4f', '').strip('()')
- r, g, b, a = map(float, color_str.split(','))
- return Vec4(r, g, b, a)
- except:
- return Vec4(1, 1, 1, 1) # 默认白色
-
- if nodePath.hasTag("material_ambient"):
- material.setAmbient(parseColor(nodePath.getTag("material_ambient")))
- if nodePath.hasTag("material_diffuse"):
- material.setDiffuse(parseColor(nodePath.getTag("material_diffuse")))
- if nodePath.hasTag("material_specular"):
- material.setSpecular(parseColor(nodePath.getTag("material_specular")))
- if nodePath.hasTag("material_emission"):
- material.setEmission(parseColor(nodePath.getTag("material_emission")))
- if nodePath.hasTag("material_shininess"):
- material.setShininess(float(nodePath.getTag("material_shininess")))
- if nodePath.hasTag("material_basecolor"):
- material.setBaseColor(parseColor(nodePath.getTag("material_basecolor")))
-
- # 应用材质
- nodePath.setMaterial(material)
-
- # 恢复颜色属性
- if nodePath.hasTag("color"):
- nodePath.setColor(parseColor(nodePath.getTag("color")))
-
- # 恢复变换信息（关键！）
+ # 恢复变换信息
def parseVec3(vec_str):
"""解析向量字符串为Vec3"""
try:
- # 移除LVecBase3f标记，只保留数值
vec_str = vec_str.replace('LVecBase3f', '').replace('LPoint3f', '').strip('()')
x, y, z = map(float, vec_str.split(','))
return Vec3(x, y, z)
except Exception as e:
print(f"解析向量失败: {vec_str}, 错误: {e}")
- return Vec3(0, 0, 0) # 默认值
+ return Vec3(0, 0, 0)
if nodePath.hasTag("transform_pos"):
pos = parseVec3(nodePath.getTag("transform_pos"))
@@ -908,13 +1529,152 @@ class SceneManager:
nodePath.setScale(scale)
print(f"{indent}恢复缩放: {scale}")
- # 将模型重新挂载到render下
- nodePath.wrtReparentTo(self.world.render)
+ if nodePath.hasTag("has_scripts") and nodePath.getTag("has_scripts") == "true":
+ if hasattr(self.world,'script_manager') and self.world.script_manager:
+ try:
+ import json
+ scripts_info = json.loads(nodePath.getTag("scripts_info"))
+ print(f"节点 {nodePath.getName()} 需要重新挂载 {len(scripts_info)} 个脚本")
- # 为加载的模型设置碰撞检测
- self.setupCollision(nodePath)
+ script_manager = self.world.script_manager
+ for script_info in scripts_info:
+ script_name = script_info["name"]
+ script_file = script_info.get("file","")
- self.models.append(nodePath)
+ print(f"尝试重新挂载脚本{script_name}from {script_file}")
+
+ if script_name not in script_manager.loader.script_classes:
+ if script_file and os.path.exists(script_file):
+ print(f"从文件加载脚本：{script_file}")
+ loaded_class = script_manager.load_script_from_file(script_file)
+ if loaded_class is None:
+ print(f"从文件加载脚本失败{script_file}")
+ script_path = self._find_scrip_in_directory(script_name)
+ if script_path:
+ print(f"从目录找到脚本并加载{script_path}")
+ script_manager.load_script_from_file(script_path)
+ else:
+ script_path = self._find_script_in_directory(script_name)
+ if script_path:
+ print(f"从目录找到脚本并加载: {script_path}")
+ script_manager.load_script_from_file(script_path)
+ else:
+ print(f"找不到脚本文件: {script_name}")
+ if script_name in script_manager.loader.script_classes:
+ script_component = script_manager.add_script_to_object(nodePath,script_name)
+ if script_component:
+ print(f"成功为 {nodePath.getName()} 添加脚本: {script_name}")
+ else:
+ print(f"为 {nodePath.getName()} 添加脚本失败: {script_name}")
+ else:
+ print(f"脚本 {script_name} 不可用，跳过挂载")
+ except Exception as e:
+ print(f"重新挂载脚本失败: {e}")
+ import traceback
+ traceback.print_exc()
+
+
+ # 恢复材质属性
+ def parseColor(color_str):
+ """解析颜色字符串为Vec4"""
+ try:
+ color_str = color_str.replace('LVecBase4f', '').strip('()')
+ r, g, b, a = map(float, color_str.split(','))
+ return Vec4(r, g, b, a)
+ except:
+ return Vec4(1, 1, 1, 1)
+
+ # 创建并恢复材质
+ material = Material()
+ material_changed = False
+
+ if nodePath.hasTag("material_ambient"):
+ material.setAmbient(parseColor(nodePath.getTag("material_ambient")))
+ material_changed = True
+
+ if nodePath.hasTag("material_diffuse"):
+ material.setDiffuse(parseColor(nodePath.getTag("material_diffuse")))
+ material_changed = True
+
+ if nodePath.hasTag("material_specular"):
+ material.setSpecular(parseColor(nodePath.getTag("material_specular")))
+ material_changed = True
+
+ if nodePath.hasTag("material_emission"):
+ material.setEmission(parseColor(nodePath.getTag("material_emission")))
+ material_changed = True
+
+ if nodePath.hasTag("material_shininess"):
+ material.setShininess(float(nodePath.getTag("material_shininess")))
+ material_changed = True
+
+ if nodePath.hasTag("material_basecolor"):
+ material.setBaseColor(parseColor(nodePath.getTag("material_basecolor")))
+ material_changed = True
+
+ if material_changed:
+ nodePath.setMaterial(material)
+
+ # 恢复颜色属性
+ if nodePath.hasTag("color"):
+ nodePath.setColor(parseColor(nodePath.getTag("color")))
+
+ # 处理特定类型的节点
+ if nodePath.hasTag("light_type"):
+ light_type = nodePath.getTag("light_type")
+ print(f"{indent}检测到光源类型: {light_type}")
+
+ # 检查是否已经处理过这个灯光
+ if nodePath not in processed_lights:
+ # 重新创建RP光源对象
+ if light_type == "spot_light":
+ self._recreateSpotLight(nodePath)
+ elif light_type == "point_light":
+ self._recreatePointLight(nodePath)
+ # 标记为已处理
+ processed_lights.append(nodePath)
+
+ elif nodePath.hasTag("element_type"):
+ element_type = nodePath.getTag("element_type")
+ if element_type == "cesium_tileset":
+ tileset_url = nodePath.getTag("saved_tileset_url") if nodePath.hasTag(
+ "saved_tileset_url") else ""
+ tileset_info = {
+ 'url': tileset_url,
+ 'node': nodePath,
+ 'position': nodePath.getPos(),
+ 'tiles': {}
+ }
+ self.tilesets.append(tileset_info)
+ self.cesium_integration.tilesets[nodePath.getName()] = tileset_info
+
+ # 将节点重新挂载到render下（如果需要）
+ # 注意：GUI元素可能需要挂载到特定的父节点上
+ if nodePath.hasTag("gui_type") or nodePath.hasTag("is_gui_element"):
+ # GUI元素通常应该挂载到aspect2d或特定的GUI父节点上
+ # 这里我们先保持原挂载关系
+ pass
+ else:
+ # 其他节点确保挂载到render下
+ if nodePath.getParent() != self.world.render and not nodePath.getName() in ["render",
+ "aspect2d",
+ "render2d"]:
+ nodePath.wrtReparentTo(self.world.render)
+
+ # 为模型节点设置碰撞检测
+ if nodePath.hasTag("is_model_root"):
+ print(f"J{indent}处理模型节点{nodePath.getName()}")
+
+ #self._validateAndFixAllTransforms(nodePath)
+
+ self._fixModelStructure(nodePath)
+
+ # if self.world.property_panel._hasCollision(nodePath):
+ # print(f"{indent}模型{nodePath.getName()}已有碰撞体，跳过碰撞体设置")
+ # else:
+ # print(f"{indent}为模型{nodePath.getName()}设置碰撞检测")
+ # self.setupCollision(nodePath)
+ self.models.append(nodePath)
# 递归处理子节点
for child in nodePath.getChildren():
@@ -923,11 +1683,49 @@ class SceneManager:
print("\n开始处理场景节点...")
processNode(scene)
+ #处理父子关系 - 在所有节点加载完成后设置正确的父子关系
+ print("\n开始重建父子关系...")
+ self._rebuildParentChildRelationships(loaded_nodes)
+
+ # 加载GUI信息并重新创建非3D的GUI元素
+ gui_info_file = filename.replace('.bam', '_gui.json')
+ if os.path.exists(gui_info_file):
+ try:
+ with open(gui_info_file, 'r', encoding='utf-8') as f:
+ content = f.read().strip()
+ if content: # 检查文件是否为空
+ import json
+ gui_data = json.loads(content)
+ print(f"✓ 成功加载GUI信息文件: {gui_info_file}")
+ print(f" 发现 {len(gui_data)} 个GUI元素需要重建")
+
+ # 使用gui_manager重新创建GUI元素
+ self._recreateGUIElementsFromData(gui_data)
+ else:
+ print("ℹ️ GUI信息文件为空")
+ except json.JSONDecodeError as e:
+ print(f"✗ GUI信息文件格式错误: {e}")
+ except Exception as e:
+ print(f"✗ 加载GUI信息失败: {e}")
+ import traceback
+ traceback.print_exc()
+ else:
+ print("ℹ️ 未找到GUI信息文件")
+
# 移除临时场景节点
- scene.removeNode()
+ if not scene.isEmpty():
+ scene.removeNode()
# 更新场景树
- self.updateSceneTree()
+ #self.updateSceneTree()
+ #self._get_tree_widget().create_model_items(scene)
+
+ print(f"加载完成，GUI元素数量: {len(self.world.gui_elements)}")
+ if len(self.world.gui_elements) > 0:
+ print("GUI元素列表:")
+ for i, elem in enumerate(self.world.gui_elements):
+ print(
+ f" {i + 1}. {elem.getName()} (类型: {elem.getTag('gui_type') if elem.hasTag('gui_type') else 'unknown'})")
print("=== 场景加载完成 ===\n")
return True
@@ -938,6 +1736,632 @@ class SceneManager:
traceback.print_exc()
return False
+ def _rebuildParentChildRelationships(self, loaded_nodes):
+ try:
+ parent_child_relations = []
+ for node_name, node in loaded_nodes.items():
+ if node.hasTag("parent_name"):
+ parent_name = node.getTag("parent_name")
+ if parent_name in loaded_nodes:
+ parent_child_relations.append((node, loaded_nodes[parent_name])) # 修复：应该是元组
+ print(f"发现父子关系：{parent_name}->{node_name}")
+ else:
+ print(f"警告：节点{node_name}的父节点{parent_name}不存在")
+ for child_node, parent_node in parent_child_relations:
+ try:
+ child_node.wrtReparentTo(parent_node)
+ print(f"成功设置父子关系：{parent_node.getName()}->{child_node.getName()}")
+ except Exception as e:
+ print(f"设置父子关系失败{parent_node.getName()}->{child_node.getName()}:{e}")
+
+ if not parent_child_relations:
+ print("尝试从场景结构推断父子关系")
+ self._inferParentChildRelationships(loaded_nodes)
+
+ print("父子关系重建完成")
+ except Exception as e:
+ print(f"重建父子关系时出错: {e}")
+ import traceback
+ traceback.print_exc()
+
+
+ except Exception as e:
+ print(f"重建父子关系时出错: {e}")
+ import traceback
+ traceback.print_exc()
+
+ def _inferParentChildRelationships(self, loaded_nodes):
+ """从场景结构推断父子关系"""
+ try:
+ # 这里可以添加更复杂的父子关系推断逻辑
+ # 例如，根据节点名称、位置关系等进行推断
+ # 目前保持简单，后续可以扩展
+ print("父子关系推断完成（当前为空实现）")
+ except Exception as e:
+ print(f"推断父子关系时出错: {e}")
+
+ def _shouldSkipNodeInTree(self, nodePath):
+ """判断节点是否应该在场景树中跳过显示"""
+ # 跳过render节点的递归
+ if nodePath.getName() == "render":
+ return True
+
+ # 跳过光源节点
+ if nodePath.getName() in ["alight", "dlight"]:
+ return True
+
+ # 跳过相机节点
+ if nodePath.getName() in ["camera", "cam"]:
+ return True
+
+ # 跳过3D文本和3D图像节点
+ if (hasattr(nodePath.node(), "hasTag") and
+ nodePath.node().hasTag("gui_type") and
+ nodePath.node().getTag("gui_type") in ["3d_text", "3d_image"]):
+ return True
+
+ # 跳过辅助节点
+ if nodePath.getName().startswith(("gizmo", "selectionBox")):
+ return True
+
+ return False
+ def _recreateGUIElementsFromData(self, gui_data):
+ """根据保存的GUI数据重新创建GUI元素"""
+ try:
+ gui_manager = getattr(self.world, 'gui_manager', None)
+ property_manager = getattr(self.world, 'property_panel', None)
+ info_panel_manager = getattr(self.world,'info_panel_manager',None)
+ if not gui_manager:
+ print("GUI管理器未找到，无法重建GUI元素")
+ return
+ print(f"开始重建 {len(gui_data)} 个GUI元素...")
+
+ processed_names = set()
+ created_elements = {}
+ #存储原始的缩放和位置信息，用于后续计算
+ element_original_data = {}
+
+ # 第一遍：收集所有元素信息
+ for i, gui_info in enumerate(gui_data):
+ name = gui_info.get("name", f"gui_element_{i}")
+ element_original_data[name] = {
+ "scale": gui_info.get("scale", [1, 1, 1]),
+ "position": gui_info.get("position", [0, 0, 0]),
+ "parent_name": gui_info.get("parent_name")
+ }
+
+ valid_parents = set()
+ for gui_info in gui_data:
+ name = gui_info.get("name",f"gui_element_{gui_info.get('index',0)}")
+ valid_parents.add(name)
+
+ if hasattr(self.world,'gui_elements'):
+ for elem in self.world.gui_elements:
+ if elem and not elem.isEmpty():
+ valid_parents.add(elem.getName())
+
+ valid_parents.add("render")
+ valid_parents.add("aspect2d")
+ valid_parents.add("render2d")
+
+ pos = (0, 0, 0)
+ for i, gui_info in enumerate(gui_data):
+ try:
+ gui_type = gui_info.get("type", "unknown")
+ name = gui_info.get("name", f"gui_element_{i}")
+ position = gui_info.get("position", [0, 0, 0])
+ scale = gui_info.get("scale", [1, 1, 1])
+ tags = gui_info.get("tags", {})
+ text = gui_info.get("text", "")
+ image_path = gui_info.get("image_path", "")
+ video_path = gui_info.get("video_path", "")
+ bg_image_path = gui_info.get("bg_image_path", "") # 背景图片路径
+ panel_id = gui_info.get("panel_id", name) # 信息面板ID
+ panel_data = gui_info.get("panel_data", None) # 面板数据
+ parent_name = gui_info.get("parent_name")
+
+ # 检查是否已经处理过同名元素
+ if name in processed_names:
+ print(f"跳过重复元素: {name}")
+ continue
+
+ if parent_name and parent_name not in valid_parents:
+ print(f"⚠️ 跳过元素 {name}，因为其父级 {parent_name} 不存在")
+ continue
+
+ processed_names.add(name)
+
+ print(f"重建GUI元素: {name} (类型: {gui_type})")
+ print(f" 位置: {position}")
+ print(f" 缩放: {scale}")
+ print(f" 文本: {text}")
+ print(f" 图像路径: {image_path}")
+ print(f" 背景图片路径: {bg_image_path}")
+ print(f"视频路径：{video_path}")
+
+ absolute_position = list(position)
+ absolute_scale = list(scale)
+
+ if parent_name and parent_name in element_original_data:
+ parent_data = element_original_data[parent_name]
+ parent_scale = parent_data["scale"]
+
+ if gui_type in ["3d_text", "3d_image", "button", "label", "entry", "2d_image",
+ "2d_video_screen"]:
+ # 位置需要乘以父级缩放来得到绝对位置
+ for j in range(min(len(absolute_position), len(parent_scale))):
+ absolute_position[j] *= parent_scale[j] if len(parent_scale) > j else parent_scale[0]
+
+ # 缩放需要乘以父级缩放来得到绝对缩放
+ for j in range(min(len(absolute_scale), len(parent_scale))):
+ absolute_scale[j] *= parent_scale[j] if len(parent_scale) > j else parent_scale[0]
+
+ print(f" 绝对位置: {absolute_position}")
+ print(f" 绝对缩放: {absolute_scale}")
+
+ # 根据类型创建相应的GUI元素
+ new_element = None
+
+ if gui_type == "button" and hasattr(gui_manager, 'createGUIButton'):
+ new_element = gui_manager.createGUIButton(
+ pos=tuple(absolute_position),
+ text=text,
+ size=absolute_scale[0] if absolute_scale and len(absolute_scale) > 0 else 1.0
+ )
+ elif gui_type == "label" and hasattr(gui_manager, 'createGUILabel'):
+ scale_value = absolute_scale[0] if absolute_scale and len(absolute_scale) > 0 else 1.0
+ new_element = gui_manager.createGUILabel(
+ pos=tuple(absolute_position),
+ text=text,
+ size=scale_value
+ )
+ elif gui_type == "entry" and hasattr(gui_manager, 'createGUIEntry'):
+ new_element = gui_manager.createGUIEntry(
+ pos=tuple(absolute_position),
+ placeholder=text,
+ size=absolute_scale[0] if absolute_scale and len(absolute_scale) > 0 else 1.0
+ )
+ elif gui_type == "2d_image" and hasattr(gui_manager, 'createGUI2DImage'):
+ scale_value = absolute_scale[0] if absolute_scale and len(absolute_scale) > 0 else 0.2
+ new_element = gui_manager.createGUI2DImage(
+ pos=tuple(absolute_position),
+ image_path=image_path,
+ size=scale_value*0.2
+ )
+ elif gui_type == "3d_text" and hasattr(gui_manager,'createGUI3DText'):
+ size = absolute_scale[0] if absolute_scale and len(absolute_scale) > 0 else 0.5
+ new_element = gui_manager.createGUI3DText(
+ pos=tuple(absolute_position),
+ text=text,
+ size=size
+ )
+ elif gui_type == "3d_image" and hasattr(gui_manager, 'createGUI3DImage'):
+ # 处理3D图像
+ # 根据缩放值的数量处理尺寸
+ if len(absolute_scale) >= 3:
+ size = (absolute_scale[0] * 2, absolute_scale[1] * 2)
+ elif len(absolute_scale) >= 2:
+ size = (absolute_scale[0] * 2, absolute_scale[1] * 2)
+ elif len(scale) >= 1:
+ size = (absolute_scale[0] * 2, absolute_scale[0] * 2)
+ else:
+ size = (1.0, 1.0)
+
+ new_element = gui_manager.createGUI3DImage(
+ pos=tuple(absolute_position),
+ image_path=image_path,
+ size=size
+ )
+ elif gui_type == "video_screen" and hasattr(gui_manager,'createVideoScreen'):
+ new_element = gui_manager.createVideoScreen(
+ pos=tuple(absolute_position),
+ size=absolute_scale,
+ video_path=video_path
+ )
+ if video_path and new_element:
+ if video_path.startswith("http://") or video_path.startswith("https://"):
+ from direct.task.TaskManagerGlobal import taskMgr
+ def load_video_stream_task(task):
+ if hasattr(property_manager,'_loadVideoFromURLWithOpenCV_3D'):
+ property_manager._loadVideoFromURLWithOpenCV_3D(new_element,video_path)
+ return task.done
+
+ taskMgr.doMethodLater(0.5, load_video_stream_task, 'loadVideoStreamTask')
+ else:
+ if hasattr(gui_manager,'loadVideoFile'):
+ from direct.task.TaskManagerGlobal import taskMgr
+ def load_video_file_task(task):
+ gui_manager.loadVideoFile(new_element,video_path)
+ return task.done
+ taskMgr.doMethodLater(0.1,load_video_file_task,'loadVideoFileTask')
+
+ # if video_path and new_element and hasattr(gui_manager, 'loadVideoFile'):
+ # # 延迟一帧执行，确保节点完全初始化
+ # from direct.task.TaskManagerGlobal import taskMgr
+ # def load_video_task(task):
+ # gui_manager.loadVideoFile(new_element, video_path)
+ # return task.done
+ #
+ # taskMgr.doMethodLater(0.1, load_video_task, 'loadVideoTask')
+
+ elif gui_type == "2d_video_screen" and hasattr(gui_manager,'createGUI2DVideoScreen'):
+ new_element = gui_manager.createGUI2DVideoScreen(
+ pos=tuple(absolute_position),
+ size=absolute_scale,
+ video_path=video_path
+ )
+ if video_path and new_element:
+ if video_path.startswith("http://") or video_path.startswith("https://"):
+ pass
+ # from direct.task.TaskManagerGlobal import taskMgr
+ # def load_2d_video_stream_task(task):
+ # if hasattr(property_manager,'_loadVideoFromURLWithOpenCV'):
+ # property_manager._loadVideoFromURLWithOpenCV(new_element,video_path)
+ # return task.done
+ # taskMgr.doMethodLater(0.1,load_2d_video_stream_task,'load2DVideoStreamTask')
+ else:
+ if hasattr(property_manager,'load2DVideoFile'):
+ from direct.task.TaskManagerGlobal import taskMgr
+ def load_2d_video_file_task(task):
+ property_manager.load2DVideoFile(new_element,video_path)
+ return task.done
+ taskMgr.doMethodLater(0.1,load_2d_video_file_task,'load2DVideoFileTask')
+
+
+ # 如果创建成功，设置属性
+ if new_element:
+ # 如果返回的是列表（多选创建），取第一个
+ if isinstance(new_element, list):
+ new_element = new_element[0]
+
+ # 设置名称
+ new_element.setName(name)
+
+ # 设置变换
+ new_element.setPos(*position)
+
+ if len(scale) >= 3:
+ new_element.setScale(scale[0], scale[1], scale[2])
+ elif len(scale) >= 1:
+ new_element.setScale(scale[0])
+
+ # 设置标签
+ # 对于NodePath对象
+ if hasattr(new_element, 'setTag'):
+ for tag_name, tag_value in tags.items():
+ # 跳过变换标签，因为我们已经设置了
+ if tag_name not in ["transform_pos", "transform_hpr", "transform_scale"]:
+ new_element.setTag(tag_name, tag_value)
+ # 对于DirectGUI对象，使用自定义标签存储
+ elif hasattr(new_element, '_tags'):
+ new_element._tags.update(tags)
+
+ created_elements[name] = new_element
+
+ print(f"GUI元素重建成功: {name}")
+ else:
+ print(f"无法重建GUI元素: {name} (类型: {gui_type})")
+
+ except Exception as e:
+ print(f"重建GUI元素失败 {name}: {e}")
+ import traceback
+ traceback.print_exc()
+ continue
+
+ # 第二遍：设置父子级关系并更新Qt树
+ print("开始设置父子级关系...")
+ try:
+ # 创建父子级关系映射
+ parent_child_map = {}
+ for gui_info in gui_data:
+ name = gui_info.get("name")
+ parent_name = gui_info.get("parent_name")
+
+ if name and parent_name and parent_name in created_elements:
+ parent_child_map[name] = parent_name
+ print(f"父子级关系映射: {parent_name} -> {name}")
+
+ # 按正确的顺序设置父子级关系并更新Qt树
+ tree_widget = self._get_tree_widget()
+ if tree_widget:
+ # 先将所有元素添加到Qt树中
+ qt_tree_items = {}
+ for name, element in created_elements.items():
+ # 尝试在Qt树中找到对应的项，如果找不到则创建
+ qt_item = self._findOrCreateQtTreeItem(tree_widget, element, name)
+ if qt_item:
+ qt_tree_items[name] = qt_item
+
+ # 然后设置父子级关系
+ for child_name, parent_name in parent_child_map.items():
+ try:
+ if child_name in created_elements and parent_name in created_elements:
+ child_element = created_elements[child_name]
+ parent_element = created_elements[parent_name]
+
+ # 设置父子级关系
+ if hasattr(child_element, 'reparentTo'):
+ child_element.reparentTo(parent_element)
+ print(f"成功设置父子级关系: {parent_name} -> {child_name}")
+
+ # 更新Qt树显示
+ if child_name in qt_tree_items and parent_name in qt_tree_items:
+ child_item = qt_tree_items[child_name]
+ parent_item = qt_tree_items[parent_name]
+
+ # 从当前位置移除子项
+ if child_item.parent():
+ child_item.parent().removeChild(child_item)
+ else:
+ # 如果是顶级项，从树中移除
+ index = tree_widget.indexOfTopLevelItem(child_item)
+ if index >= 0:
+ tree_widget.takeTopLevelItem(index)
+
+ # 将子项添加到新的父项下
+ parent_item.addChild(child_item)
+ print(f"Qt树更新: {child_name} 移动到 {parent_name} 下")
+ else:
+ print(f"元素 {child_name} 不支持 reparentTo 操作")
+ else:
+ print(f"元素未找到: 父级={parent_name}, 子级={child_name}")
+ except Exception as e:
+ print(f"设置父子级关系失败 {parent_name} -> {child_name}: {e}")
+ continue
+ else:
+ # 如果没有tree_widget，只设置父子级关系
+ for child_name, parent_name in parent_child_map.items():
+ try:
+ if child_name in created_elements and parent_name in created_elements:
+ child_element = created_elements[child_name]
+ parent_element = created_elements[parent_name]
+
+ # 设置父子级关系
+ if hasattr(child_element, 'reparentTo'):
+ child_element.reparentTo(parent_element)
+ print(f"成功设置父子级关系: {parent_name} -> {child_name}")
+ except Exception as e:
+ print(f"设置父子级关系失败 {parent_name} -> {child_name}: {e}")
+ continue
+
+ except Exception as e:
+ print(f"设置父子级关系时出错: {e}")
+ # 第三遍：重新挂载脚本
+ print("开始重新挂载脚本...")
+ for gui_info in gui_data:
+ try:
+ name = gui_info.get("name")
+ if name in created_elements and "scripts" in gui_info:
+ new_element = created_elements[name]
+
+ # 重新挂载脚本（如果有的话）
+ if "scripts" in gui_info and hasattr(self.world,
+ 'script_manager') and self.world.script_manager:
+ script_manager = self.world.script_manager
+ for script_info in gui_info["scripts"]:
+ script_name = script_info["name"]
+ script_file = script_info.get("file", "")
+
+ print(f"尝试重新挂载脚本: {script_name} from {script_file}")
+
+ # 检查脚本是否已加载
+ if script_name not in script_manager.loader.script_classes:
+ # 如果脚本未加载，尝试从保存的文件路径加载
+ if script_file and os.path.exists(script_file):
+ print(f"从文件加载脚本: {script_file}")
+ loaded_class = script_manager.load_script_from_file(script_file)
+ if loaded_class is None:
+ print(f"从文件加载脚本失败: {script_file}")
+ # 如果从文件加载失败，尝试在脚本目录中查找
+ script_path = self._find_script_in_directory(script_name)
+ if script_path:
+ print(f"从目录找到脚本并加载: {script_path}")
+ script_manager.load_script_from_file(script_path)
+ else:
+ # 如果没有文件路径或文件不存在，尝试在脚本目录中查找
+ script_path = self._find_script_in_directory(script_name)
+ if script_path:
+ print(f"从目录找到脚本并加载: {script_path}")
+ script_manager.load_script_from_file(script_path)
+ else:
+ print(f"找不到脚本文件: {script_name}")
+
+ # 为元素添加脚本
+ script_component = script_manager.add_script_to_object(new_element, script_name)
+ if script_component:
+ print(f"成功为 {name} 添加脚本: {script_name}")
+ else:
+ print(f"为 {name} 添加脚本失败: {script_name}")
+ except Exception as e:
+ print(f"重新挂载脚本失败 {gui_info.get('name', 'unknown')}: {e}")
+ continue
+
+ print("GUI元素重建完成")
+
+ except Exception as e:
+ print(f"重建GUI元素时发生错误: {e}")
+ import traceback
+ traceback.print_exc()
+
+ def _findOrCreateQtTreeItem(self, tree_widget, target_element, element_name):
+ """在Qt树中查找或创建指定元素对应的项"""
+ try:
+ # 首先尝试查找现有的项
+ existing_item = self._findQtTreeItem(tree_widget, target_element)
+ if existing_item:
+ return existing_item
+
+ # 如果找不到，创建新的项
+ # 找到场景根节点
+ scene_root = None
+ for i in range(tree_widget.topLevelItemCount()):
+ top_item = tree_widget.topLevelItem(i)
+ if top_item.data(0, Qt.UserRole + 1) == "SCENE_ROOT":
+ scene_root = top_item
+ break
+
+ if not scene_root:
+ print("无法找到场景根节点")
+ return None
+
+ # 创建新的Qt树项
+ new_item = QTreeWidgetItem(scene_root, [element_name])
+ new_item.setData(0, Qt.UserRole, target_element)
+ new_item.setData(0, Qt.UserRole + 1, "SCENE_NODE") # 或根据元素类型设置适当的类型
+
+ print(f"为元素 {element_name} 创建了新的Qt树项")
+ return new_item
+
+ except Exception as e:
+ print(f"查找或创建Qt树项失败: {e}")
+ return None
+
+ def _findQtTreeItem(self, tree_widget, target_element):
+ """在Qt树中查找指定元素对应的项"""
+ try:
+ def search_recursive(parent_item):
+ # 检查当前项
+ if parent_item:
+ item_element = parent_item.data(0, Qt.UserRole)
+ if item_element == target_element:
+ return parent_item
+
+ # 递归检查子项
+ for i in range(parent_item.childCount()):
+ child_item = parent_item.child(i)
+ result = search_recursive(child_item)
+ if result:
+ return result
+ return None
+
+ # 从根节点开始搜索
+ root = tree_widget.invisibleRootItem()
+ for i in range(root.childCount()):
+ top_item = root.child(i)
+ result = search_recursive(top_item)
+ if result:
+ return result
+
+ return None
+ except Exception as e:
+ print(f"查找Qt树项失败: {e}")
+ return None
+ def _find_script_in_directory(self, script_name):
+ """在脚本目录中查找脚本文件"""
+ try:
+ if hasattr(self.world, 'script_manager') and self.world.script_manager:
+ script_manager = self.world.script_manager
+ scripts_dir = script_manager.scripts_directory
+
+ if os.path.exists(scripts_dir):
+ # 首先精确匹配
+ for file_name in os.listdir(scripts_dir):
+ if file_name.endswith('.py'):
+ base_name = os.path.splitext(file_name)[0]
+ if base_name == script_name:
+ return os.path.join(scripts_dir, file_name)
+
+ # 如果没有精确匹配，尝试模糊匹配
+ for file_name in os.listdir(scripts_dir):
+ if file_name.endswith('.py'):
+ base_name = os.path.splitext(file_name)[0]
+ if script_name.lower() in base_name.lower() or base_name.lower() in script_name.lower():
+ return os.path.join(scripts_dir, file_name)
+ except Exception as e:
+ print(f"查找脚本文件时出错: {e}")
+
+ return None
+
+ def _recreateSpotLight(self, light_node):
+ """重新创建聚光灯"""
+ try:
+ from RenderPipelineFile.rpcore import SpotLight
+ from QPanda3D.Panda3DWorld import get_render_pipeline
+ from panda3d.core import Vec3
+
+ # 创建聚光灯对象
+ light = SpotLight()
+ light.direction = Vec3(0, 0, -1)
+ light.fov = 70
+ light.set_color_from_temperature(5 * 1000.0)
+
+ # 恢复保存的属性
+ if light_node.hasTag("light_energy"):
+ light.energy = float(light_node.getTag("light_energy"))
+ else:
+ light.energy = 5000
+
+ light.radius = 1000
+ light.casts_shadows = True
+ light.shadow_map_resolution = 256
+
+ light_pos = light_node.getPos()
+ light.setPos(light_pos)
+
+ # 添加到渲染管线
+ render_pipeline = get_render_pipeline()
+ render_pipeline.add_light(light)
+
+ # 保存光源对象引用
+ light_node.setPythonTag("rp_light_object", light)
+
+ # 添加到管理列表
+ self.Spotlight.append(light_node)
+
+ # 确保灯光节点有正确的标签，以便在场景树更新时被识别
+ if not light_node.hasTag("is_scene_element"):
+ light_node.setTag("is_scene_element", "1")
+
+ print(f"重新创建聚光灯: {light_node.getName()}")
+ except Exception as e:
+ print(f"重新创建聚光灯失败: {str(e)}")
+ import traceback
+ traceback.print_exc()
+
+ def _recreatePointLight(self, light_node):
+ """重新创建点光源"""
+ try:
+ from RenderPipelineFile.rpcore import PointLight
+ from QPanda3D.Panda3DWorld import get_render_pipeline
+
+ # 创建点光源对象
+ light = PointLight()
+
+ # 恢复保存的属性
+ if light_node.hasTag("light_energy"):
+ light.energy = float(light_node.getTag("light_energy"))
+ else:
+ light.energy = 5000
+
+ light.radius = 1000
+ light.inner_radius = 0.4
+ light.set_color_from_temperature(5 * 1000.0)
+ light.casts_shadows = True
+ light.shadow_map_resolution = 256
+
+ # 设置位置
+ light.setPos(light_node.getPos())
+
+ # 添加到渲染管线
+ render_pipeline = get_render_pipeline()
+ render_pipeline.add_light(light)
+
+ # 保存光源对象引用
+ light_node.setPythonTag("rp_light_object", light)
+
+ # 添加到管理列表
+ self.Pointlight.append(light_node)
+
+ # 确保灯光节点有正确的标签，以便在场景树更新时被识别
+ if not light_node.hasTag("is_scene_element"):
+ light_node.setTag("is_scene_element", "1")
+
+ print(f"重新创建点光源: {light_node.getName()}")
+ except Exception as e:
+ print(f"重新创建点光源失败: {str(e)}")
+ import traceback
+ traceback.print_exc()
+
def _cleanupAuxiliaryNodes(self):
"""清理场景中可能存在的辅助节点"""
try:
@@ -970,9 +2394,14 @@ class SceneManager:
"""删除模型"""
try:
if model in self.models:
- model.removeNode()
- self.models.remove(model)
- self.updateSceneTree()
+ tree_widget = self._get_tree_widget()
+ if not tree_widget:
+ return False
+
+ tree_widget.delete_items(tree_widget.selectedItems())
+ # model.removeNode()
+ # self.models.remove(model)
+ # self.updateSceneTree()
print(f"删除模型: {model.getName()}")
return True
except Exception as e:
@@ -981,14 +2410,15 @@ class SceneManager:
def clearAllModels(self):
"""清除所有模型"""
- try:
- for model in self.models:
- model.removeNode()
- self.models.clear()
- self.updateSceneTree()
- print("清除所有模型完成")
- except Exception as e:
- print(f"清除所有模型失败: {str(e)}")
+ pass
+ # try:
+ # for model in self.models:
+ # model.removeNode()
+ # self.models.clear()
+ # self.updateSceneTree()
+ # print("清除所有模型完成")
+ # except Exception as e:
+ # print(f"清除所有模型失败: {str(e)}")
def getModels(self):
"""获取模型列表"""
@@ -1065,6 +2495,8 @@ class SceneManager:
light_np.reparentTo(parent_node) # 挂载到父节点而不是render
light_np.setPos(*pos)
+ light_np.setTransform(TransformState.makeIdentity())
+
# 创建聚光灯对象
light = SpotLight()
light.direction = Vec3(0, 0, -1)
@@ -1074,7 +2506,6 @@ class SceneManager:
light.radius = 1000
light.casts_shadows = True
light.shadow_map_resolution = 256
- light.setPos(*pos)
# 添加到渲染管线
render_pipeline.add_light(light)
@@ -1082,6 +2513,7 @@ class SceneManager:
# 设置节点属性和标签
light_np.setTag("light_type", "spot_light")
light_np.setTag("is_scene_element", "1")
+ light_np.setTag("tree_item_type", "LIGHT_NODE")
light_np.setTag("light_energy", str(light.energy))
light_np.setTag("created_by_user", "1")
@@ -1170,11 +2602,12 @@ class SceneManager:
light_np.reparentTo(parent_node) # 挂载到父节点而不是render
light_np.setPos(*pos)
+ # 确保变换矩阵有效
+ light_np.setTransform(TransformState.makeIdentity())
+
# 创建点光源对象
light = PointLight()
-
light.setPos(*pos)
-
light.energy = 5000
light.radius = 1000
light.inner_radius = 0.4
@@ -1188,6 +2621,7 @@ class SceneManager:
# 设置节点属性和标签
light_np.setTag("light_type", "point_light")
light_np.setTag("is_scene_element", "1")
+ light_np.setTag("tree_item_type", "LIGHT_NODE")
light_np.setTag("light_energy", str(light.energy))
light_np.setTag("created_by_user", "1")
@@ -1248,92 +2682,6 @@ class SceneManager:
pass
return None
- def _importModelSingle(self, filepath, apply_unit_conversion=False, normalize_scales=True, auto_convert_to_glb=True):
- """传统单一模型导入方法（兼容性保留）"""
- try:
- print(f"\n=== 使用传统模式导入模型: {filepath} ===")
-
- filepath = util.normalize_model_path(filepath)
- original_filepath = filepath
-
- # 检查是否需要转换为GLB
- if auto_convert_to_glb and self._shouldConvertToGLB(filepath):
- print(f"🔄 检测到需要转换的格式，尝试转换为GLB...")
- converted_path = self._convertToGLBWithProgress(filepath)
- if converted_path:
- print(f"✅ 转换成功: {converted_path}")
- filepath = converted_path
- try:
- from PyQt5.QtWidgets import QMessageBox
- original_ext = os.path.splitext(original_filepath)[1].upper()
- QMessageBox.information(None, "转换成功",
- f"已将 {original_ext} 格式自动转换为 GLB 格式\n以获得更好的动画支持！")
- except:
- pass
- else:
- print(f"⚠️ 转换失败，使用原始文件")
-
- # 加载模型
- print("直接从文件加载模型...")
- model = self.world.loader.loadModel(filepath)
- if not model:
- print("加载模型失败")
- return None
-
- # 设置模型名称
- model_name = os.path.basename(filepath)
- model.setName(model_name)
-
- # 将模型添加到场景
- model.reparentTo(self.world.render)
-
- # 设置标签和路径信息
- model.setTag("model_path", filepath)
- model.setTag("original_path", original_filepath)
- model.setTag("file", model_name)
- model.setTag("is_model_root", "1")
- model.setTag("is_scene_element", "1")
- model.setTag("created_by_user", "1")
-
- if filepath != original_filepath:
- model.setTag("converted_from", os.path.splitext(original_filepath)[1])
- model.setTag("converted_to_glb", "true")
-
- # 应用处理选项
- if apply_unit_conversion and filepath.lower().endswith('.fbx'):
- print("应用FBX单位转换（厘米到米）...")
- self._applyUnitConversion(model, 0.01)
- model.setTag("unit_conversion_applied", "true")
-
- if normalize_scales and filepath.lower().endswith('.fbx'):
- print("标准化FBX模型缩放层级...")
- self._normalizeModelScales(model)
- model.setTag("scale_normalization_applied", "true")
-
- # 调整模型位置到地面
- self._adjustModelToGround(model)
-
- # 创建并设置基础材质
- print("\n=== 开始设置材质 ===")
- self._applyMaterialsToModel(model)
-
- # 设置碰撞检测（重要！用于选择功能）
- print("\n=== 设置碰撞检测 ===")
- self.setupCollision(model)
-
- # 添加到模型列表
- self.models.append(model)
-
- # 更新场景树
- self.updateSceneTree()
-
- print(f"=== 模型导入成功: {model_name} ===\n")
- return model
-
- except Exception as e:
- print(f"导入模型失败: {str(e)}")
- return None
-
# def createSpotLight(self, pos=(0, 0, 0)):
# """创建聚光灯 - 使用统一的create_item方法"""
# try:
@@ -1770,43 +3118,96 @@ except Exception as e:
return False
def load_cesium_tileset(self, tileset_url, position=(0, 0, 0)):
+ """
+ 加载 Cesium 3D Tileset - 采用新的创建逻辑，支持多选和更完善的UI交互。
+ """
try:
- print(f"加载 Cesium 3D Tiles: {tileset_url}")
+ from panda3d.core import NodePath
+ print(f"🗺️ 开始加载 Cesium 3D Tiles: {tileset_url}")
- # 创建一个容器节点来管理tileset
- node_name = f"cesium_tileset_{len(self.tilesets)}"
- tileset_node = self.world.render.attachNewNode(node_name)
- tileset_node.setPos(*position)
+ # 1. 获取UI控件和目标父节点
+ tree_widget = self._get_tree_widget()
+ if not tree_widget:
+ print("❌ 无法访问树形控件")
+ return None
- #添加标签以便场景树识别
- tileset_node.setTag("is_scene_element","1")
- tileset_node.setTag("element_type","cesium_tileset")
- tileset_node.setTag("tileset_url",tileset_url)
- tileset_node.setTag("file",f"tileset_{len(self.tilesets)}")
+ target_parents = tree_widget.get_target_parents_for_creation()
+ if not target_parents:
+ print("❌ 没有找到有效的父节点来附加Tileset")
+ return None
- # 存储tileset信息
- tileset_info = {
- 'url': tileset_url,
- 'node': tileset_node,
- 'position': position,
- 'tiles': {}
- }
+ created_tilesets = []
- self.tilesets.append(tileset_info)
+ # 2. 遍历所有选中的父节点，并为其创建Tileset
+ for parent_item, parent_node in target_parents:
+ try:
+ # 生成唯一名称
+ node_name = f"cesium_tileset_{len(self.tilesets)}"
- # 创建一个临时的可视化占位符，让用户能看到节点已添加
- self._create_placeholder_geometry(tileset_node)
+ # 创建一个容器节点来管理tileset，并挂载到父节点
+ tileset_node = parent_node.attachNewNode(node_name)
+ tileset_node.setPos(*position)
- # 异步加载tileset数据
- self._load_tileset_async(tileset_url, tileset_info)
+ # 添加标签以便场景识别和保存
+ tileset_node.setTag("is_scene_element", "1")
+ tileset_node.setTag("tree_item_type", "CESIUM_TILESET_NODE")
+ tileset_node.setTag("element_type", "cesium_tileset")
+ tileset_node.setTag("tileset_url", tileset_url)
+ # 使用唯一名称作为文件标识，代替索引
+ tileset_node.setTag("file", node_name)
- # 更新场景树
- self.updateSceneTree()
- print(f"✓ Cesium 3D Tiles 加载请求已发送")
- return tileset_node
+ # 存储tileset核心信息
+ tileset_info = {
+ 'url': tileset_url,
+ 'node': tileset_node,
+ 'position': position,
+ 'tiles': {} # 用于后续管理瓦片
+ }
+ self.tilesets.append(tileset_info)
+
+ # 创建一个临时的可视化占位符，让用户能看到节点已添加
+ self._create_placeholder_geometry(tileset_node)
+
+ # 异步加载tileset的实际数据
+ self._load_tileset_async(tileset_url, tileset_info)
+
+ print(f"✅ 为 {parent_item.text(0)} 加载 Tileset 成功: {node_name}")
+
+ # 在Qt树形控件中添加对应节点
+ qt_item = tree_widget.add_node_to_tree_widget(tileset_node, parent_item, "CESIUM_TILESET_NODE")
+ if qt_item:
+ created_tilesets.append((tileset_node, qt_item))
+ else:
+ created_tilesets.append((tileset_node, None))
+ print("⚠️ Qt树节点添加失败，但Panda3D对象已创建")
+
+ except Exception as e:
+ print(f"❌ 为 {parent_item.text(0)} 加载 Tileset 失败: {str(e)}")
+ continue # 继续尝试为下一个父节点创建
+
+ # 3. 处理创建结果
+ if not created_tilesets:
+ print("❌ 没有成功加载任何 Tileset")
+ return None
+
+ # 选中最后创建的Tileset并更新UI
+ if created_tilesets:
+ last_tileset_node, last_qt_item = created_tilesets[-1]
+ if last_qt_item:
+ tree_widget.setCurrentItem(last_qt_item)
+ # 更新选择状态和属性面板
+ tree_widget.update_selection_and_properties(last_tileset_node, last_qt_item)
+
+ print(f"🎉 总共加载了 {len(created_tilesets)} 个 Cesium Tileset 实例")
+
+ # 4. 返回值处理
+ if len(created_tilesets) == 1:
+ return created_tilesets[0][0] # 单个实例返回NodePath
+ else:
+ return [node for node, _ in created_tilesets] # 多个实例返回NodePath列表
except Exception as e:
- print(f"❌ 加载 Cesium 3D Tiles 失败: {e}")
+ print(f"❌ 加载 Cesium 3D Tiles 过程失败: {str(e)}")
import traceback
traceback.print_exc()
return None
@@ -2059,4 +3460,729 @@ except Exception as e:
return None
+ def serializeNode(self, node):
+ """序列化节点为字典数据"""
+ try:
+ node_data = {
+ 'name': node.getName(),
+ 'type': type(node.node()).__name__,
+ 'pos': (node.getX(), node.getY(), node.getZ()),
+ 'hpr': (node.getH(), node.getP(), node.getR()),
+ 'scale': (node.getSx(), node.getSy(), node.getSz()),
+ 'tags': {},
+ 'children': []
+ }
+
+ # 保存所有标签
+ for tag_key in node.getTagKeys():
+ node_data['tags'][tag_key] = node.getTag(tag_key)
+
+ # 特殊处理不同类型的节点
+ if hasattr(node.node(), 'getClassType'):
+ node_class = node.node().getClassType().getName()
+ node_data['node_class'] = node_class
+
+ # 递归序列化子节点
+ for child in node.getChildren():
+ # 跳过辅助节点
+ if not child.getName().startswith(('gizmo', 'selectionBox', 'grid')):
+ child_data = self.serializeNode(child)
+ if child_data:
+ node_data['children'].append(child_data)
+
+ return node_data
+
+ except Exception as e:
+ print(f"序列化节点 {node.getName()} 失败: {e}")
+ import traceback
+ traceback.print_exc()
+ return None
+
+ def deserializeNode(self, node_data, parent_node):
+ """从字典数据反序列化节点"""
+ try:
+ # 创建新节点
+ node_name = node_data.get('name', 'node')
+ new_node = parent_node.attachNewNode(node_name)
+
+ # 设置变换
+ pos = node_data.get('pos', (0, 0, 0))
+ hpr = node_data.get('hpr', (0, 0, 0))
+ scale = node_data.get('scale', (1, 1, 1))
+
+ new_node.setPos(*pos)
+ new_node.setHpr(*hpr)
+ new_node.setScale(*scale)
+
+ # 恢复标签
+ for tag_key, tag_value in node_data.get('tags', {}).items():
+ new_node.setTag(tag_key, tag_value)
+
+ # 根据节点类型进行特殊处理
+ node_type = node_data.get('type', '')
+ node_class = node_data.get('node_class', '')
+
+ # 特殊处理光源节点
+ if 'light_type' in node_data.get('tags', {}):
+ light_type = node_data['tags']['light_type']
+ if light_type == 'spot_light':
+ self._recreateSpotLight(new_node)
+ elif light_type == 'point_light':
+ self._recreatePointLight(new_node)
+
+ # 递归创建子节点
+ for child_data in node_data.get('children', []):
+ self.deserializeNode(child_data, new_node)
+
+ return new_node
+
+ except Exception as e:
+ print(f"反序列化节点 {node_data.get('name', 'unknown')} 失败: {e}")
+ import traceback
+ traceback.print_exc()
+ return None
+
+ def serializeNodeForCopy(self, node):
+ """序列化节点用于复制操作，完整保存视觉属性"""
+ try:
+ if not node or node.isEmpty():
+ return None
+
+ node_data = {
+ 'name': node.getName(),
+ 'type': type(node.node()).__name__,
+ 'pos': (node.getX(), node.getY(), node.getZ()),
+ 'hpr': (node.getH(), node.getP(), node.getR()),
+ 'scale': (node.getSx(), node.getSy(), node.getSz()),
+ 'tags': {},
+ 'children': []
+ }
+
+ # 保存所有标签
+ try:
+ if hasattr(node, 'getTagKeys'):
+ for tag_key in node.getTagKeys():
+ node_data['tags'][tag_key] = node.getTag(tag_key)
+ except Exception as e:
+ print(f"获取标签时出错: {e}")
+
+ # 保存视觉属性
+ try:
+ # 保存颜色属性
+ if hasattr(node, 'getColor'):
+ color = node.getColor()
+ node_data['color'] = (color.getX(), color.getY(), color.getZ(), color.getW())
+
+ # 保存材质属性
+ if hasattr(node, 'getMaterial'):
+ material = node.getMaterial()
+ if material:
+ material_data = {}
+ material_data['base_color'] = (
+ material.getBaseColor().getX(),
+ material.getBaseColor().getY(),
+ material.getBaseColor().getZ(),
+ material.getBaseColor().getW()
+ )
+ material_data['ambient'] = (
+ material.getAmbient().getX(),
+ material.getAmbient().getY(),
+ material.getAmbient().getZ(),
+ material.getAmbient().getW()
+ )
+ material_data['diffuse'] = (
+ material.getDiffuse().getX(),
+ material.getDiffuse().getY(),
+ material.getDiffuse().getZ(),
+ material.getDiffuse().getW()
+ )
+ material_data['specular'] = (
+ material.getSpecular().getX(),
+ material.getSpecular().getY(),
+ material.getSpecular().getZ(),
+ material.getSpecular().getW()
+ )
+ material_data['shininess'] = material.getShininess()
+ node_data['material'] = material_data
+
+ except Exception as e:
+ print(f"保存视觉属性时出错: {e}")
+
+ # 根据节点类型保存特定信息
+ if node.hasTag("tree_item_type"):
+ node_type = node.getTag("tree_item_type")
+ node_data['node_type'] = node_type
+
+ # 保存特定类型节点的额外信息
+ if node_type in ["LIGHT_NODE", "SPOT_LIGHT_NODE", "POINT_LIGHT_NODE"]:
+ # 保存光源特定信息
+ rp_light = node.getPythonTag("rp_light_object")
+ if rp_light:
+ node_data['light_data'] = {
+ 'energy': getattr(rp_light, 'energy', 5000),
+ 'radius': getattr(rp_light, 'radius', 1000),
+ 'fov': getattr(rp_light, 'fov', 70) if hasattr(rp_light, 'fov') else None,
+ 'inner_radius': getattr(rp_light, 'inner_radius', 0.4) if hasattr(rp_light,
+ 'inner_radius') else None,
+ 'casts_shadows': getattr(rp_light, 'casts_shadows', True) if hasattr(rp_light,
+ 'casts_shadows') else True,
+ 'shadow_map_resolution': getattr(rp_light, 'shadow_map_resolution', 256) if hasattr(
+ rp_light, 'shadow_map_resolution') else 256
+ }
+ elif node_type in ["GUI_BUTTON", "GUI_LABEL", "GUI_ENTRY", "GUI_IMAGE",
+ "GUI_3D_TEXT", "GUI_3D_IMAGE", "GUI_VIRTUAL_SCREEN"]:
+ # 保存GUI元素特定信息
+ node_data['gui_data'] = self._serializeGUIData(node)
+ elif node_type == "IMPORTED_MODEL_NODE":
+ # 保存模型特定信息
+ node_data['model_data'] = self._serializeModelData(node)
+
+ return node_data
+
+ except Exception as e:
+ print(f"序列化节点失败: {e}")
+ import traceback
+ traceback.print_exc()
+ return None
+
+ def _serializeGUIData(self, node):
+ """序列化GUI元素数据"""
+ try:
+ gui_data = {}
+
+ # 保存GUI相关的通用属性
+ if node.hasTag("gui_type"):
+ gui_data['gui_type'] = node.getTag("gui_type")
+
+ # 保存文本内容（如果有的话）
+ if node.hasTag("text"):
+ gui_data['text'] = node.getTag("text")
+
+ # 保存其他GUI相关标签
+ gui_tags = ['font', 'font_size', 'text_color', 'bg_color', 'size']
+ for tag in gui_tags:
+ if node.hasTag(tag):
+ gui_data[tag] = node.getTag(tag)
+
+ return gui_data
+ except Exception as e:
+ print(f"序列化GUI数据失败: {e}")
+ return {}
+
+ def _serializeModelData(self, node):
+ """序列化模型数据，包括材质信息"""
+ try:
+ model_data = {}
+
+ # 保存模型相关的标签
+ model_tags = ['model_path', 'file', 'element_type']
+ for tag in model_tags:
+ if node.hasTag(tag):
+ model_data[tag] = node.getTag(tag)
+
+ # 保存材质信息
+ try:
+ # 获取模型的材质信息
+ if hasattr(node, 'getState'):
+ state = node.getState()
+ if state:
+ # 保存基础颜色信息
+ from panda3d.core import ColorAttrib
+ color_attrib = state.getColor()
+ if color_attrib:
+ model_data['base_color'] = (
+ color_attrib.getColor().getX(),
+ color_attrib.getColor().getY(),
+ color_attrib.getColor().getZ(),
+ color_attrib.getColor().getW()
+ )
+
+ # 保存其他材质属性
+ from panda3d.core import MaterialAttrib
+ material_attrib = state.getAttrib(MaterialAttrib.getClassType())
+ if material_attrib:
+ material = material_attrib.getMaterial()
+ if material:
+ # 保存基础颜色
+ base_color = material.getBaseColor()
+ model_data['material_base_color'] = (
+ base_color.getX(), base_color.getY(), base_color.getZ(), base_color.getW()
+ )
+
+ # 保存环境光颜色
+ ambient_color = material.getAmbient()
+ model_data['material_ambient_color'] = (
+ ambient_color.getX(), ambient_color.getY(), ambient_color.getZ(),
+ ambient_color.getW()
+ )
+
+ # 保存漫反射颜色
+ diffuse_color = material.getDiffuse()
+ model_data['material_diffuse_color'] = (
+ diffuse_color.getX(), diffuse_color.getY(), diffuse_color.getZ(),
+ diffuse_color.getW()
+ )
+
+ # 保存高光颜色
+ specular_color = material.getSpecular()
+ model_data['material_specular_color'] = (
+ specular_color.getX(), specular_color.getY(), specular_color.getZ(),
+ specular_color.getW()
+ )
+
+ # 保存粗糙度和金属度等参数
+ model_data['material_roughness'] = material.getRoughness()
+ model_data['material metallic'] = material.getMetallic()
+
+ except Exception as e:
+ print(f"保存材质信息时出错: {e}")
+
+ return model_data
+ except Exception as e:
+ print(f"序列化模型数据失败: {e}")
+ return {}
+
+ def recreateNodeFromData(self, node_data, parent_node):
+ """根据数据重建节点，并确保在场景树中显示"""
+ try:
+ if not node_data or not parent_node or parent_node.isEmpty():
+ return None
+
+ print(f"正在重建节点 {node_data}")
+ node_type = node_data.get('node_type', '')
+ original_name = node_data.get('name', 'node')
+
+ # 生成唯一名称
+ unique_name = self._generateUniqueName(original_name, parent_node)
+
+ # 根据节点类型调用相应的重建方法
+ new_node = None
+ if node_type in ["LIGHT_NODE", "SPOT_LIGHT_NODE", "POINT_LIGHT_NODE"]:
+ new_node = self._recreateLightFromData(node_data, parent_node, unique_name)
+ elif node_type == "CESIUM_TILESET_NODE":
+ new_node = self._recreateTilesetFromData(node_data, parent_node, unique_name)
+ elif node_type in ["GUI_BUTTON", "GUI_LABEL", "GUI_ENTRY", "GUI_IMAGE",
+ "GUI_3DTEXT", "GUI_3DIMAGE", "GUI_VIRTUAL_SCREEN"]:
+ new_node = self._recreateGUIFromData(node_data, parent_node, unique_name)
+ elif node_type == "IMPORTED_MODEL_NODE":
+ new_node = self._recreateModelFromData(node_data, parent_node, unique_name)
+ else:
+ # 创建普通节点
+ new_node = self._createBasicNodeFromData(node_data, parent_node, unique_name)
+
+ # 如果成功创建节点，确保它在场景树中显示
+ if new_node:
+ # 尝试更新场景树以显示新节点
+ try:
+ if hasattr(self.world, 'interface_manager') and self.world.interface_manager:
+ # 查找父节点在场景树中的对应项
+ parent_item = self._findTreeItemForNode(parent_node)
+ if parent_item:
+ # 添加新节点到场景树
+ tree_widget = self.world.interface_manager.treeWidget
+ if tree_widget:
+ tree_widget.add_node_to_tree_widget(new_node, parent_item, node_type or "NODE")
+ except Exception as e:
+ print(f"添加节点到场景树时出错: {e}")
+
+ return new_node
+
+ except Exception as e:
+ print(f"重建节点失败: {e}")
+ import traceback
+ traceback.print_exc()
+ return None
+
+ def _findTreeItemForNode(self, node):
+ """根据节点查找对应的场景树项"""
+ try:
+ if hasattr(self.world, 'interface_manager') and self.world.interface_manager:
+ tree_widget = self.world.interface_manager.treeWidget
+ if tree_widget:
+ # 遍历场景树查找匹配的节点项
+ for i in range(tree_widget.topLevelItemCount()):
+ item = tree_widget.topLevelItem(i)
+ result = self._findTreeItemForNodeRecursive(item, node)
+ if result:
+ return result
+ return None
+ except Exception as e:
+ print(f"查找场景树项时出错: {e}")
+ return None
+
+ def _findTreeItemForNodeRecursive(self, item, target_node):
+ """递归查找场景树项"""
+ try:
+ # 检查当前项是否匹配
+ item_node = getattr(item, 'node_path', None)
+ if not item_node:
+ item_node = getattr(item, 'node', None)
+
+ if item_node and item_node == target_node:
+ return item
+
+ # 递归检查子项
+ for i in range(item.childCount()):
+ child_item = item.child(i)
+ result = self._findTreeItemForNodeRecursive(child_item, target_node)
+ if result:
+ return result
+
+ return None
+ except Exception as e:
+ print(f"递归查找场景树项时出错: {e}")
+ return None
+
+ def _recreateLightFromData(self, node_data, parent_node, name):
+ """根据数据重建光源"""
+ try:
+ light_type = node_data.get('tags', {}).get('light_type', 'spot_light')
+
+ # 创建光源
+ if light_type == 'spot_light':
+ light_node = self.createSpotLight(pos=node_data.get('pos', (0, 0, 0)))
+ else: # point_light
+ light_node = self.createPointLight(pos=node_data.get('pos', (0, 0, 0)))
+
+ if light_node:
+ # 设置名称
+ light_node.setName(name)
+
+ # 恢复其他属性
+ light_data = node_data.get('light_data', {})
+ rp_light = light_node.getPythonTag("rp_light_object")
+ if rp_light and light_data:
+ if 'energy' in light_data:
+ rp_light.energy = light_data['energy']
+ if 'radius' in light_data:
+ rp_light.radius = light_data['radius']
+ if 'fov' in light_data and hasattr(rp_light, 'fov'):
+ rp_light.fov = light_data['fov']
+ if 'inner_radius' in light_data and hasattr(rp_light, 'inner_radius'):
+ rp_light.inner_radius = light_data['inner_radius']
+ if 'casts_shadows' in light_data and hasattr(rp_light, 'casts_shadows'):
+ rp_light.casts_shadows = light_data['casts_shadows']
+ if 'shadow_map_resolution' in light_data and hasattr(rp_light, 'shadow_map_resolution'):
+ rp_light.shadow_map_resolution = light_data['shadow_map_resolution']
+
+ # 恢复其他标签
+ for tag_key, tag_value in node_data.get('tags', {}).items():
+ if tag_key not in ['name', 'light_type']:
+ light_node.setTag(tag_key, str(tag_value))
+
+ return light_node
+
+ except Exception as e:
+ print(f"重建光源失败: {e}")
+ return None
+
+ def _recreateTilesetFromData(self, node_data, parent_node, name):
+ """根据数据重建Tileset"""
+ try:
+ tileset_url = node_data.get('tileset_url', '')
+ if not tileset_url:
+ return None
+
+ # 使用现有方法加载tileset
+ position = node_data.get('pos', (0, 0, 0))
+ tileset_node = self.load_cesium_tileset(tileset_url, position)
+
+ if tileset_node:
+ # 设置名称
+ tileset_node.setName(name)
+
+ # 恢复其他标签
+ for tag_key, tag_value in node_data.get('tags', {}).items():
+ if tag_key not in ['name']:
+ tileset_node.setTag(tag_key, str(tag_value))
+
+ return tileset_node
+
+ except Exception as e:
+ print(f"重建Tileset失败: {e}")
+ return None
+
+ def _recreateGUIFromData(self, node_data, parent_node, name):
+ """根据数据重建GUI元素"""
+ try:
+ gui_data = node_data.get('gui_data', {})
+ #gui_type = gui_data.get('gui_type', '')
+ gui_type = node_data.get("tags").get("gui_type", "")
+
+ print(f"正在重建GUI元素: {gui_type}")
+ print(f"正在重建GUI元素: {node_data}")
+
+ # 根据GUI类型调用相应的创建方法
+ new_gui_element = None
+
+ if gui_type == "button" and hasattr(self.world, 'createGUIButton'):
+ pos = node_data.get('pos', (0, 0, 0))
+ text = node_data.get('tags').get('gui_text', '')
+ size = node_data.get('scale', 1)
+ print(pos,text,size)
+ new_gui_element = self.world.createGUIButton(pos,text,size)
+ elif gui_type == "label" and hasattr(self.world, 'createGUILabel'):
+ pos = node_data.get('pos', (0, 0, 0))
+ text = node_data.get('tags').get('gui_text', '')
+ size = node_data.get('scale', 1)
+ new_gui_element = self.world.createGUILabel(pos,text,size)
+ elif gui_type == "entry" and hasattr(self.world, 'createGUIEntry'):
+ pos = node_data.get('pos', (0, 0, 0))
+ text = node_data.get('tags').get('gui_text', '')
+ size = node_data.get('scale', 1)
+ new_gui_element = self.world.createGUIEntry(pos,text,size)
+ elif gui_type == "2d_image" and hasattr(self.world, 'createGUI2DImage'):
+ pos = node_data.get('pos', (0, 0, 0))
+ image_path = node_data.get('tags').get('image_path', '')
+ size = node_data.get('size', 1)
+ new_gui_element = self.world.createGUI2DImage(pos, image_path, size)
+ elif gui_type == "3d_text" and hasattr(self.world, 'createGUI3DText'):
+ print("正在创建3D文本!!!")
+ pos = node_data.get('pos', (0, 0, 0))
+ text = node_data.get('tags', {}).get('gui_text', '')
+ scale = node_data.get('scale', 1)
+ if isinstance(scale, (list, tuple)):
+ scale = scale[0] if len(scale) > 0 else 1
+ print(f"正在创建3D文本: 位置={pos}, 文本={text}, 大小={scale}")
+ new_gui_element = self.world.createGUI3DText(pos, text, scale)
+ elif gui_type == "3d_image" and hasattr(self.world, 'createGUI3DImage'):
+ pos = node_data.get('pos', (0, 0, 0))
+ image_path = node_data.get('tags').get('image_path', '')
+ scale = node_data.get('scale', (1, 1))
+ if isinstance(scale, (int, float)):
+ scale = (scale, scale)
+ elif isinstance(scale, (list, tuple)) and len(scale) >= 2:
+ scale = (scale[0], scale[1])
+ else:
+ scale = (1, 1)
+ print(f"正在创建3D图片: 位置={pos}, 路径={image_path}, 大小={scale}")
+ new_gui_element = self.world.createGUI3DImage(pos, image_path, scale)
+
+ if new_gui_element:
+ # 设置名称和变换
+ if hasattr(new_gui_element, 'setName'):
+ new_gui_element.setName(name)
+
+ # 设置位置、旋转、缩放
+ pos = node_data.get('pos', (0, 0, 0))
+ hpr = node_data.get('hpr', (0, 0, 0))
+ scale = node_data.get('scale', (1, 1, 1))
+
+ if hasattr(new_gui_element, 'setPos'):
+ new_gui_element.setPos(*pos)
+ if hasattr(new_gui_element, 'setHpr'):
+ new_gui_element.setHpr(*hpr)
+ if hasattr(new_gui_element, 'setScale'):
+ new_gui_element.setScale(*scale)
+
+ # 恢复文本内容
+ if 'text' in gui_data and hasattr(new_gui_element, 'setText'):
+ new_gui_element.setText(gui_data['text'])
+
+ # 恢复其他标签
+ for tag_key, tag_value in node_data.get('tags', {}).items():
+ if hasattr(new_gui_element, 'setTag') and tag_key not in ['name']:
+ new_gui_element.setTag(tag_key, str(tag_value))
+
+ print(f"GUI元素重建成功: {name}")
+
+ return new_gui_element
+
+ except Exception as e:
+ print(f"重建GUI元素失败: {e}")
+ import traceback
+ traceback.print_exc()
+ return None
+
+ def _recreateModelFromData(self, node_data, parent_node, name):
+ """根据数据重建模型，保持材质"""
+ try:
+ model_data = node_data.get('model_data', {})
+ model_path = model_data.get('model_path', model_data.get('file', ''))
+
+ if not model_path or not os.path.exists(model_path):
+ # 如果原始模型文件不存在，创建一个基本节点
+ return self._createBasicNodeFromData(node_data, parent_node, name)
+
+ # 导入模型，保持原有参数
+ model = self.importModel(
+ model_path,
+ apply_unit_conversion=False, # 已经处理过的模型不需要再次转换
+ normalize_scales=False, # 保持原有缩放
+ auto_convert_to_glb=False # 已经处理过的模型不需要再次转换
+ )
+
+ if model:
+ # 设置名称
+ model.setName(name)
+
+ # 设置变换
+ pos = node_data.get('pos', (0, 0, 0))
+ hpr = node_data.get('hpr', (0, 0, 0))
+ scale = node_data.get('scale', (1, 1, 1))
+
+ model.setPos(*pos)
+ model.setHpr(*hpr)
+ model.setScale(*scale)
+
+ # 恢复材质信息
+ try:
+ self._restoreModelMaterial(model, model_data)
+ except Exception as e:
+ print(f"恢复模型材质时出错: {e}")
+
+ # 恢复标签
+ for tag_key, tag_value in node_data.get('tags', {}).items():
+ if tag_key not in ['name']:
+ model.setTag(tag_key, str(tag_value))
+
+ # 添加到模型列表
+ if model not in self.models:
+ self.models.append(model)
+
+ return model
+
+ except Exception as e:
+ print(f"重建模型失败: {e}")
+ # 出错时创建基本节点
+ return self._createBasicNodeFromData(node_data, parent_node, name)
+
+ def _restoreModelMaterial(self, model, model_data):
+ """恢复模型材质"""
+ try:
+ # 恢复基础颜色
+ if 'base_color' in model_data:
+ from panda3d.core import ColorAttrib
+ base_color = model_data['base_color']
+ color = (base_color[0], base_color[1], base_color[2], base_color[3])
+ model.setColor(color)
+
+ # 恢复复杂材质属性
+ if any(key.startswith('material_') for key in model_data.keys()):
+ from panda3d.core import Material
+
+ # 创建新材质或获取现有材质
+ material = Material()
+
+ # 恢复基础颜色
+ if 'material_base_color' in model_data:
+ base_color = model_data['material_base_color']
+ material.setBaseColor((base_color[0], base_color[1], base_color[2], base_color[3]))
+
+ # 恢复环境光颜色
+ if 'material_ambient_color' in model_data:
+ ambient_color = model_data['material_ambient_color']
+ material.setAmbient((ambient_color[0], ambient_color[1], ambient_color[2], ambient_color[3]))
+
+ # 恢复漫反射颜色
+ if 'material_diffuse_color' in model_data:
+ diffuse_color = model_data['material_diffuse_color']
+ material.setDiffuse((diffuse_color[0], diffuse_color[1], diffuse_color[2], diffuse_color[3]))
+
+ # 恢复高光颜色
+ if 'material_specular_color' in model_data:
+ specular_color = model_data['material_specular_color']
+ material.setSpecular((specular_color[0], specular_color[1], specular_color[2], specular_color[3]))
+
+ # 恢复粗糙度和金属度
+ if 'material_roughness' in model_data:
+ material.setRoughness(model_data['material_roughness'])
+
+ if 'material_metallic' in model_data:
+ material.setMetallic(model_data['material_metallic'])
+
+ # 应用材质到模型
+ model.setMaterial(material)
+
+ except Exception as e:
+ print(f"恢复材质失败: {e}")
+
+ def _createBasicNodeFromData(self, node_data, parent_node, name):
+ """创建基本节点，保持视觉属性"""
+ try:
+ new_node = parent_node.attachNewNode(name)
+
+ # 设置变换
+ pos = node_data.get('pos', (0, 0, 0))
+ hpr = node_data.get('hpr', (0, 0, 0))
+ scale = node_data.get('scale', (1, 1, 1))
+
+ new_node.setPos(*pos)
+ new_node.setHpr(*hpr)
+ new_node.setScale(*scale)
+
+ # 恢复视觉属性
+ try:
+ # 恢复颜色
+ if 'color' in node_data:
+ color_data = node_data['color']
+ new_node.setColor(color_data[0], color_data[1], color_data[2], color_data[3])
+
+ # 恢复材质
+ if 'material' in node_data:
+ from panda3d.core import Material
+ material_data = node_data['material']
+ material = Material()
+
+ if 'base_color' in material_data:
+ bc = material_data['base_color']
+ material.setBaseColor((bc[0], bc[1], bc[2], bc[3]))
+
+ if 'ambient' in material_data:
+ ac = material_data['ambient']
+ material.setAmbient((ac[0], ac[1], ac[2], ac[3]))
+
+ if 'diffuse' in material_data:
+ dc = material_data['diffuse']
+ material.setDiffuse((dc[0], dc[1], dc[2], dc[3]))
+
+ if 'specular' in material_data:
+ sc = material_data['specular']
+ material.setSpecular((sc[0], sc[1], sc[2], sc[3]))
+
+ if 'shininess' in material_data:
+ material.setShininess(material_data['shininess'])
+
+ new_node.setMaterial(material)
+
+ except Exception as e:
+ print(f"恢复视觉属性时出错: {e}")
+
+ # 恢复标签
+ for tag_key, tag_value in node_data.get('tags', {}).items():
+ if tag_key not in ['name']:
+ new_node.setTag(tag_key, str(tag_value))
+
+ return new_node
+
+ except Exception as e:
+ print(f"创建基本节点失败: {e}")
+ return None
+
+ def _generateUniqueName(self, base_name, parent_node):
+ """生成唯一节点名称"""
+ try:
+ # 移除可能的数字后缀
+ import re
+ import time
+ name_base = re.sub(r'_\d+$', '', base_name)
+
+ # 查找现有同名节点
+ counter = 1
+ unique_name = base_name
+ while True:
+ # 检查父节点下是否已存在同名子节点
+ existing_node = parent_node.find(unique_name)
+ if existing_node.isEmpty():
+ break
+ unique_name = f"{name_base}_{counter}"
+ counter += 1
+ if counter > 1000: # 防止无限循环
+ unique_name = f"{name_base}_{int(time.time())}"
+ break
+
+ return unique_name
+ except:
+ return f"{base_name}_{int(time.time())}"
+
diff --git a/scene/util.py b/scene/util.py
index 678beba0..06ad4b23 100644
--- a/scene/util.py
+++ b/scene/util.py
@@ -25,9 +25,9 @@ class CrossPlatformPathHandler:
def normalize_model_path(self, filepath):
"""标准化模型文件路径"""
try:
- print(f"\n=== 路径标准化处理 ===")
- print(f"原始路径: {filepath}")
- print(f"当前系统: {self.system}")
+ #print(f"\n=== 路径标准化处理 ===")
+ #print(f"原始路径: {filepath}")
+ #print(f"当前系统: {self.system}")
# 步骤1: 检查原始路径是否存在
if self._check_file_exists(filepath):
@@ -54,10 +54,6 @@ class CrossPlatformPathHandler:
def _check_file_exists(self, filepath):
"""检查文件是否存在"""
exists = os.path.exists(filepath)
- if exists:
- print(f"✓ 文件存在: {filepath}")
- else:
- print(f"⚠️ 文件不存在: {filepath}")
return exists
def _panda3d_normalize(self, filepath):
diff --git a/scripts/RotatorScript.py b/scripts/RotatorScript.py
index cea56986..bdc49495 100644
--- a/scripts/RotatorScript.py
+++ b/scripts/RotatorScript.py
@@ -21,6 +21,10 @@ class RotatorScript(ScriptBase):
self.log(f"旋转速度: {self.rotation_speed_y}度/秒")
def update(self, dt):
+ # 检查 gameObject 是否存在且不为空
+ if not self.gameObject or self.gameObject.isEmpty():
+ print("RotatorScript: gameObject is empty or None, skipping update")
+ return
"""每帧更新"""
if not self.is_rotating:
return
diff --git a/threejs_panel.html b/threejs_panel.html
new file mode 100644
index 00000000..ee6ef4c1
--- /dev/null
+++ b/threejs_panel.html
@@ -0,0 +1,106 @@
+
+
+
+
+ Three.js Panel
+
+
+
+
+
场景信息面板
+
FPS: 0
+
对象数: 0
+