3966 lines
160 KiB
Python
3966 lines
160 KiB
Python
|
||
import sys
|
||
import os
|
||
import struct
|
||
import time
|
||
import types
|
||
from panda3d.core import (
|
||
Filename, loadPrcFileData, GeomVertexFormat,
|
||
GeomVertexWriter, InternalName, Shader, Texture, SamplerState,
|
||
Vec3, Vec4, Point2, Point3, LMatrix4f, ShaderBuffer, GeomEnums, OmniBoundingVolume,
|
||
TransparencyAttrib, BoundingSphere, NodePath,
|
||
GraphicsEngine, WindowProperties, FrameBufferProperties,
|
||
GraphicsPipe, GraphicsOutput, Camera, DisplayRegion, OrthographicLens,
|
||
BoundingBox, BitMask32, Material, MaterialAttrib, ColorAttrib, TextureAttrib, PNMImage,
|
||
KeyboardButton
|
||
)
|
||
|
||
# p3dimgui.backend first tries `from shaders import *`, which can be shadowed by
|
||
# project folders named `shaders/` and leave VERT_SHADER/FRAG_SHADER undefined.
|
||
# Seed a valid fallback module before importing p3dimgui.
|
||
_shaders_mod = sys.modules.get("shaders")
|
||
if not (_shaders_mod and hasattr(_shaders_mod, "VERT_SHADER") and hasattr(_shaders_mod, "FRAG_SHADER")):
|
||
_shaders_mod = types.ModuleType("shaders")
|
||
_shaders_mod.FRAG_SHADER = """
|
||
#version 120
|
||
varying vec2 texcoord;
|
||
varying vec4 color;
|
||
uniform sampler2D p3d_Texture0;
|
||
void main() {
|
||
gl_FragColor = color * texture2D(p3d_Texture0, texcoord);
|
||
}
|
||
"""
|
||
_shaders_mod.VERT_SHADER = """
|
||
#version 120
|
||
attribute vec4 p3d_Vertex;
|
||
attribute vec4 p3d_Color;
|
||
varying vec2 texcoord;
|
||
varying vec4 color;
|
||
uniform mat4 p3d_ModelViewProjectionMatrix;
|
||
void main() {
|
||
texcoord = p3d_Vertex.zw;
|
||
color = p3d_Color.bgra;
|
||
gl_Position = p3d_ModelViewProjectionMatrix * vec4(p3d_Vertex.x, 0.0, -p3d_Vertex.y, 1.0);
|
||
}
|
||
"""
|
||
sys.modules["shaders"] = _shaders_mod
|
||
|
||
from p3dimgui import ImGuiBackend
|
||
from imgui_bundle import imgui
|
||
from rpcore.effect import Effect
|
||
|
||
from .ssbo_controller import ObjectController
|
||
from core.selection_outline import SelectionOutlineManager
|
||
|
||
class SSBOEditor:
|
||
"""
|
||
SSBO Editor Component
|
||
====================
|
||
Encapsulates the SSBO rendering, ImGui editor, and interaction logic.
|
||
Can be integrated into any ShowBase application using RenderPipeline.
|
||
"""
|
||
|
||
def __init__(self, base_app, render_pipeline, model_path=None, font_path=None):
|
||
self.base = base_app
|
||
self.rp = render_pipeline
|
||
self.controller = None
|
||
self.model = None
|
||
self.source_model = None
|
||
self.source_model_root = None
|
||
self._source_child_base_mats = {}
|
||
self._runtime_owner_base_mats = {}
|
||
self._model_root_last_snapshot_mat = LMatrix4f.ident_mat()
|
||
self.last_import_tree_key = None
|
||
self.last_import_root_name = None
|
||
self.ssbo = None
|
||
self.font_path = font_path
|
||
self._transform_gizmo = None
|
||
self._ssbo_transform_active = False
|
||
self._ssbo_selected_local_indices = []
|
||
self._ssbo_gizmo_proxy = None
|
||
|
||
# Internal State
|
||
self.selected_name = None
|
||
self.selected_ids = []
|
||
self.transform_ids = []
|
||
self.search_text = ""
|
||
self.last_search_text = None
|
||
self.filtered_nodes = []
|
||
self.debug_mode = False
|
||
self.keys = {}
|
||
self.pick_mask = BitMask32.bit(29)
|
||
self.pick_buffer = None
|
||
self._empty_pick_scene = NodePath("ssbo_pick_empty")
|
||
# Avoid heavy per-frame sync for huge group selections.
|
||
self._pick_sync_bg_limit = 256
|
||
self._last_group_sync_mat = None
|
||
self._last_single_sync_gid = None
|
||
self._last_single_sync_mat = None
|
||
self._group_proxy_initial_mat = None
|
||
self._group_proxy_source_initial_net_mat = None
|
||
# Performance toggle: forcing shadow tasks every frame is expensive.
|
||
# Keep it off by default so frustum/content reduction has clearer FPS impact.
|
||
self.realtime_shadow_updates = False
|
||
self._scheduler_tasks_original = None
|
||
self._realtime_shadow_tasks_enabled = False
|
||
self._outline_manager = getattr(self.base, "_selection_outline_manager", None)
|
||
if self._outline_manager is None:
|
||
self._outline_manager = SelectionOutlineManager(self.base)
|
||
setattr(self.base, "_selection_outline_manager", self._outline_manager)
|
||
|
||
# Initialize ImGui Backend if not already present
|
||
if not hasattr(self.base, 'imgui_backend'):
|
||
print("[SSBOEditor] Initializing ImGui Backend...")
|
||
self.base.imgui_backend = ImGuiBackend()
|
||
|
||
self.load_font()
|
||
|
||
# Register Events
|
||
self.base.accept("imgui-new-frame", self.draw_imgui)
|
||
self.base.accept("f", self.focus_on_selected)
|
||
self.base.accept("d", self.toggle_debug)
|
||
self.base.accept("mouse1", self.on_mouse_click)
|
||
|
||
# Register Input Tasks
|
||
for key in ['arrow_up', 'arrow_down', 'arrow_left', 'arrow_right', 'z', 'x']:
|
||
self.base.accept(key, self.keys.__setitem__, [key, True])
|
||
self.base.accept(f"{key}-up", self.keys.__setitem__, [key, False])
|
||
|
||
# Add Tasks
|
||
self.base.taskMgr.add(self.update_task, "update_task")
|
||
|
||
# Load Model if provided
|
||
if model_path:
|
||
self.load_model(model_path)
|
||
|
||
def _get_model_file_size(self, model_path):
|
||
try:
|
||
return int(os.path.getsize(model_path))
|
||
except Exception:
|
||
return 0
|
||
|
||
def _should_skip_heavy_material_processing(self, *, model_path=None, geom_count=0, node_count=0):
|
||
file_size = self._get_model_file_size(model_path) if model_path else 0
|
||
if file_size >= 200 * 1024 * 1024:
|
||
return True
|
||
if geom_count >= 2048:
|
||
return True
|
||
if node_count >= 4096:
|
||
return True
|
||
return False
|
||
|
||
def _capture_scheduler_tasks_snapshot(self):
|
||
scheduler = getattr(self.rp, "task_scheduler", None)
|
||
if not scheduler or not hasattr(scheduler, "_tasks"):
|
||
return
|
||
if self._scheduler_tasks_original is None:
|
||
self._scheduler_tasks_original = [list(frame_tasks) for frame_tasks in scheduler._tasks]
|
||
|
||
def _enable_realtime_shadow_tasks(self):
|
||
"""
|
||
Force PSSM-related scheduled tasks to run every frame to avoid visible
|
||
shadow lag/ghosting while editing moving objects.
|
||
"""
|
||
scheduler = getattr(self.rp, "task_scheduler", None)
|
||
if not scheduler or not hasattr(scheduler, "_tasks"):
|
||
return
|
||
|
||
self._capture_scheduler_tasks_snapshot()
|
||
|
||
required = {
|
||
"pssm_scene_shadows",
|
||
"pssm_distant_shadows",
|
||
"pssm_convert_distant_to_esm",
|
||
"pssm_blur_distant_vert",
|
||
"pssm_blur_distant_horiz",
|
||
}
|
||
changed = False
|
||
for frame_tasks in scheduler._tasks:
|
||
for task_name in required:
|
||
if task_name not in frame_tasks:
|
||
frame_tasks.append(task_name)
|
||
changed = True
|
||
|
||
if changed:
|
||
print("[SSBOEditor] Realtime shadow tasks enabled (PSSM updates every frame).")
|
||
self._realtime_shadow_tasks_enabled = True
|
||
|
||
def _disable_realtime_shadow_tasks(self):
|
||
"""Restore scheduler layout captured before realtime shadow override."""
|
||
scheduler = getattr(self.rp, "task_scheduler", None)
|
||
if not scheduler or not hasattr(scheduler, "_tasks"):
|
||
return
|
||
if self._scheduler_tasks_original is None:
|
||
self._realtime_shadow_tasks_enabled = False
|
||
return
|
||
scheduler._tasks[:] = [list(frame_tasks) for frame_tasks in self._scheduler_tasks_original]
|
||
self._realtime_shadow_tasks_enabled = False
|
||
|
||
def set_realtime_shadow_updates(self, enabled):
|
||
"""Public toggle for aggressive per-frame shadow updates."""
|
||
self.realtime_shadow_updates = bool(enabled)
|
||
if self.realtime_shadow_updates:
|
||
self._enable_realtime_shadow_tasks()
|
||
else:
|
||
self._disable_realtime_shadow_tasks()
|
||
|
||
def load_font(self):
|
||
"""Load custom font for ImGui"""
|
||
io = imgui.get_io()
|
||
|
||
# Load Chinese Glyph Ranges
|
||
glyph_ranges = None
|
||
try:
|
||
if hasattr(io.fonts, 'get_glyph_ranges_chinese_full'):
|
||
glyph_ranges = io.fonts.get_glyph_ranges_chinese_full()
|
||
elif hasattr(io.fonts, 'get_glyph_ranges_chinese_simplified_common'):
|
||
glyph_ranges = io.fonts.get_glyph_ranges_chinese_simplified_common()
|
||
except Exception as e:
|
||
print(f"[SSBOEditor] Warning: Could not get Chinese glyph ranges: {e}")
|
||
|
||
try:
|
||
if self.font_path and os.path.exists(self.font_path):
|
||
io.fonts.clear()
|
||
# If glyph_ranges is None, it uses default (Basic Latin)
|
||
if glyph_ranges:
|
||
io.fonts.add_font_from_file_ttf(self.font_path, 18.0, glyph_ranges=glyph_ranges)
|
||
else:
|
||
io.fonts.add_font_from_file_ttf(self.font_path, 18.0)
|
||
else:
|
||
# Fallback to default or common font
|
||
default_font = os.path.join(os.path.dirname(os.path.dirname(__file__)), "font", "msyh.ttc")
|
||
if os.path.exists(default_font):
|
||
io.fonts.clear()
|
||
io.fonts.add_font_from_file_ttf(default_font, 18.0, glyph_ranges=glyph_ranges)
|
||
else:
|
||
io.fonts.clear()
|
||
io.fonts.add_font_default()
|
||
except Exception as e:
|
||
print(f"[SSBOEditor] Font load error: {e}")
|
||
io.fonts.clear()
|
||
io.fonts.add_font_default()
|
||
|
||
def _fixBlackMaterials(self, model):
|
||
try:
|
||
from panda3d.core import MaterialAttrib, Material, GeomNode
|
||
|
||
for geom_path in model.findAllMatches('**/+GeomNode'):
|
||
geom_node = geom_path.node()
|
||
|
||
node_state = geom_path.getState()
|
||
if node_state.hasAttrib(MaterialAttrib.getClassType()):
|
||
mat_attrib = node_state.getAttrib(MaterialAttrib.getClassType())
|
||
mat = mat_attrib.getMaterial()
|
||
if mat:
|
||
is_black = False
|
||
if mat.hasBaseColor():
|
||
c = mat.getBaseColor()
|
||
if c.x <= 0.05 and c.y <= 0.05 and c.z <= 0.05:
|
||
is_black = True
|
||
elif mat.hasDiffuse():
|
||
c = mat.getDiffuse()
|
||
if c.x <= 0.05 and c.y <= 0.05 and c.z <= 0.05:
|
||
is_black = True
|
||
|
||
if is_black or not (mat.hasBaseColor() or mat.hasDiffuse()):
|
||
new_mat = Material(mat)
|
||
new_mat.setBaseColor((0.8, 0.8, 0.8, 1.0))
|
||
new_mat.setDiffuse((0.8, 0.8, 0.8, 1.0))
|
||
geom_path.setState(node_state.setAttrib(MaterialAttrib.make(new_mat)))
|
||
|
||
for i in range(geom_node.getNumGeoms()):
|
||
geom_state = geom_node.getGeomState(i)
|
||
if geom_state.hasAttrib(MaterialAttrib.getClassType()):
|
||
mat_attrib = geom_state.getAttrib(MaterialAttrib.getClassType())
|
||
mat = mat_attrib.getMaterial()
|
||
if mat:
|
||
is_black = False
|
||
if mat.hasBaseColor():
|
||
c = mat.getBaseColor()
|
||
if c.x <= 0.05 and c.y <= 0.05 and c.z <= 0.05:
|
||
is_black = True
|
||
elif mat.hasDiffuse():
|
||
c = mat.getDiffuse()
|
||
if c.x <= 0.05 and c.y <= 0.05 and c.z <= 0.05:
|
||
is_black = True
|
||
|
||
if is_black or not (mat.hasBaseColor() or mat.hasDiffuse()):
|
||
new_mat = Material(mat)
|
||
new_mat.setBaseColor((0.8, 0.8, 0.8, 1.0))
|
||
new_mat.setDiffuse((0.8, 0.8, 0.8, 1.0))
|
||
geom_node.setGeomState(i, geom_state.setAttrib(MaterialAttrib.make(new_mat)))
|
||
else:
|
||
new_mat = Material()
|
||
new_mat.setBaseColor((0.8, 0.8, 0.8, 1.0))
|
||
new_mat.setDiffuse((0.8, 0.8, 0.8, 1.0))
|
||
new_mat.setSpecular((0.2, 0.2, 0.2, 1.0))
|
||
new_mat.setRoughness(0.8)
|
||
geom_node.setGeomState(i, geom_state.addAttrib(MaterialAttrib.make(new_mat)))
|
||
|
||
model.clearColor()
|
||
|
||
except Exception as e:
|
||
print(f'修复黑色模型材质时出错: {e}')
|
||
|
||
def _load_source_model_from_path(self, model_path, apply_black_fix=True, repair_textures=True):
|
||
"""Load a source model NodePath from disk without touching current runtime state."""
|
||
source_model = None
|
||
last_error = None
|
||
load_path = model_path
|
||
try:
|
||
from scene.gltf_support import ensure_gltf_visual_bam, probe_gltf_metadata
|
||
|
||
gltf_meta = probe_gltf_metadata(model_path)
|
||
if gltf_meta.get("is_gltf"):
|
||
has_anim = gltf_meta.get("has_animations", False)
|
||
if has_anim:
|
||
project_manager = getattr(self.base, "project_manager", None)
|
||
project_root = getattr(project_manager, "current_project_path", "") if project_manager else ""
|
||
cached_visual_path = ensure_gltf_visual_bam(
|
||
model_path,
|
||
project_root=project_root,
|
||
skip_animations=False, # 既然是为了动画，就不跳过
|
||
flatten_nodes=False,
|
||
)
|
||
if cached_visual_path and cached_visual_path != model_path:
|
||
load_path = cached_visual_path
|
||
print(f"[GLTF智能加载] SSBO检测到动画，使用缓存: {cached_visual_path}")
|
||
else:
|
||
print(f"[GLTF智能加载] SSBO识别为静态模型，跳过缓存以获得最大流畅度")
|
||
except Exception as e:
|
||
print(f"[GLTF可见缓存] SSBO回退原始模型加载: {e}")
|
||
loader_options = None
|
||
try:
|
||
from panda3d.core import LoaderOptions
|
||
loader_options = LoaderOptions()
|
||
if hasattr(loader_options, "LF_no_cache"):
|
||
loader_options.setFlags(loader_options.getFlags() | loader_options.LF_no_cache)
|
||
elif hasattr(loader_options, "LFNoCache"):
|
||
loader_options.setFlags(loader_options.getFlags() | loader_options.LFNoCache)
|
||
except Exception:
|
||
loader_options = None
|
||
for fn in self._build_filename_candidates(load_path):
|
||
try:
|
||
if loader_options is not None:
|
||
source_model = self.base.loader.loadModel(fn, loader_options)
|
||
else:
|
||
source_model = self.base.loader.loadModel(fn)
|
||
if source_model and not source_model.is_empty():
|
||
break
|
||
except Exception as e:
|
||
last_error = e
|
||
source_model = None
|
||
if not source_model or source_model.is_empty():
|
||
if last_error:
|
||
raise RuntimeError(f"Failed to load model '{model_path}': {last_error}")
|
||
raise RuntimeError(f"Failed to load model '{model_path}'")
|
||
if apply_black_fix:
|
||
self._fixBlackMaterials(source_model)
|
||
if repair_textures:
|
||
self._repair_missing_textures(source_model, model_path)
|
||
return source_model
|
||
|
||
def _detach_shared_materials_in_subtree(self, root_np):
|
||
"""Clone materials in-place so one imported model instance cannot affect another."""
|
||
try:
|
||
from panda3d.core import Material, MaterialAttrib
|
||
|
||
if not self._node_is_valid(root_np):
|
||
return
|
||
|
||
for np in root_np.find_all_matches("**"):
|
||
if not self._node_is_valid(np):
|
||
continue
|
||
|
||
try:
|
||
if np.hasMaterial():
|
||
material = np.getMaterial()
|
||
if material is not None:
|
||
np.setMaterial(Material(material), 1)
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
panda_node = np.node()
|
||
if panda_node is None or not hasattr(panda_node, "getNumGeoms"):
|
||
continue
|
||
for geom_index in range(panda_node.getNumGeoms()):
|
||
geom_state = panda_node.getGeomState(geom_index)
|
||
if not geom_state.hasAttrib(MaterialAttrib):
|
||
continue
|
||
material_attrib = geom_state.getAttrib(MaterialAttrib)
|
||
material = material_attrib.getMaterial() if material_attrib else None
|
||
if material is None:
|
||
continue
|
||
panda_node.setGeomState(
|
||
geom_index,
|
||
geom_state.setAttrib(MaterialAttrib.make(Material(material))),
|
||
)
|
||
except Exception:
|
||
continue
|
||
except Exception:
|
||
pass
|
||
|
||
def _materialize_explicit_geom_materials(self, root_np):
|
||
"""Bake each GeomNode's effective material into local GeomState and clear inherited node material."""
|
||
try:
|
||
from panda3d.core import Material, MaterialAttrib
|
||
|
||
if not self._node_is_valid(root_np):
|
||
return
|
||
|
||
for geom_np in root_np.find_all_matches("**/+GeomNode"):
|
||
if not self._node_is_valid(geom_np):
|
||
continue
|
||
|
||
try:
|
||
geom_node = geom_np.node()
|
||
except Exception:
|
||
continue
|
||
|
||
net_state = None
|
||
try:
|
||
net_state = geom_np.getNetState()
|
||
except Exception:
|
||
try:
|
||
net_state = geom_np.get_net_state()
|
||
except Exception:
|
||
net_state = None
|
||
|
||
for geom_index in range(geom_node.getNumGeoms()):
|
||
try:
|
||
geom_state = geom_node.getGeomState(geom_index)
|
||
except Exception:
|
||
continue
|
||
|
||
material = None
|
||
try:
|
||
if geom_state.hasAttrib(MaterialAttrib):
|
||
material_attrib = geom_state.getAttrib(MaterialAttrib)
|
||
material = material_attrib.getMaterial() if material_attrib else None
|
||
except Exception:
|
||
material = None
|
||
|
||
if material is None and net_state is not None:
|
||
try:
|
||
if net_state.hasAttrib(MaterialAttrib):
|
||
material_attrib = net_state.getAttrib(MaterialAttrib)
|
||
material = material_attrib.getMaterial() if material_attrib else None
|
||
except Exception:
|
||
material = None
|
||
|
||
if material is None:
|
||
try:
|
||
if geom_np.hasMaterial():
|
||
material = geom_np.getMaterial()
|
||
except Exception:
|
||
material = None
|
||
|
||
if material is None:
|
||
continue
|
||
|
||
try:
|
||
geom_node.setGeomState(
|
||
geom_index,
|
||
geom_state.setAttrib(MaterialAttrib.make(Material(material))),
|
||
)
|
||
except Exception:
|
||
continue
|
||
|
||
try:
|
||
if geom_np.hasMaterial():
|
||
geom_np.clearMaterial()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
geom_np.clearAttrib(MaterialAttrib.getClassType())
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
pass
|
||
|
||
def _set_node_name(self, node, name):
|
||
if not node:
|
||
return
|
||
try:
|
||
node.set_name(name)
|
||
return
|
||
except Exception:
|
||
pass
|
||
try:
|
||
node.setName(name)
|
||
except Exception:
|
||
pass
|
||
|
||
def _get_node_name(self, node, default_name=None):
|
||
if not node:
|
||
return default_name
|
||
try:
|
||
return node.get_name()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
return node.getName()
|
||
except Exception:
|
||
return default_name
|
||
|
||
def _iter_children(self, node):
|
||
if not node:
|
||
return []
|
||
try:
|
||
return list(node.get_children())
|
||
except Exception:
|
||
try:
|
||
return list(node.getChildren())
|
||
except Exception:
|
||
return []
|
||
|
||
def _ensure_source_model_root(self):
|
||
root = self.source_model_root
|
||
if root:
|
||
try:
|
||
if not root.is_empty():
|
||
return root
|
||
except Exception:
|
||
try:
|
||
if not root.isEmpty():
|
||
return root
|
||
except Exception:
|
||
pass
|
||
self.source_model_root = NodePath("ssbo_source_scene_root")
|
||
return self.source_model_root
|
||
|
||
def _make_unique_source_child_name(self, desired_name):
|
||
root = self._ensure_source_model_root()
|
||
existing_names = set()
|
||
for child in self._iter_children(root):
|
||
try:
|
||
existing_names.add(child.get_name())
|
||
except Exception:
|
||
try:
|
||
existing_names.add(child.getName())
|
||
except Exception:
|
||
continue
|
||
|
||
base_name = desired_name or "imported_model"
|
||
if base_name not in existing_names:
|
||
return base_name
|
||
|
||
stem, ext = os.path.splitext(base_name)
|
||
index = 2
|
||
while True:
|
||
candidate = f"{stem}_{index}{ext}"
|
||
if candidate not in existing_names:
|
||
return candidate
|
||
index += 1
|
||
|
||
@staticmethod
|
||
def _tag_is_enabled(node, tag_name, default=False):
|
||
try:
|
||
if not node or not node.hasTag(tag_name):
|
||
return bool(default)
|
||
value = str(node.getTag(tag_name) or "").strip().lower()
|
||
if value in ("1", "true", "yes", "on"):
|
||
return True
|
||
if value in ("0", "false", "no", "off"):
|
||
return False
|
||
except Exception:
|
||
pass
|
||
return bool(default)
|
||
|
||
def _node_has_saved_animation_info(self, node):
|
||
if not self._node_is_valid(node):
|
||
return False
|
||
for tag_name in ("saved_has_animations", "has_animations"):
|
||
if self._tag_is_enabled(node, tag_name, default=False):
|
||
return True
|
||
try:
|
||
if node.hasTag("gltf_animation_count"):
|
||
return int(str(node.getTag("gltf_animation_count") or "0").strip() or "0") > 0
|
||
except Exception:
|
||
pass
|
||
return False
|
||
|
||
def _should_skip_scene_package_child_for_ssbo(self, node):
|
||
if not self._node_is_valid(node):
|
||
return False
|
||
if self._node_has_saved_animation_info(node):
|
||
return True
|
||
try:
|
||
if node.hasTag("ssbo_managed"):
|
||
return not self._tag_is_enabled(node, "ssbo_managed", default=True)
|
||
except Exception:
|
||
pass
|
||
return False
|
||
|
||
def _capture_source_child_base_mats(self):
|
||
"""Capture baseline local mats for each top-level source child."""
|
||
self._source_child_base_mats = {}
|
||
self._model_root_last_snapshot_mat = LMatrix4f.ident_mat()
|
||
root = self.source_model_root
|
||
if not root:
|
||
return
|
||
for child in self._iter_children(root):
|
||
if not self._node_is_valid(child):
|
||
continue
|
||
name = self._get_node_name(child, None)
|
||
if not name:
|
||
continue
|
||
try:
|
||
self._source_child_base_mats[name] = LMatrix4f(child.get_mat())
|
||
except Exception:
|
||
try:
|
||
self._source_child_base_mats[name] = LMatrix4f(child.getMat())
|
||
except Exception:
|
||
continue
|
||
|
||
def _get_top_level_group_keys(self):
|
||
if not self.controller or not getattr(self.controller, "tree_root_key", None):
|
||
return []
|
||
root_key = self.controller.tree_root_key
|
||
root_node = self.controller.tree_nodes.get(root_key)
|
||
if not root_node:
|
||
return []
|
||
return list(root_node.get("children", []))
|
||
|
||
def _invert_matrix_in_place(self, mat_value):
|
||
inv_mat = LMatrix4f(mat_value)
|
||
try:
|
||
inv_mat.invertInPlace()
|
||
return inv_mat
|
||
except Exception:
|
||
try:
|
||
inv_mat.invert_in_place()
|
||
return inv_mat
|
||
except Exception:
|
||
return None
|
||
|
||
def _capture_runtime_owner_base_mats(self):
|
||
"""Capture runtime model-space matrices keyed by hierarchy owner key."""
|
||
self._runtime_owner_base_mats = {}
|
||
controller = getattr(self, "controller", None)
|
||
if not controller or not self.model:
|
||
return
|
||
|
||
id_to_object_np = getattr(controller, "id_to_object_np", {}) or {}
|
||
id_to_name = getattr(controller, "id_to_name", {}) or {}
|
||
if not id_to_object_np or not id_to_name:
|
||
return
|
||
|
||
root_key = getattr(controller, "tree_root_key", None)
|
||
for global_id, obj_np in id_to_object_np.items():
|
||
if not self._node_is_valid(obj_np):
|
||
continue
|
||
owner_key = str(id_to_name.get(global_id, "") or "").strip()
|
||
if not owner_key or owner_key == root_key:
|
||
continue
|
||
if owner_key in self._runtime_owner_base_mats:
|
||
continue
|
||
try:
|
||
self._runtime_owner_base_mats[owner_key] = LMatrix4f(obj_np.get_mat(self.model))
|
||
except Exception:
|
||
try:
|
||
self._runtime_owner_base_mats[owner_key] = LMatrix4f(obj_np.getMat(self.model))
|
||
except Exception:
|
||
continue
|
||
|
||
def _snapshot_top_level_transforms_to_source_root(self):
|
||
"""Persist current runtime transforms back into the source scene tree."""
|
||
if not self.controller or not self.model or not self.source_model_root:
|
||
return
|
||
|
||
selected_key = self.selected_name
|
||
is_top_level_like_selection = False
|
||
if selected_key:
|
||
is_top_level_like_selection = bool(
|
||
self._selection_equivalent_top_level_key(selected_key)
|
||
or self._is_top_level_source_child_selection(selected_key)
|
||
or self._is_displayed_top_level_selection(selected_key)
|
||
or self._should_use_model_root_for_top_level_selection(selected_key)
|
||
)
|
||
|
||
selected_top_synced = self._snapshot_selected_top_level_transform_to_source()
|
||
|
||
# Top-level model transforms live on the aggregated runtime root/proxy.
|
||
# Batch-syncing descendant runtime objects in the same pass writes an
|
||
# opposite transform into the children, so the reopened scene visually
|
||
# cancels back to the original pose.
|
||
if not is_top_level_like_selection:
|
||
self._snapshot_runtime_transforms_to_source_root()
|
||
|
||
if not selected_top_synced:
|
||
self._snapshot_active_selection_transform_to_source()
|
||
self._snapshot_model_root_transform_to_source_root()
|
||
|
||
def _snapshot_selected_top_level_transform_to_source(self):
|
||
"""Explicitly persist currently selected top-level model transform, including wrapper selections."""
|
||
if not self.controller or not self.model or not self.source_model_root:
|
||
return False
|
||
|
||
selected_key = self.selected_name
|
||
root_key = getattr(self.controller, "tree_root_key", None)
|
||
if not selected_key or selected_key == root_key:
|
||
return False
|
||
|
||
top_key = self._selection_equivalent_top_level_key(selected_key)
|
||
if not top_key:
|
||
is_top_level_like_selection = bool(
|
||
self._is_top_level_source_child_selection(selected_key)
|
||
or self._is_displayed_top_level_selection(selected_key)
|
||
)
|
||
if is_top_level_like_selection:
|
||
top_key = selected_key
|
||
if not top_key:
|
||
return False
|
||
|
||
source_node = self._resolve_source_node_by_tree_key(top_key)
|
||
if not self._node_is_valid(source_node):
|
||
return False
|
||
|
||
scene_node = self.get_selection_scene_node()
|
||
if not self._node_is_valid(scene_node):
|
||
return False
|
||
|
||
# Single-model top-level selections are edited through self.model.
|
||
# In that case, use the dedicated model-root delta snapshot path.
|
||
if scene_node == self.model:
|
||
return self._snapshot_model_root_transform_to_source_root()
|
||
|
||
try:
|
||
current_net_mat = LMatrix4f(scene_node.get_mat(self.model))
|
||
except Exception:
|
||
try:
|
||
current_net_mat = LMatrix4f(scene_node.getMat(self.model))
|
||
except Exception:
|
||
return False
|
||
|
||
try:
|
||
reference_node = self._get_transform_snapshot_reference_node(source_node)
|
||
source_node.set_mat(reference_node, current_net_mat)
|
||
source_node.setTag("scene_transform_dirty", "true")
|
||
try:
|
||
self._cache_top_level_source_child_base_mat(source_node, source_node.get_mat())
|
||
except Exception:
|
||
try:
|
||
self._cache_top_level_source_child_base_mat(source_node, source_node.getMat())
|
||
except Exception:
|
||
pass
|
||
return True
|
||
except Exception:
|
||
try:
|
||
source_node.setMat(reference_node, current_net_mat)
|
||
source_node.setTag("scene_transform_dirty", "true")
|
||
try:
|
||
self._cache_top_level_source_child_base_mat(source_node, source_node.get_mat())
|
||
except Exception:
|
||
try:
|
||
self._cache_top_level_source_child_base_mat(source_node, source_node.getMat())
|
||
except Exception:
|
||
pass
|
||
return True
|
||
except Exception:
|
||
return False
|
||
|
||
def _snapshot_runtime_transforms_to_source_root(self):
|
||
"""Persist runtime object transforms for all owner keys back into source tree."""
|
||
controller = getattr(self, "controller", None)
|
||
if not controller or not self.model or not self.source_model_root:
|
||
return 0
|
||
|
||
id_to_object_np = getattr(controller, "id_to_object_np", {}) or {}
|
||
id_to_name = getattr(controller, "id_to_name", {}) or {}
|
||
if not id_to_object_np or not id_to_name:
|
||
return 0
|
||
|
||
owner_net_mats = {}
|
||
for global_id, obj_np in id_to_object_np.items():
|
||
if not self._node_is_valid(obj_np):
|
||
continue
|
||
owner_key = str(id_to_name.get(global_id, "") or "").strip()
|
||
if not owner_key:
|
||
continue
|
||
if owner_key == getattr(controller, "tree_root_key", None):
|
||
continue
|
||
if owner_key in owner_net_mats:
|
||
continue
|
||
try:
|
||
owner_net_mats[owner_key] = LMatrix4f(obj_np.get_mat(self.model))
|
||
except Exception:
|
||
try:
|
||
owner_net_mats[owner_key] = LMatrix4f(obj_np.getMat(self.model))
|
||
except Exception:
|
||
continue
|
||
|
||
if not owner_net_mats:
|
||
return 0
|
||
|
||
synced = 0
|
||
ordered_owner_items = sorted(
|
||
owner_net_mats.items(),
|
||
key=lambda item: str(item[0]).count("/"),
|
||
)
|
||
for owner_key, current_net_mat in ordered_owner_items:
|
||
source_node = self._resolve_source_node_by_tree_key(owner_key)
|
||
if not self._node_is_valid(source_node):
|
||
continue
|
||
|
||
try:
|
||
# Use robust Panda3D set_mat(ref, mat) to handle all coordinate conversions.
|
||
# This ensures the source node's net transform relative to the source root
|
||
# exactly matches the runtime node's net transform relative to self.model.
|
||
reference_node = self._get_transform_snapshot_reference_node(source_node)
|
||
source_node.set_mat(reference_node, current_net_mat)
|
||
source_node.setTag("scene_transform_dirty", "true")
|
||
|
||
# Update top-level child baseline cache for structural sync
|
||
try:
|
||
local_mat = source_node.get_mat()
|
||
except Exception:
|
||
local_mat = source_node.getMat()
|
||
self._cache_top_level_source_child_base_mat(source_node, local_mat)
|
||
|
||
# Mark as synced for the next incremental update
|
||
self._runtime_owner_base_mats[owner_key] = LMatrix4f(current_net_mat)
|
||
synced += 1
|
||
except Exception as e:
|
||
print(f"[SSBO] Snapshot failed for {owner_key}: {e}")
|
||
continue
|
||
return synced
|
||
|
||
def _snapshot_runtime_materials_to_source_root(self):
|
||
"""Persist current runtime material tags back into the source scene tree."""
|
||
controller = getattr(self, "controller", None)
|
||
if not controller or not self.model or not self.source_model_root:
|
||
return 0
|
||
|
||
id_to_object_np = getattr(controller, "id_to_object_np", {}) or {}
|
||
id_to_name = getattr(controller, "id_to_name", {}) or {}
|
||
if not id_to_object_np or not id_to_name:
|
||
return 0
|
||
|
||
synced = 0
|
||
material_tag_prefixes = ("material_", "scene_material_")
|
||
|
||
# We need to find all unique owner keys and their corresponding runtime nodes
|
||
# that actually hold the updated material tags.
|
||
owner_to_runtime = {}
|
||
for global_id, obj_np in id_to_object_np.items():
|
||
if not self._node_is_valid(obj_np):
|
||
continue
|
||
owner_key = str(id_to_name.get(global_id, "") or "").strip()
|
||
if not owner_key or owner_key == getattr(controller, "tree_root_key", None):
|
||
continue
|
||
|
||
# If multiple objects share an owner key, any of them having a dirty material tag
|
||
# should probably work, but we take the first one or one that is marked dirty.
|
||
if owner_key not in owner_to_runtime:
|
||
owner_to_runtime[owner_key] = obj_np
|
||
elif obj_np.hasTag("scene_material_dirty") and obj_np.getTag("scene_material_dirty").lower() == "true":
|
||
owner_to_runtime[owner_key] = obj_np
|
||
|
||
for owner_key, runtime_node in owner_to_runtime.items():
|
||
source_node = self._resolve_source_node_by_tree_key(owner_key)
|
||
if not self._node_is_valid(source_node):
|
||
continue
|
||
|
||
# Check if runtime node has any material tags to sync
|
||
tags_to_sync = {}
|
||
has_dirty = False
|
||
for tag_key in runtime_node.getTagKeys():
|
||
if any(tag_key.startswith(p) for p in material_tag_prefixes):
|
||
tags_to_sync[tag_key] = runtime_node.getTag(tag_key)
|
||
if tag_key == "scene_material_dirty" and tags_to_sync[tag_key].lower() == "true":
|
||
has_dirty = True
|
||
|
||
# Even if not explicitly marked dirty, if it has material tags, we sync them.
|
||
if tags_to_sync:
|
||
for t_key, t_val in tags_to_sync.items():
|
||
source_node.setTag(t_key, t_val)
|
||
synced += 1
|
||
|
||
return synced
|
||
|
||
def _snapshot_model_root_transform_to_source_root(self):
|
||
"""Apply only the aggregated runtime-root delta onto top-level source children."""
|
||
if not self.controller or not self.model or not self.source_model_root:
|
||
return False
|
||
|
||
# Persist whole-model transforms that live on the aggregated runtime root.
|
||
# Child/object sync above only captures transforms relative to self.model,
|
||
# so moving the whole imported model root would otherwise be lost on save.
|
||
model_root_mat = None
|
||
try:
|
||
model_root_mat = LMatrix4f(self.model.get_mat(self.base.render))
|
||
except Exception:
|
||
try:
|
||
model_root_mat = LMatrix4f(self.model.getMat(self.base.render))
|
||
except Exception:
|
||
model_root_mat = None
|
||
|
||
if model_root_mat is None:
|
||
return False
|
||
|
||
source_children = self._get_source_root_children()
|
||
if not source_children:
|
||
return False
|
||
|
||
# Single imported model: the editor manipulates self.model directly.
|
||
# Persist that absolute root transform straight onto the only top-level
|
||
# source child. Using delta composition here loses the saved root pose
|
||
# after reopen because there is no sibling model to preserve relative to.
|
||
if len(source_children) == 1 and self._node_is_valid(source_children[0]):
|
||
source_child = source_children[0]
|
||
try:
|
||
source_child.set_mat(model_root_mat)
|
||
source_child.setTag("scene_transform_dirty", "true")
|
||
self._cache_top_level_source_child_base_mat(source_child, model_root_mat)
|
||
self._model_root_last_snapshot_mat = LMatrix4f(model_root_mat)
|
||
return True
|
||
except Exception:
|
||
try:
|
||
source_child.setMat(model_root_mat)
|
||
source_child.setTag("scene_transform_dirty", "true")
|
||
self._cache_top_level_source_child_base_mat(source_child, model_root_mat)
|
||
self._model_root_last_snapshot_mat = LMatrix4f(model_root_mat)
|
||
return True
|
||
except Exception:
|
||
return False
|
||
|
||
previous_root_mat = getattr(self, "_model_root_last_snapshot_mat", None)
|
||
if previous_root_mat is None:
|
||
previous_root_mat = LMatrix4f.ident_mat()
|
||
|
||
model_root_delta = LMatrix4f(previous_root_mat)
|
||
try:
|
||
model_root_delta.invertInPlace()
|
||
except Exception:
|
||
try:
|
||
model_root_delta.invert_in_place()
|
||
except Exception:
|
||
return False
|
||
model_root_delta *= model_root_mat
|
||
|
||
applied = False
|
||
|
||
for source_child in source_children:
|
||
if not self._node_is_valid(source_child):
|
||
continue
|
||
try:
|
||
composed_mat = LMatrix4f(source_child.get_mat())
|
||
except Exception:
|
||
try:
|
||
composed_mat = LMatrix4f(source_child.getMat())
|
||
except Exception:
|
||
continue
|
||
composed_mat *= model_root_delta
|
||
try:
|
||
source_child.set_mat(composed_mat)
|
||
source_child.setTag("scene_transform_dirty", "true")
|
||
self._cache_top_level_source_child_base_mat(source_child, composed_mat)
|
||
applied = True
|
||
except Exception:
|
||
try:
|
||
source_child.setMat(composed_mat)
|
||
source_child.setTag("scene_transform_dirty", "true")
|
||
self._cache_top_level_source_child_base_mat(source_child, composed_mat)
|
||
applied = True
|
||
except Exception:
|
||
continue
|
||
if applied:
|
||
self._model_root_last_snapshot_mat = LMatrix4f(model_root_mat)
|
||
return applied
|
||
|
||
def _cache_top_level_source_child_base_mat(self, source_node, local_mat=None):
|
||
"""Keep top-level source-child baselines in sync with explicit subtree edits."""
|
||
if not self._node_is_valid(source_node) or not self._node_is_valid(self.source_model_root):
|
||
return False
|
||
|
||
try:
|
||
source_parent = source_node.get_parent()
|
||
except Exception:
|
||
try:
|
||
source_parent = source_node.getParent()
|
||
except Exception:
|
||
return False
|
||
|
||
if source_parent != self.source_model_root:
|
||
return False
|
||
|
||
child_name = self._get_node_name(source_node, None)
|
||
if not child_name:
|
||
return False
|
||
|
||
if local_mat is None:
|
||
try:
|
||
local_mat = LMatrix4f(source_node.get_mat())
|
||
except Exception:
|
||
try:
|
||
local_mat = LMatrix4f(source_node.getMat())
|
||
except Exception:
|
||
return False
|
||
else:
|
||
local_mat = LMatrix4f(local_mat)
|
||
|
||
self._source_child_base_mats[child_name] = local_mat
|
||
return True
|
||
|
||
def _snapshot_active_selection_transform_to_source(self):
|
||
"""Persist only the actively edited selection back into the source tree."""
|
||
if not self.controller or not self.model or not self.source_model_root:
|
||
return False
|
||
|
||
selected_key = self.selected_name
|
||
root_key = getattr(self.controller, "tree_root_key", None)
|
||
if not selected_key or selected_key == root_key:
|
||
return False
|
||
|
||
normalized_top_key = self._selection_equivalent_top_level_key(selected_key)
|
||
if normalized_top_key:
|
||
selected_key = normalized_top_key
|
||
|
||
scene_node = self.get_selection_scene_node()
|
||
source_node = self.get_selection_source_node()
|
||
if normalized_top_key:
|
||
normalized_source_node = self._resolve_source_node_by_tree_key(normalized_top_key)
|
||
if self._node_is_valid(normalized_source_node):
|
||
source_node = normalized_source_node
|
||
if not self._node_is_valid(scene_node) or not self._node_is_valid(source_node):
|
||
return False
|
||
|
||
# When a single imported model is selected via the aggregated runtime
|
||
# root, its whole-model transform lives on self.model rather than on the
|
||
# source child itself. Writing self.model's local identity back here
|
||
# would poison the top-level baseline and later structural edits
|
||
# (delete/attach/rebuild) would reapply a stale root transform.
|
||
if (
|
||
scene_node == self.model
|
||
and self._should_use_model_root_for_top_level_selection(selected_key)
|
||
):
|
||
return self._snapshot_model_root_transform_to_source_root()
|
||
|
||
is_top_level_like_selection = bool(
|
||
self._is_top_level_source_child_selection(selected_key)
|
||
or self._is_displayed_top_level_selection(selected_key)
|
||
)
|
||
|
||
# For regular non-root selections, runtime owner-key snapshot is the most
|
||
# reliable and fast path.
|
||
if not is_top_level_like_selection:
|
||
synced = self._snapshot_runtime_transforms_to_source_root()
|
||
if synced > 0:
|
||
return True
|
||
|
||
current_net_mat = None
|
||
proxy = getattr(self, "_group_proxy", None)
|
||
if (
|
||
proxy
|
||
and scene_node == proxy
|
||
and self._group_proxy_initial_mat is not None
|
||
and self._group_proxy_source_initial_net_mat is not None
|
||
):
|
||
try:
|
||
current_proxy_mat = LMatrix4f(proxy.get_mat(self.model))
|
||
except Exception:
|
||
try:
|
||
current_proxy_mat = LMatrix4f(proxy.getMat(self.model))
|
||
except Exception:
|
||
current_proxy_mat = None
|
||
if current_proxy_mat is not None:
|
||
proxy_delta_mat = LMatrix4f(self._group_proxy_initial_mat)
|
||
try:
|
||
proxy_delta_mat.invertInPlace()
|
||
except Exception:
|
||
try:
|
||
proxy_delta_mat.invert_in_place()
|
||
except Exception:
|
||
proxy_delta_mat = None
|
||
if proxy_delta_mat is not None:
|
||
proxy_delta_mat *= current_proxy_mat
|
||
current_net_mat = LMatrix4f(self._group_proxy_source_initial_net_mat)
|
||
current_net_mat *= proxy_delta_mat
|
||
# Make repeated snapshots idempotent until the selection is cleared.
|
||
self._group_proxy_initial_mat = LMatrix4f(current_proxy_mat)
|
||
self._group_proxy_source_initial_net_mat = LMatrix4f(current_net_mat)
|
||
|
||
if current_net_mat is None:
|
||
try:
|
||
current_net_mat = LMatrix4f(scene_node.get_mat(self.model))
|
||
except Exception:
|
||
try:
|
||
current_net_mat = LMatrix4f(scene_node.getMat(self.model))
|
||
except Exception:
|
||
current_net_mat = None
|
||
if current_net_mat is None:
|
||
return False
|
||
|
||
try:
|
||
# Corrected: use Panda3D native world-to-local projection relative to source root
|
||
reference_node = self._get_transform_snapshot_reference_node(source_node)
|
||
source_node.set_mat(reference_node, current_net_mat)
|
||
source_node.setTag("scene_transform_dirty", "true")
|
||
try:
|
||
self._cache_top_level_source_child_base_mat(source_node, source_node.get_mat())
|
||
except Exception:
|
||
try:
|
||
self._cache_top_level_source_child_base_mat(source_node, source_node.getMat())
|
||
except Exception:
|
||
pass
|
||
return True
|
||
except Exception as e:
|
||
print(f"[SSBO] Snapshot failed: {e}")
|
||
return False
|
||
return True
|
||
|
||
def _resolve_source_node_by_tree_key(self, tree_key):
|
||
"""Resolve controller tree key (e.g. 0/1/2) to source_model_root node."""
|
||
if not self.source_model_root or not tree_key:
|
||
return None
|
||
parts = str(tree_key).split("/")
|
||
if not parts or parts[0] != "0":
|
||
return None
|
||
node = self.source_model_root
|
||
for part in parts[1:]:
|
||
try:
|
||
child_index = int(part)
|
||
except Exception:
|
||
return None
|
||
try:
|
||
node = node.get_child(child_index)
|
||
except Exception:
|
||
try:
|
||
node = node.getChild(child_index)
|
||
except Exception:
|
||
return None
|
||
if not self._node_is_valid(node):
|
||
return None
|
||
return node
|
||
|
||
def _is_node_in_subtree(self, node, subtree_root):
|
||
if not self._node_is_valid(node) or not self._node_is_valid(subtree_root):
|
||
return False
|
||
current = node
|
||
while self._node_is_valid(current):
|
||
if current == subtree_root:
|
||
return True
|
||
try:
|
||
current = current.get_parent()
|
||
except Exception:
|
||
try:
|
||
current = current.getParent()
|
||
except Exception:
|
||
return False
|
||
return False
|
||
|
||
def _get_transform_snapshot_reference_node(self, source_node):
|
||
"""
|
||
Pick the correct reference node when snapshotting runtime transforms.
|
||
|
||
In the single-top-level-model path, the runtime moves that only top-level
|
||
child transform onto self.model. Descendant runtime matrices are then
|
||
relative to the sole source child, not to source_model_root. Saving those
|
||
descendants against source_model_root bakes the inverse root transform into
|
||
children, so reopening restores children but loses the whole-model pose.
|
||
"""
|
||
source_root = self.source_model_root
|
||
if not self._node_is_valid(source_node) or not self._node_is_valid(source_root):
|
||
return source_root
|
||
|
||
source_children = self._get_source_root_children()
|
||
if len(source_children) != 1 or not self._node_is_valid(source_children[0]):
|
||
return source_root
|
||
|
||
sole_source_child = source_children[0]
|
||
if source_node == sole_source_child:
|
||
return source_root
|
||
|
||
if self._is_node_in_subtree(source_node, sole_source_child):
|
||
return sole_source_child
|
||
return source_root
|
||
|
||
def _resolve_tree_key_for_source_node(self, node):
|
||
"""Resolve a source-tree NodePath back to the controller tree key."""
|
||
source_root = self._ensure_source_model_root()
|
||
if not self._node_is_valid(node) or not self._node_is_valid(source_root):
|
||
return None
|
||
if node == source_root:
|
||
return getattr(self.controller, "tree_root_key", "0") if self.controller else "0"
|
||
|
||
parts = []
|
||
current = node
|
||
while self._node_is_valid(current) and current != source_root:
|
||
try:
|
||
parent = current.get_parent()
|
||
except Exception:
|
||
try:
|
||
parent = current.getParent()
|
||
except Exception:
|
||
return None
|
||
if not self._node_is_valid(parent):
|
||
return None
|
||
|
||
child_index = None
|
||
children = self._iter_children(parent)
|
||
for index, child in enumerate(children):
|
||
if child == current:
|
||
child_index = index
|
||
break
|
||
if child_index is None:
|
||
return None
|
||
parts.append(str(child_index))
|
||
current = parent
|
||
|
||
if current != source_root:
|
||
return None
|
||
parts.reverse()
|
||
root_key = getattr(self.controller, "tree_root_key", "0") if self.controller else "0"
|
||
return "/".join([root_key] + parts) if parts else root_key
|
||
|
||
def sync_runtime_material_from_source_node(self, source_node):
|
||
"""Update only the runtime objects owned by the given source node."""
|
||
if not self.controller or not self._node_is_valid(source_node):
|
||
return False
|
||
|
||
owner_key = ""
|
||
try:
|
||
owner_key = str(source_node.getTag("imported_node_key") or "").strip()
|
||
except Exception:
|
||
owner_key = ""
|
||
if not owner_key:
|
||
owner_key = self._resolve_tree_key_for_source_node(source_node) or ""
|
||
if not owner_key:
|
||
return False
|
||
|
||
property_helpers = getattr(self.world, "property_helpers", None) if getattr(self, "world", None) else None
|
||
if not property_helpers:
|
||
return False
|
||
|
||
get_material_fn = getattr(property_helpers, "_get_renderable_node_material", None)
|
||
ensure_material_fn = getattr(property_helpers, "_ensure_material_for_node", None)
|
||
clone_material_fn = getattr(property_helpers, "_clone_material_for_node", None)
|
||
apply_geom_fn = getattr(property_helpers, "_apply_material_to_geom_states", None)
|
||
apply_surface_fn = getattr(property_helpers, "_apply_material_surface_state", None)
|
||
refresh_pipeline_fn = getattr(property_helpers, "_refresh_pipeline_material_mode", None)
|
||
|
||
material = get_material_fn(source_node) if callable(get_material_fn) else None
|
||
if material is None and callable(ensure_material_fn):
|
||
material = ensure_material_fn(source_node)
|
||
if material is None:
|
||
return False
|
||
|
||
target_ids = []
|
||
try:
|
||
current_source_node = self.get_selection_source_material_node()
|
||
except Exception:
|
||
current_source_node = None
|
||
if self._node_is_valid(current_source_node) and current_source_node == source_node:
|
||
target_ids = list(getattr(self, "selected_ids", []) or [])
|
||
if not target_ids:
|
||
target_ids = [
|
||
gid
|
||
for gid in getattr(self.controller, "id_to_object_np", {}).keys()
|
||
if self.controller.id_to_name.get(gid) == owner_key
|
||
]
|
||
|
||
updated = False
|
||
for gid in target_ids:
|
||
obj_np = getattr(self.controller, "id_to_object_np", {}).get(gid)
|
||
if not self._node_is_valid(obj_np):
|
||
continue
|
||
|
||
runtime_material = material
|
||
if callable(clone_material_fn):
|
||
try:
|
||
runtime_material = clone_material_fn(material, obj_np)
|
||
except Exception:
|
||
runtime_material = material
|
||
|
||
if callable(apply_geom_fn):
|
||
try:
|
||
apply_geom_fn(obj_np, runtime_material)
|
||
except Exception:
|
||
pass
|
||
if callable(apply_surface_fn):
|
||
try:
|
||
apply_surface_fn(obj_np, runtime_material)
|
||
except Exception:
|
||
pass
|
||
if callable(refresh_pipeline_fn):
|
||
try:
|
||
refresh_pipeline_fn(obj_np, runtime_material)
|
||
except Exception:
|
||
pass
|
||
updated = True
|
||
|
||
return updated
|
||
|
||
def _resolve_tree_key_for_source_node(self, node):
|
||
"""Resolve a source-tree NodePath back to its controller tree key."""
|
||
if not self._node_is_valid(node) or not self._node_is_valid(self.source_model_root):
|
||
return None
|
||
if node == self.source_model_root:
|
||
return getattr(self.controller, "tree_root_key", None) or "0"
|
||
|
||
indices = []
|
||
current = node
|
||
while self._node_is_valid(current) and current != self.source_model_root:
|
||
try:
|
||
parent = current.get_parent()
|
||
except Exception:
|
||
try:
|
||
parent = current.getParent()
|
||
except Exception:
|
||
return None
|
||
if not self._node_is_valid(parent):
|
||
return None
|
||
|
||
child_index = None
|
||
for idx, child in enumerate(self._iter_children(parent)):
|
||
if child == current:
|
||
child_index = idx
|
||
break
|
||
if child_index is None:
|
||
return None
|
||
indices.append(str(child_index))
|
||
current = parent
|
||
|
||
if current != self.source_model_root:
|
||
return None
|
||
indices.reverse()
|
||
return "0/" + "/".join(indices) if indices else "0"
|
||
|
||
def sync_runtime_material_from_source_node(self, source_node):
|
||
"""Push one source-node material change into matching runtime objects only."""
|
||
if not self.controller or not self._node_is_valid(source_node):
|
||
return False
|
||
if not self.is_source_tree_node(source_node):
|
||
return False
|
||
|
||
owner_key = self._resolve_tree_key_for_source_node(source_node)
|
||
if not owner_key:
|
||
return False
|
||
|
||
property_helpers = getattr(self.world, "property_helpers", None) if getattr(self, "world", None) else None
|
||
if property_helpers is None:
|
||
return False
|
||
|
||
get_material_fn = getattr(property_helpers, "_get_renderable_node_material", None)
|
||
ensure_material_fn = getattr(property_helpers, "_ensure_material_for_node", None)
|
||
clone_material_fn = getattr(property_helpers, "_clone_material_for_node", None)
|
||
apply_geom_fn = getattr(property_helpers, "_apply_material_to_geom_states", None)
|
||
apply_surface_fn = getattr(property_helpers, "_apply_material_surface_state", None)
|
||
refresh_pipeline_fn = getattr(property_helpers, "_refresh_pipeline_material_mode", None)
|
||
if not callable(apply_geom_fn) or not callable(apply_surface_fn):
|
||
return False
|
||
|
||
material = None
|
||
if callable(get_material_fn):
|
||
try:
|
||
material = get_material_fn(source_node)
|
||
except Exception:
|
||
material = None
|
||
if material is None and callable(ensure_material_fn):
|
||
try:
|
||
material = ensure_material_fn(source_node)
|
||
except Exception:
|
||
material = None
|
||
if material is None:
|
||
return False
|
||
|
||
matched = False
|
||
for gid, obj_np in (self.controller.id_to_object_np or {}).items():
|
||
try:
|
||
if self.controller.id_to_name.get(gid) != owner_key:
|
||
continue
|
||
except Exception:
|
||
continue
|
||
if not self._node_is_valid(obj_np):
|
||
continue
|
||
runtime_material = material
|
||
if callable(clone_material_fn):
|
||
try:
|
||
runtime_material = clone_material_fn(material, obj_np)
|
||
except Exception:
|
||
runtime_material = material
|
||
try:
|
||
apply_geom_fn(obj_np, runtime_material)
|
||
apply_surface_fn(obj_np, runtime_material)
|
||
if callable(refresh_pipeline_fn):
|
||
refresh_pipeline_fn(obj_np, runtime_material)
|
||
matched = True
|
||
except Exception:
|
||
continue
|
||
return matched
|
||
|
||
def _snapshot_runtime_materials_to_source_root(self):
|
||
"""
|
||
Persist runtime-edited material/geom render state back to source_model_root.
|
||
This keeps project save/load consistent for SSBO editing workflow.
|
||
"""
|
||
controller = self.controller
|
||
if not controller or not self.source_model_root:
|
||
return
|
||
|
||
synced = 0
|
||
effect_tags_synced = set()
|
||
root_effect_tags = {}
|
||
property_helpers = getattr(self.world, "property_helpers", None) if getattr(self, "world", None) else None
|
||
capture_snapshot_fn = getattr(property_helpers, "_capture_node_material_snapshot", None) if property_helpers else None
|
||
normalize_snapshot_fn = getattr(property_helpers, "_normalize_material_snapshot", None) if property_helpers else None
|
||
apply_snapshot_fn = getattr(property_helpers, "_apply_node_material_snapshot", None) if property_helpers else None
|
||
get_materials_fn = getattr(property_helpers, "_get_node_materials", None) if property_helpers else None
|
||
ensure_material_fn = getattr(property_helpers, "_ensure_material_for_node", None) if property_helpers else None
|
||
try:
|
||
model_root = self.model
|
||
if model_root and not model_root.is_empty():
|
||
for tag_name in (
|
||
"material_effect_metallic_enabled",
|
||
"material_effect_default_texture_enabled",
|
||
"material_effect_parallax_enabled",
|
||
"material_render_effect_signature",
|
||
):
|
||
if model_root.hasTag(tag_name):
|
||
root_effect_tags[tag_name] = model_root.getTag(tag_name)
|
||
except Exception:
|
||
root_effect_tags = {}
|
||
|
||
def _node_has_metallic_texture(node_np):
|
||
try:
|
||
stages = node_np.findAllTextureStages()
|
||
for i in range(stages.getNumTextureStages()):
|
||
stage = stages.getTextureStage(i)
|
||
if not stage:
|
||
continue
|
||
try:
|
||
sname = (stage.getName() or "").lower()
|
||
except Exception:
|
||
sname = ""
|
||
# convention in project helpers and RP metallic workflow
|
||
if "metallic" in sname or sname == "p3d_texture5":
|
||
return True
|
||
except Exception:
|
||
pass
|
||
return False
|
||
|
||
def _clone_snapshot_for_target(source_snapshot, target_node):
|
||
if not callable(normalize_snapshot_fn):
|
||
return None
|
||
snapshot = normalize_snapshot_fn(source_snapshot)
|
||
if snapshot is None:
|
||
return None
|
||
|
||
target_materials = []
|
||
try:
|
||
if callable(get_materials_fn):
|
||
target_materials = list(get_materials_fn(target_node) or [])
|
||
except Exception:
|
||
target_materials = []
|
||
if not target_materials and callable(ensure_material_fn):
|
||
try:
|
||
fallback = ensure_material_fn(target_node)
|
||
if fallback is not None:
|
||
target_materials = [fallback]
|
||
except Exception:
|
||
target_materials = []
|
||
|
||
source_entries = snapshot.get("materials", []) or []
|
||
cloned_entries = []
|
||
for idx, entry in enumerate(source_entries):
|
||
target_material = target_materials[idx] if idx < len(target_materials) else None
|
||
cloned_entries.append({
|
||
"material": target_material,
|
||
"base_color": entry.get("base_color"),
|
||
"roughness": entry.get("roughness"),
|
||
"metallic": entry.get("metallic"),
|
||
"ior": entry.get("ior"),
|
||
"emission": entry.get("emission"),
|
||
})
|
||
|
||
node_state = snapshot.get("node_state", {}) or {}
|
||
textures = dict(node_state.get("textures", {}) or {})
|
||
effect_tags = dict(node_state.get("effect_tags", {}) or {})
|
||
|
||
return {
|
||
"materials": cloned_entries,
|
||
"node_state": {
|
||
"textures": textures,
|
||
"effect_tags": effect_tags,
|
||
},
|
||
}
|
||
|
||
grouped_entries = {}
|
||
|
||
def _snapshot_score(snapshot, obj_np):
|
||
score = 0
|
||
try:
|
||
snapshot = normalize_snapshot_fn(snapshot) if callable(normalize_snapshot_fn) else snapshot
|
||
except Exception:
|
||
pass
|
||
if isinstance(snapshot, dict):
|
||
node_state = snapshot.get("node_state", {}) or {}
|
||
textures = node_state.get("textures", {}) or {}
|
||
effect_tags = node_state.get("effect_tags", {}) or {}
|
||
score += len([value for value in textures.values() if value]) * 100
|
||
score += len([value for value in effect_tags.values() if value]) * 50
|
||
for entry in snapshot.get("materials", []) or []:
|
||
if entry.get("base_color") is not None:
|
||
score += 5
|
||
for scalar_name in ("roughness", "metallic", "ior"):
|
||
if entry.get(scalar_name) is not None:
|
||
score += 3
|
||
if entry.get("emission") is not None:
|
||
score += 2
|
||
try:
|
||
if _node_has_metallic_texture(obj_np):
|
||
score += 25
|
||
except Exception:
|
||
pass
|
||
return score
|
||
|
||
for gid, obj_np in controller.id_to_object_np.items():
|
||
if not self._node_is_valid(obj_np):
|
||
continue
|
||
owner_key = controller.id_to_name.get(gid)
|
||
if not owner_key:
|
||
continue
|
||
source_node = self._resolve_source_node_by_tree_key(owner_key)
|
||
if not self._node_is_valid(source_node):
|
||
continue
|
||
|
||
runtime_snapshot = None
|
||
if callable(capture_snapshot_fn):
|
||
try:
|
||
runtime_snapshot = capture_snapshot_fn(obj_np)
|
||
except Exception:
|
||
runtime_snapshot = None
|
||
|
||
source_snapshot = None
|
||
if callable(capture_snapshot_fn):
|
||
try:
|
||
source_snapshot = capture_snapshot_fn(source_node)
|
||
except Exception:
|
||
source_snapshot = None
|
||
|
||
source_node_key = id(source_node)
|
||
entry = grouped_entries.get(source_node_key)
|
||
runtime_score = _snapshot_score(runtime_snapshot, obj_np)
|
||
source_score = _snapshot_score(source_snapshot, source_node)
|
||
# Saving should prefer the visible runtime state on ties; otherwise a
|
||
# stale source snapshot can overwrite a freshly edited child material.
|
||
if runtime_snapshot is not None and runtime_score >= source_score:
|
||
chosen_snapshot = runtime_snapshot
|
||
else:
|
||
chosen_snapshot = source_snapshot
|
||
candidate_score = max(runtime_score, source_score)
|
||
if entry is None or candidate_score > entry["score"]:
|
||
grouped_entries[source_node_key] = {
|
||
"gid": gid,
|
||
"obj_np": obj_np,
|
||
"source_node": source_node,
|
||
"snapshot": chosen_snapshot,
|
||
"score": candidate_score,
|
||
}
|
||
|
||
for source_node_key, entry in grouped_entries.items():
|
||
gid = entry["gid"]
|
||
obj_np = entry["obj_np"]
|
||
source_node = entry["source_node"]
|
||
source_snapshot = entry["snapshot"]
|
||
|
||
if source_node_key not in effect_tags_synced:
|
||
inferred_metallic = _node_has_metallic_texture(obj_np)
|
||
for tag_name in (
|
||
"material_effect_metallic_enabled",
|
||
"material_effect_default_texture_enabled",
|
||
"material_effect_parallax_enabled",
|
||
"material_render_effect_signature",
|
||
):
|
||
try:
|
||
if obj_np.hasTag(tag_name):
|
||
source_node.setTag(tag_name, obj_np.getTag(tag_name))
|
||
elif tag_name == "material_effect_metallic_enabled" and inferred_metallic:
|
||
source_node.setTag(tag_name, "1")
|
||
elif tag_name in root_effect_tags:
|
||
source_node.setTag(tag_name, root_effect_tags[tag_name])
|
||
except Exception:
|
||
pass
|
||
texture_slot_tags = (
|
||
"material_texture_diffuse",
|
||
"material_texture_normal",
|
||
"material_texture_ior",
|
||
"material_texture_roughness",
|
||
"material_texture_parallax",
|
||
"material_texture_metallic",
|
||
"material_texture_emission",
|
||
"material_texture_ao",
|
||
"material_texture_alpha",
|
||
"material_texture_detail",
|
||
"material_texture_gloss",
|
||
)
|
||
for tag_name in texture_slot_tags:
|
||
try:
|
||
if obj_np.hasTag(tag_name):
|
||
source_node.setTag(tag_name, obj_np.getTag(tag_name))
|
||
elif source_node.hasTag(tag_name):
|
||
source_node.clearTag(tag_name)
|
||
except Exception:
|
||
pass
|
||
effect_tags_synced.add(source_node_key)
|
||
|
||
if source_snapshot is not None and callable(apply_snapshot_fn):
|
||
try:
|
||
target_snapshot = _clone_snapshot_for_target(source_snapshot, source_node)
|
||
if target_snapshot is not None:
|
||
apply_snapshot_fn(source_node, target_snapshot)
|
||
source_node.setTag("scene_material_dirty", "true")
|
||
synced += 1
|
||
continue
|
||
except Exception:
|
||
pass
|
||
|
||
runtime_geom_state = None
|
||
try:
|
||
geom_paths = obj_np.findAllMatches("**/+GeomNode")
|
||
if geom_paths and geom_paths.getNumPaths() > 0:
|
||
runtime_geom_state = geom_paths.getPath(0).getNetState()
|
||
except Exception:
|
||
runtime_geom_state = None
|
||
if runtime_geom_state is None:
|
||
continue
|
||
|
||
try:
|
||
src_gnode = source_node.node()
|
||
set_src_state = getattr(src_gnode, "set_geom_state", None) or getattr(src_gnode, "setGeomState", None)
|
||
get_src_count = getattr(src_gnode, "get_num_geoms", None) or getattr(src_gnode, "getNumGeoms", None)
|
||
src_geom_count = int(get_src_count()) if callable(get_src_count) else 0
|
||
except Exception:
|
||
continue
|
||
|
||
src_geom_index = controller.id_to_geom_index.get(gid, 0)
|
||
if src_geom_index < 0 or src_geom_index >= src_geom_count:
|
||
continue
|
||
|
||
try:
|
||
if callable(set_src_state):
|
||
set_src_state(src_geom_index, runtime_geom_state)
|
||
source_node.setTag("scene_material_dirty", "true")
|
||
synced += 1
|
||
except Exception:
|
||
continue
|
||
|
||
if synced:
|
||
print(f"[SSBOEditor] Synced runtime material states back to source tree: {synced}")
|
||
|
||
def _restore_saved_material_bindings_from_tags(self, root_np):
|
||
"""Rebind saved texture/effect tags back onto loaded source nodes."""
|
||
if not self._node_is_valid(root_np):
|
||
return 0
|
||
|
||
property_helpers = getattr(self.base, "property_helpers", None)
|
||
capture_snapshot_fn = getattr(property_helpers, "_capture_node_material_snapshot", None) if property_helpers else None
|
||
apply_snapshot_fn = getattr(property_helpers, "_apply_node_material_snapshot", None) if property_helpers else None
|
||
texture_slots_fn = getattr(property_helpers, "_get_material_texture_slots", None) if property_helpers else None
|
||
if not callable(capture_snapshot_fn) or not callable(apply_snapshot_fn):
|
||
return 0
|
||
|
||
texture_types = []
|
||
if callable(texture_slots_fn):
|
||
try:
|
||
texture_types = list((texture_slots_fn() or {}).keys())
|
||
except Exception:
|
||
texture_types = []
|
||
if not texture_types:
|
||
texture_types = [
|
||
"diffuse", "normal", "ior", "roughness", "parallax",
|
||
"metallic", "emission", "ao", "alpha", "detail", "gloss",
|
||
]
|
||
|
||
effect_tag_names = (
|
||
"material_effect_metallic_enabled",
|
||
"material_effect_default_texture_enabled",
|
||
"material_effect_parallax_enabled",
|
||
"material_render_effect_signature",
|
||
)
|
||
|
||
restored = 0
|
||
try:
|
||
descendant_nodes = list(root_np.find_all_matches("**"))
|
||
except Exception:
|
||
try:
|
||
descendant_nodes = list(root_np.findAllMatches("**"))
|
||
except Exception:
|
||
descendant_nodes = []
|
||
|
||
for node in [root_np] + descendant_nodes:
|
||
if not self._node_is_valid(node):
|
||
continue
|
||
|
||
has_texture_tags = any(node.hasTag(f"material_texture_{texture_type}") for texture_type in texture_types)
|
||
has_effect_tags = any(node.hasTag(tag_name) for tag_name in effect_tag_names)
|
||
if not (has_texture_tags or has_effect_tags):
|
||
continue
|
||
|
||
try:
|
||
snapshot = capture_snapshot_fn(node)
|
||
except Exception:
|
||
snapshot = None
|
||
if not snapshot:
|
||
continue
|
||
|
||
try:
|
||
apply_snapshot_fn(node, snapshot)
|
||
restored += 1
|
||
except Exception:
|
||
continue
|
||
|
||
if restored:
|
||
print(f"[SSBOEditor] Restored saved material bindings from tags: {restored}")
|
||
return restored
|
||
|
||
def _clear_runtime_state(self, preserve_source_models=False, snapshot_transform=True):
|
||
"""Remove runtime SSBO controller/model state while optionally keeping source snapshots."""
|
||
self.clear_selection(snapshot_transform=snapshot_transform)
|
||
self._cleanup_group_proxy()
|
||
self._reset_pick_sync_cache()
|
||
self._teardown_gpu_picking()
|
||
|
||
controller = self.controller
|
||
pick_model = getattr(controller, "pick_model", None) if controller else None
|
||
model = self.model
|
||
|
||
removable_nodes = [pick_model, model]
|
||
if not preserve_source_models:
|
||
removable_nodes.extend([self.source_model, self.source_model_root])
|
||
|
||
for node in removable_nodes:
|
||
if not node:
|
||
continue
|
||
try:
|
||
if not node.is_empty():
|
||
node.remove_node()
|
||
except Exception:
|
||
try:
|
||
if not node.isEmpty():
|
||
node.removeNode()
|
||
except Exception:
|
||
pass
|
||
|
||
self.controller = None
|
||
self.model = None
|
||
self.selected_name = None
|
||
self.selected_ids = []
|
||
self.transform_ids = []
|
||
self.last_import_tree_key = None
|
||
self.last_import_root_name = None
|
||
self._model_root_last_snapshot_mat = LMatrix4f.ident_mat()
|
||
self._runtime_owner_base_mats = {}
|
||
if not preserve_source_models:
|
||
self.source_model = None
|
||
self.source_model_root = None
|
||
self._source_child_base_mats = {}
|
||
self._sync_pick_scene_binding()
|
||
|
||
def _get_source_root_children(self):
|
||
root = self.source_model_root
|
||
if not root:
|
||
return []
|
||
return [child for child in self._iter_children(root) if self._node_is_valid(child)]
|
||
|
||
def _rebuild_or_clear_runtime_from_current_source(self, highlight_root_name=None):
|
||
if self._get_source_root_children():
|
||
self.source_model = self.source_model_root
|
||
self._rebuild_runtime_from_source_root(highlight_root_name=highlight_root_name)
|
||
return self.model
|
||
|
||
self.last_import_tree_key = None
|
||
self.last_import_root_name = None
|
||
self.source_model = self.source_model_root
|
||
self._sync_pick_scene_binding()
|
||
return None
|
||
|
||
def find_source_child_by_name(self, child_name):
|
||
if not child_name:
|
||
return None
|
||
for child in self._get_source_root_children():
|
||
if self._get_node_name(child) == child_name:
|
||
return child
|
||
return None
|
||
|
||
def detach_source_child(self, child_name=None, child_np=None):
|
||
target = child_np if self._node_is_valid(child_np) else self.find_source_child_by_name(child_name)
|
||
if not self._node_is_valid(target):
|
||
return None
|
||
|
||
if self.controller and self.model:
|
||
self._snapshot_top_level_transforms_to_source_root()
|
||
self._clear_runtime_state(preserve_source_models=True, snapshot_transform=False)
|
||
|
||
try:
|
||
target.detach_node()
|
||
except Exception:
|
||
try:
|
||
target.detachNode()
|
||
except Exception:
|
||
return None
|
||
|
||
self._rebuild_or_clear_runtime_from_current_source()
|
||
return target
|
||
|
||
def delete_selected_source_node(self):
|
||
"""Delete the current SSBO selection from source_model_root and rebuild runtime."""
|
||
if not self.controller or self.selected_name is None:
|
||
return False
|
||
|
||
target = self._resolve_source_node_by_tree_key(self.selected_name)
|
||
if not self._node_is_valid(target):
|
||
return False
|
||
|
||
source_root = self._ensure_source_model_root()
|
||
if target == source_root:
|
||
children = self._get_source_root_children()
|
||
if not children:
|
||
return False
|
||
if self.controller and self.model:
|
||
self._snapshot_top_level_transforms_to_source_root()
|
||
self._clear_runtime_state(preserve_source_models=True, snapshot_transform=False)
|
||
for child in children:
|
||
try:
|
||
child.detach_node()
|
||
except Exception:
|
||
try:
|
||
child.detachNode()
|
||
except Exception:
|
||
continue
|
||
self.clear_selection(sync_world_selection=False, snapshot_transform=False)
|
||
self._rebuild_or_clear_runtime_from_current_source()
|
||
return True
|
||
|
||
if self.controller and self.model:
|
||
self._snapshot_top_level_transforms_to_source_root()
|
||
self._clear_runtime_state(preserve_source_models=True, snapshot_transform=False)
|
||
try:
|
||
target.detach_node()
|
||
except Exception:
|
||
try:
|
||
target.detachNode()
|
||
except Exception:
|
||
return False
|
||
|
||
self.clear_selection(sync_world_selection=False, snapshot_transform=False)
|
||
self._rebuild_or_clear_runtime_from_current_source()
|
||
return True
|
||
|
||
def attach_source_child(self, child_np, highlight_root_name=None):
|
||
if not self._node_is_valid(child_np):
|
||
return None
|
||
|
||
if self.controller and self.model:
|
||
self._snapshot_top_level_transforms_to_source_root()
|
||
self._clear_runtime_state(preserve_source_models=True, snapshot_transform=False)
|
||
|
||
source_root = self._ensure_source_model_root()
|
||
target_name = highlight_root_name or self._get_node_name(child_np, "imported_model")
|
||
self._set_node_name(child_np, target_name)
|
||
|
||
try:
|
||
child_np.reparent_to(source_root)
|
||
except Exception:
|
||
try:
|
||
child_np.reparentTo(source_root)
|
||
except Exception:
|
||
return None
|
||
|
||
self._rebuild_or_clear_runtime_from_current_source(highlight_root_name=target_name)
|
||
return self.model
|
||
|
||
def _rebuild_runtime_from_source_root(self, highlight_root_name=None):
|
||
root = self._ensure_source_model_root()
|
||
working_holder = NodePath("ssbo_source_scene_work")
|
||
working_root = root.copy_to(working_holder)
|
||
runtime_root_mat = None
|
||
source_children = self._get_source_root_children()
|
||
if len(source_children) == 1 and self._node_is_valid(source_children[0]):
|
||
try:
|
||
working_children = [child for child in self._iter_children(working_root) if self._node_is_valid(child)]
|
||
except Exception:
|
||
working_children = []
|
||
if len(working_children) == 1 and self._node_is_valid(working_children[0]):
|
||
working_child = working_children[0]
|
||
try:
|
||
runtime_root_mat = LMatrix4f(working_child.get_mat(working_root))
|
||
except Exception:
|
||
try:
|
||
runtime_root_mat = LMatrix4f(working_child.getMat(working_root))
|
||
except Exception:
|
||
runtime_root_mat = None
|
||
if runtime_root_mat is not None:
|
||
try:
|
||
working_child.set_mat(LMatrix4f.ident_mat())
|
||
except Exception:
|
||
try:
|
||
working_child.setMat(LMatrix4f.ident_mat())
|
||
except Exception:
|
||
runtime_root_mat = None
|
||
self.controller = ObjectController()
|
||
try:
|
||
geom_count = len(list(working_root.find_all_matches("**/+GeomNode")))
|
||
except Exception:
|
||
geom_count = 0
|
||
try:
|
||
node_count = len(list(working_root.find_all_matches("**")))
|
||
except Exception:
|
||
node_count = 0
|
||
skip_heavy_material_processing = self._should_skip_heavy_material_processing(
|
||
geom_count=geom_count,
|
||
node_count=node_count,
|
||
)
|
||
if skip_heavy_material_processing:
|
||
print(
|
||
f"[SSBOEditor] Skip heavy material processing for large scene "
|
||
f"(nodes={node_count}, geoms={geom_count})"
|
||
)
|
||
else:
|
||
self._detach_shared_materials_in_subtree(working_root)
|
||
self._materialize_explicit_geom_materials(working_root)
|
||
# Large scenes should prefer the old flat import path.
|
||
# Hybrid mode keeps per-child editing, but for vegetation/campus-like GLB
|
||
# scenes it explodes into tens of thousands of runtime objects/chunks and
|
||
# the editor becomes unusable or crashes.
|
||
# 提高使用 hybrid 模式的阈值。
|
||
# 对于类似 jyc.glb 的场景，hybrid 模式的对象分块（chunks）比一个巨大的 flat 节点拥有更好的剔除性能和帧率。
|
||
# 只有在极端规模（如 > 20000 节点或 > 10000 几何体）的情况下才强制退回到 flat 模式以节省内存。
|
||
prefer_flat_mode = (
|
||
geom_count > 10000
|
||
or node_count > 20000
|
||
)
|
||
use_hybrid_mode = geom_count > 0 and not prefer_flat_mode
|
||
if prefer_flat_mode:
|
||
print(
|
||
f"[SSBOEditor] Large scene uses flat runtime path "
|
||
f"(nodes={node_count}, geoms={geom_count})"
|
||
)
|
||
if use_hybrid_mode:
|
||
count = self.controller.bake_ids_and_collect_hybrid(working_root)
|
||
else:
|
||
count = self.controller.bake_ids_and_collect(
|
||
working_root,
|
||
lightweight=prefer_flat_mode,
|
||
)
|
||
self.model = self.controller.model
|
||
self.model.reparent_to(self.base.render)
|
||
if runtime_root_mat is not None:
|
||
try:
|
||
self.model.set_mat(runtime_root_mat)
|
||
except Exception:
|
||
try:
|
||
self.model.setMat(runtime_root_mat)
|
||
except Exception:
|
||
pass
|
||
self._capture_runtime_owner_base_mats()
|
||
|
||
self.set_realtime_shadow_updates(self.realtime_shadow_updates)
|
||
self.setup_gpu_picking()
|
||
self._sync_pick_model_transform()
|
||
|
||
self.last_import_tree_key = None
|
||
self.last_import_root_name = highlight_root_name
|
||
if highlight_root_name:
|
||
root_key = getattr(self.controller, "tree_root_key", None)
|
||
root_node = self.controller.tree_nodes.get(root_key, {}) if root_key else {}
|
||
for child_key in root_node.get("children", []):
|
||
if self.controller.display_names.get(child_key) == highlight_root_name:
|
||
self.last_import_tree_key = child_key
|
||
break
|
||
|
||
try:
|
||
if not working_holder.is_empty():
|
||
working_holder.remove_node()
|
||
except Exception:
|
||
try:
|
||
if not working_holder.isEmpty():
|
||
working_holder.removeNode()
|
||
except Exception:
|
||
pass
|
||
|
||
mode_name = "hybrid" if use_hybrid_mode else "flat"
|
||
print(f"[SSBOEditor] Model loaded. Total objects: {count}, mode={mode_name}, geoms={geom_count}")
|
||
|
||
def load_model(
|
||
self,
|
||
model_path,
|
||
keep_source_model=False,
|
||
append=False,
|
||
scene_package_import=False,
|
||
rebuild_runtime=True,
|
||
):
|
||
"""Load and process one model into the aggregated SSBO scene."""
|
||
print(f"[SSBOEditor] Loading model: {model_path}")
|
||
skip_heavy_material_processing = self._should_skip_heavy_material_processing(model_path=model_path)
|
||
# scene_package_import: loading saved scene.bam from project.
|
||
# Keep stored material/texture states intact; repair heuristics can
|
||
# misclassify valid packed/relative texture refs and cause dark materials.
|
||
should_repair_textures = (not scene_package_import) and (not skip_heavy_material_processing)
|
||
should_fix_black_materials = (not scene_package_import) and (not skip_heavy_material_processing)
|
||
if skip_heavy_material_processing:
|
||
model_size_mb = self._get_model_file_size(model_path) / (1024.0 * 1024.0)
|
||
print(
|
||
f"[SSBOEditor] Large model fast path enabled for {os.path.basename(model_path)} "
|
||
f"({model_size_mb:.1f} MB)"
|
||
)
|
||
source_model = self._load_source_model_from_path(
|
||
model_path,
|
||
apply_black_fix=should_fix_black_materials,
|
||
repair_textures=should_repair_textures,
|
||
)
|
||
model_name = os.path.basename(model_path)
|
||
if model_name and not scene_package_import:
|
||
self._set_node_name(source_model, model_name)
|
||
|
||
if append and self.source_model_root:
|
||
if self.controller and self.model:
|
||
self._snapshot_top_level_transforms_to_source_root()
|
||
self._clear_runtime_state(preserve_source_models=True, snapshot_transform=False)
|
||
else:
|
||
self._clear_runtime_state(preserve_source_models=False)
|
||
|
||
source_root = self._ensure_source_model_root()
|
||
|
||
# 项目场景包导入(scene.bam)时，避免再包一层 "scene.bam" 根节点，
|
||
# 直接把其顶层子节点并入 source_root，保持场景树与保存时一致。
|
||
if scene_package_import:
|
||
imported_roots = []
|
||
skipped_legacy_roots = 0
|
||
children = []
|
||
try:
|
||
children = [c for c in source_model.get_children() if c and not c.is_empty()]
|
||
except Exception:
|
||
try:
|
||
children = [c for c in source_model.getChildren() if c and not c.isEmpty()]
|
||
except Exception:
|
||
children = []
|
||
|
||
for child in children:
|
||
try:
|
||
child_name = self._get_node_name(child, "")
|
||
if child_name in {"render", "render2d", "aspect2d"}:
|
||
continue
|
||
if self._should_skip_scene_package_child_for_ssbo(child):
|
||
skipped_legacy_roots += 1
|
||
print(f"[SSBOSceneLoad] 跳过普通/动画模型: {child_name}")
|
||
continue
|
||
imported_child = child.copyTo(source_root)
|
||
if not skip_heavy_material_processing:
|
||
self._detach_shared_materials_in_subtree(imported_child)
|
||
imported_child.setTag("ssbo_managed", "true")
|
||
imported_roots.append(imported_child)
|
||
except Exception:
|
||
continue
|
||
|
||
if not imported_roots and skipped_legacy_roots == 0:
|
||
fallback_name = self._get_node_name(source_model, "scene_root")
|
||
unique_root_name = self._make_unique_source_child_name(fallback_name)
|
||
self._set_node_name(source_model, unique_root_name)
|
||
imported_root = source_model.copyTo(source_root)
|
||
self._set_node_name(imported_root, unique_root_name)
|
||
imported_root.setTag("ssbo_managed", "true")
|
||
if not skip_heavy_material_processing:
|
||
self._detach_shared_materials_in_subtree(imported_root)
|
||
imported_roots = [imported_root]
|
||
|
||
self.source_model = source_root
|
||
self._restore_saved_material_bindings_from_tags(source_root)
|
||
self._capture_source_child_base_mats()
|
||
if rebuild_runtime:
|
||
if self._get_source_root_children():
|
||
self._rebuild_runtime_from_source_root(highlight_root_name=None)
|
||
else:
|
||
self._rebuild_or_clear_runtime_from_current_source()
|
||
if len(imported_roots) == 1:
|
||
return imported_roots[0]
|
||
return source_root
|
||
|
||
unique_root_name = self._make_unique_source_child_name(model_name or "imported_model")
|
||
self._set_node_name(source_model, unique_root_name)
|
||
imported_root = source_model.copyTo(source_root)
|
||
self._set_node_name(imported_root, unique_root_name)
|
||
imported_root.setTag("ssbo_managed", "true")
|
||
if not skip_heavy_material_processing:
|
||
self._detach_shared_materials_in_subtree(imported_root)
|
||
|
||
if keep_source_model and not append:
|
||
self.source_model = imported_root
|
||
else:
|
||
self.source_model = source_root
|
||
|
||
self._capture_source_child_base_mats()
|
||
if rebuild_runtime:
|
||
self._rebuild_runtime_from_source_root(highlight_root_name=unique_root_name)
|
||
return imported_root
|
||
|
||
def _build_filename_candidates(self, path_text):
|
||
"""Build Filename candidates with wide-char first for Windows CJK paths."""
|
||
candidates = []
|
||
seen = set()
|
||
for ctor_name in ("fromOsSpecificW", "from_os_specific_w", "fromOsSpecific", "from_os_specific"):
|
||
ctor = getattr(Filename, ctor_name, None)
|
||
if not ctor:
|
||
continue
|
||
try:
|
||
fn = ctor(path_text)
|
||
key = fn.get_fullpath()
|
||
if key in seen:
|
||
continue
|
||
seen.add(key)
|
||
candidates.append(fn)
|
||
except Exception:
|
||
continue
|
||
if not candidates:
|
||
try:
|
||
candidates.append(Filename(path_text))
|
||
except Exception:
|
||
pass
|
||
return candidates
|
||
|
||
def _load_texture_from_path(self, texture_path):
|
||
"""Load texture with robust path constructors."""
|
||
for fn in self._build_filename_candidates(texture_path):
|
||
try:
|
||
tex = self.base.loader.loadTexture(fn)
|
||
if tex:
|
||
return tex
|
||
except Exception:
|
||
continue
|
||
return None
|
||
|
||
def _build_texture_search_dirs(self, model_path):
|
||
"""Build candidate directories for missing texture recovery."""
|
||
dirs = []
|
||
model_dir = os.path.dirname(os.path.abspath(model_path))
|
||
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||
|
||
def add_dir(path):
|
||
if not path:
|
||
return
|
||
path = os.path.normpath(path)
|
||
if path in dirs:
|
||
return
|
||
if os.path.isdir(path):
|
||
dirs.append(path)
|
||
|
||
add_dir(model_dir)
|
||
|
||
try:
|
||
if os.path.isdir(model_dir):
|
||
for item in os.listdir(model_dir):
|
||
if item.lower().endswith('.fbm'):
|
||
fbm_dir = os.path.join(model_dir, item)
|
||
if os.path.isdir(fbm_dir):
|
||
add_dir(fbm_dir)
|
||
for sub in ("textures", "texture", "tex", "assets", "materials"):
|
||
add_dir(os.path.join(fbm_dir, sub))
|
||
except Exception:
|
||
pass
|
||
|
||
for sub in ("textures", "texture", "tex", "assets", "materials"):
|
||
add_dir(os.path.join(model_dir, sub))
|
||
|
||
parent = model_dir
|
||
for _ in range(2):
|
||
parent = os.path.dirname(parent)
|
||
if not parent:
|
||
break
|
||
for sub in ("textures", "texture", "tex", "assets", "materials"):
|
||
add_dir(os.path.join(parent, sub))
|
||
|
||
add_dir(os.path.join(project_root, "Resources"))
|
||
add_dir(os.path.join(project_root, "Resources", "textures"))
|
||
add_dir(os.path.join(project_root, "Resources", "materials"))
|
||
add_dir(os.path.join(project_root, "Resources", "models"))
|
||
return dirs
|
||
|
||
def _index_texture_files(self, dirs, limit=30000):
|
||
"""Index texture files by basename for fast lookup."""
|
||
texture_exts = {".png", ".jpg", ".jpeg", ".tga", ".bmp", ".dds", ".ktx", ".ktx2", ".webp"}
|
||
index = {}
|
||
scanned = 0
|
||
for root_dir in dirs:
|
||
try:
|
||
for root, _, files in os.walk(root_dir):
|
||
for filename in files:
|
||
ext = os.path.splitext(filename)[1].lower()
|
||
if ext not in texture_exts:
|
||
continue
|
||
key = filename.lower()
|
||
if key not in index:
|
||
index[key] = os.path.join(root, filename)
|
||
scanned += 1
|
||
if scanned >= limit:
|
||
return index
|
||
except Exception:
|
||
continue
|
||
return index
|
||
|
||
def _repair_missing_textures(self, model_np, model_path):
|
||
"""
|
||
Repair broken texture paths by basename search; if unresolved, clear that
|
||
missing texture binding to avoid black PBR sampling.
|
||
"""
|
||
if not model_np or model_np.is_empty():
|
||
return
|
||
|
||
search_dirs = self._build_texture_search_dirs(model_path)
|
||
texture_index = self._index_texture_files(search_dirs)
|
||
|
||
fixed = 0
|
||
cleared = 0
|
||
white_tex = self._get_white_fallback_texture()
|
||
nodes = [model_np] + list(model_np.find_all_matches("**"))
|
||
for node in nodes:
|
||
if not node or node.is_empty():
|
||
continue
|
||
|
||
try:
|
||
stages = node.find_all_texture_stages()
|
||
except Exception:
|
||
try:
|
||
stages = node.findAllTextureStages()
|
||
except Exception:
|
||
continue
|
||
|
||
try:
|
||
stage_count = stages.get_num_texture_stages()
|
||
stage_at = stages.get_texture_stage
|
||
except Exception:
|
||
try:
|
||
stage_count = stages.getNumTextureStages()
|
||
stage_at = stages.getTextureStage
|
||
except Exception:
|
||
continue
|
||
|
||
for i in range(stage_count):
|
||
stage = stage_at(i)
|
||
if not stage:
|
||
continue
|
||
|
||
try:
|
||
tex = node.get_texture(stage)
|
||
except Exception:
|
||
tex = node.getTexture(stage)
|
||
if not tex:
|
||
continue
|
||
|
||
if self._texture_is_valid(tex):
|
||
continue
|
||
|
||
basename = self._extract_texture_basename(tex)
|
||
if not basename:
|
||
continue
|
||
|
||
replacement = texture_index.get(basename.lower())
|
||
if replacement:
|
||
try:
|
||
new_tex = self._load_texture_from_path(replacement)
|
||
if new_tex:
|
||
try:
|
||
node.set_texture(stage, new_tex, 1)
|
||
except Exception:
|
||
node.setTexture(stage, new_tex, 1)
|
||
fixed += 1
|
||
continue
|
||
except Exception:
|
||
pass
|
||
|
||
# Missing texture with no replacement: CLEAR the texture binding.
|
||
# Do NOT use a white fallback texture, because if this is a Metallic or Roughness
|
||
# map, pure white will force Metallic=1.0 and Roughness=1.0, which turns models black!
|
||
try:
|
||
try:
|
||
node.clear_texture(stage)
|
||
except Exception:
|
||
node.clearTexture(stage)
|
||
cleared += 1
|
||
except Exception:
|
||
pass
|
||
|
||
# GeomState-level texture bindings (common in imported FBX/GLTF):
|
||
# inspect and apply the same fallback on this GeomNode path.
|
||
try:
|
||
gnode = node.node()
|
||
get_num_geoms = getattr(gnode, "get_num_geoms", None) or getattr(gnode, "getNumGeoms", None)
|
||
get_geom_state = getattr(gnode, "get_geom_state", None) or getattr(gnode, "getGeomState", None)
|
||
geom_count = int(get_num_geoms()) if callable(get_num_geoms) else 0
|
||
except Exception:
|
||
geom_count = 0
|
||
|
||
for gi in range(geom_count):
|
||
try:
|
||
state = get_geom_state(gi)
|
||
except Exception:
|
||
continue
|
||
if state is None:
|
||
continue
|
||
|
||
tattr = None
|
||
try:
|
||
if state.has_attrib(TextureAttrib.get_class_type()):
|
||
tattr = state.get_attrib(TextureAttrib.get_class_type())
|
||
except Exception:
|
||
try:
|
||
if state.hasAttrib(TextureAttrib.getClassType()):
|
||
tattr = state.getAttrib(TextureAttrib.getClassType())
|
||
except Exception:
|
||
tattr = None
|
||
if not tattr:
|
||
continue
|
||
|
||
try:
|
||
num_on = tattr.get_num_on_stages()
|
||
get_stage = tattr.get_on_stage
|
||
get_tex = tattr.get_on_texture
|
||
except Exception:
|
||
try:
|
||
num_on = tattr.getNumOnStages()
|
||
get_stage = tattr.getOnStage
|
||
get_tex = tattr.getOnTexture
|
||
except Exception:
|
||
continue
|
||
|
||
for si in range(int(num_on)):
|
||
try:
|
||
stage = get_stage(si)
|
||
tex = get_tex(stage)
|
||
except Exception:
|
||
continue
|
||
if not stage or not tex:
|
||
continue
|
||
if self._texture_is_valid(tex):
|
||
continue
|
||
|
||
basename = self._extract_texture_basename(tex)
|
||
replacement = texture_index.get(basename.lower()) if basename else None
|
||
if replacement:
|
||
try:
|
||
new_tex = self._load_texture_from_path(replacement)
|
||
if new_tex:
|
||
try:
|
||
node.set_texture(stage, new_tex, 100000)
|
||
except Exception:
|
||
node.setTexture(stage, new_tex, 100000)
|
||
fixed += 1
|
||
continue
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
try:
|
||
node.clear_texture(stage)
|
||
except Exception:
|
||
node.clearTexture(stage)
|
||
cleared += 1
|
||
except Exception:
|
||
pass
|
||
|
||
if fixed or cleared:
|
||
print(f"[SSBOEditor] Texture repair: fixed={fixed}, cleared_missing={cleared}")
|
||
self._apply_nonblack_material_fallback(model_np)
|
||
|
||
def _texture_is_valid(self, tex):
|
||
if not tex:
|
||
return False
|
||
tex_path = self._extract_texture_os_path(tex)
|
||
if tex_path and os.path.exists(tex_path):
|
||
return True
|
||
if tex_path:
|
||
# Some valid textures use Panda VFS virtual paths; keep them RAM-checkable.
|
||
path_norm = tex_path.replace("\\", "/")
|
||
if path_norm.startswith("/$$") or path_norm.startswith("$$"):
|
||
pass
|
||
else:
|
||
# File-backed texture with missing source path should be considered invalid,
|
||
# even when Panda keeps a tiny fallback image in RAM.
|
||
return False
|
||
try:
|
||
if tex.has_ram_image():
|
||
return tex.get_ram_image_size() > 0
|
||
except Exception:
|
||
try:
|
||
if tex.hasRamImage():
|
||
return tex.getRamImageSize() > 0
|
||
except Exception:
|
||
pass
|
||
return False
|
||
|
||
def _extract_texture_os_path(self, tex):
|
||
tex_path = ""
|
||
try:
|
||
if tex.has_fullpath():
|
||
fullpath = tex.get_fullpath()
|
||
try:
|
||
tex_path = fullpath.to_os_specific()
|
||
except Exception:
|
||
try:
|
||
tex_path = fullpath.toOsSpecific()
|
||
except Exception:
|
||
tex_path = str(fullpath)
|
||
except Exception:
|
||
try:
|
||
if tex.hasFullpath():
|
||
fullpath = tex.getFullpath()
|
||
try:
|
||
tex_path = fullpath.toOsSpecific()
|
||
except Exception:
|
||
tex_path = str(fullpath)
|
||
except Exception:
|
||
tex_path = ""
|
||
|
||
tex_path = str(tex_path or "").strip()
|
||
if not tex_path:
|
||
return ""
|
||
|
||
tex_path = os.path.normpath(tex_path)
|
||
if os.path.exists(tex_path):
|
||
return tex_path
|
||
|
||
# Convert Panda internal drive path (/d/foo/bar) to Windows path if needed.
|
||
if len(tex_path) >= 3 and tex_path[0] in ("/", "\\") and tex_path[1].isalpha() and tex_path[2] in ("/", "\\"):
|
||
drive_path = f"{tex_path[1]}:{tex_path[2:]}"
|
||
drive_path = os.path.normpath(drive_path)
|
||
if os.path.exists(drive_path):
|
||
return drive_path
|
||
return tex_path
|
||
|
||
def _extract_texture_basename(self, tex):
|
||
tex_path = self._extract_texture_os_path(tex)
|
||
if tex_path:
|
||
return os.path.basename(tex_path.replace("\\", "/"))
|
||
try:
|
||
name = tex.get_name()
|
||
except Exception:
|
||
try:
|
||
name = tex.getName()
|
||
except Exception:
|
||
name = ""
|
||
return os.path.basename(str(name).replace("\\", "/"))
|
||
|
||
def _get_white_fallback_texture(self):
|
||
tex = getattr(self, "_ssbo_white_fallback_tex", None)
|
||
if tex:
|
||
return tex
|
||
try:
|
||
img = PNMImage(2, 2, 4)
|
||
img.fill(1.0, 1.0, 1.0)
|
||
img.alpha_fill(1.0)
|
||
tex = Texture("ssbo_white_fallback")
|
||
tex.load(img)
|
||
tex.set_minfilter(Texture.FT_nearest)
|
||
tex.set_magfilter(Texture.FT_nearest)
|
||
self._ssbo_white_fallback_tex = tex
|
||
return tex
|
||
except Exception:
|
||
return None
|
||
|
||
def _node_has_valid_texture(self, node):
|
||
if not node or node.is_empty():
|
||
return False
|
||
try:
|
||
stages = node.find_all_texture_stages()
|
||
stage_count = stages.get_num_texture_stages()
|
||
stage_at = stages.get_texture_stage
|
||
except Exception:
|
||
try:
|
||
stages = node.findAllTextureStages()
|
||
stage_count = stages.getNumTextureStages()
|
||
stage_at = stages.getTextureStage
|
||
except Exception:
|
||
return False
|
||
for i in range(stage_count):
|
||
stage = stage_at(i)
|
||
if not stage:
|
||
continue
|
||
try:
|
||
tex = node.get_texture(stage)
|
||
except Exception:
|
||
tex = node.getTexture(stage)
|
||
if self._texture_is_valid(tex):
|
||
return True
|
||
|
||
# GeomState TextureAttrib bindings can hold the effective textures.
|
||
try:
|
||
gnode = node.node()
|
||
get_num_geoms = getattr(gnode, "get_num_geoms", None) or getattr(gnode, "getNumGeoms", None)
|
||
get_geom_state = getattr(gnode, "get_geom_state", None) or getattr(gnode, "getGeomState", None)
|
||
geom_count = int(get_num_geoms()) if callable(get_num_geoms) else 0
|
||
except Exception:
|
||
geom_count = 0
|
||
|
||
for gi in range(geom_count):
|
||
try:
|
||
state = get_geom_state(gi)
|
||
except Exception:
|
||
continue
|
||
if state is None:
|
||
continue
|
||
|
||
tattr = None
|
||
try:
|
||
if state.has_attrib(TextureAttrib.get_class_type()):
|
||
tattr = state.get_attrib(TextureAttrib.get_class_type())
|
||
except Exception:
|
||
try:
|
||
if state.hasAttrib(TextureAttrib.getClassType()):
|
||
tattr = state.getAttrib(TextureAttrib.getClassType())
|
||
except Exception:
|
||
tattr = None
|
||
if not tattr:
|
||
continue
|
||
|
||
try:
|
||
num_on = tattr.get_num_on_stages()
|
||
get_stage = tattr.get_on_stage
|
||
get_tex = tattr.get_on_texture
|
||
except Exception:
|
||
try:
|
||
num_on = tattr.getNumOnStages()
|
||
get_stage = tattr.getOnStage
|
||
get_tex = tattr.getOnTexture
|
||
except Exception:
|
||
continue
|
||
|
||
for si in range(int(num_on)):
|
||
try:
|
||
stage = get_stage(si)
|
||
tex = get_tex(stage)
|
||
except Exception:
|
||
continue
|
||
if self._texture_is_valid(tex):
|
||
return True
|
||
return False
|
||
|
||
def _is_node_material_dark(self, node):
|
||
"""Heuristic: detect near-black material/color state."""
|
||
if not node or node.is_empty():
|
||
return False
|
||
try:
|
||
state = node.get_state()
|
||
except Exception:
|
||
try:
|
||
state = node.getState()
|
||
except Exception:
|
||
return True
|
||
|
||
def _vec_dark(v):
|
||
try:
|
||
return max(float(v[0]), float(v[1]), float(v[2])) < 0.08
|
||
except Exception:
|
||
try:
|
||
return max(float(v.x), float(v.y), float(v.z)) < 0.08
|
||
except Exception:
|
||
return False
|
||
|
||
# Material color
|
||
mat = None
|
||
try:
|
||
if state.has_attrib(MaterialAttrib.get_class_type()):
|
||
mat_attr = state.get_attrib(MaterialAttrib.get_class_type())
|
||
mat = mat_attr.get_material()
|
||
except Exception:
|
||
try:
|
||
if state.hasAttrib(MaterialAttrib.getClassType()):
|
||
mat_attr = state.getAttrib(MaterialAttrib.getClassType())
|
||
mat = mat_attr.getMaterial()
|
||
except Exception:
|
||
mat = None
|
||
|
||
if mat:
|
||
for has_name, get_name in (
|
||
("has_base_color", "get_base_color"),
|
||
("has_diffuse", "get_diffuse"),
|
||
("hasBaseColor", "getBaseColor"),
|
||
("hasDiffuse", "getDiffuse"),
|
||
):
|
||
has_fn = getattr(mat, has_name, None)
|
||
get_fn = getattr(mat, get_name, None)
|
||
if callable(has_fn) and callable(get_fn):
|
||
try:
|
||
if has_fn():
|
||
return _vec_dark(get_fn())
|
||
except Exception:
|
||
continue
|
||
return False
|
||
|
||
# ColorAttrib fallback
|
||
try:
|
||
if state.has_attrib(ColorAttrib.get_class_type()):
|
||
color_attr = state.get_attrib(ColorAttrib.get_class_type())
|
||
if not color_attr.is_off():
|
||
return _vec_dark(color_attr.get_color())
|
||
except Exception:
|
||
try:
|
||
if state.hasAttrib(ColorAttrib.getClassType()):
|
||
color_attr = state.getAttrib(ColorAttrib.getClassType())
|
||
if not color_attr.isOff():
|
||
return _vec_dark(color_attr.getColor())
|
||
except Exception:
|
||
pass
|
||
return True
|
||
|
||
def _apply_nonblack_material_fallback(self, model_np):
|
||
"""If a geom has no texture and is effectively black, apply a neutral material."""
|
||
if not model_np or model_np.is_empty():
|
||
return
|
||
neutral = Material()
|
||
neutral.set_base_color((0.75, 0.75, 0.75, 1.0)) if hasattr(neutral, "set_base_color") else neutral.setBaseColor((0.75, 0.75, 0.75, 1.0))
|
||
neutral.set_diffuse((0.75, 0.75, 0.75, 1.0)) if hasattr(neutral, "set_diffuse") else neutral.setDiffuse((0.75, 0.75, 0.75, 1.0))
|
||
neutral.set_ambient((0.22, 0.22, 0.22, 1.0)) if hasattr(neutral, "set_ambient") else neutral.setAmbient((0.22, 0.22, 0.22, 1.0))
|
||
neutral.set_specular((0.1, 0.1, 0.1, 1.0)) if hasattr(neutral, "set_specular") else neutral.setSpecular((0.1, 0.1, 0.1, 1.0))
|
||
neutral.set_shininess(8.0) if hasattr(neutral, "set_shininess") else neutral.setShininess(8.0)
|
||
|
||
patched = 0
|
||
for geom_np in model_np.find_all_matches("**/+GeomNode"):
|
||
if self._node_has_valid_texture(geom_np):
|
||
continue
|
||
if not self._is_node_material_dark(geom_np):
|
||
continue
|
||
try:
|
||
try:
|
||
geom_np.set_material(neutral, 1)
|
||
except Exception:
|
||
geom_np.setMaterial(neutral, 1)
|
||
try:
|
||
geom_np.set_color_scale(1.0, 1.0, 1.0, 1.0)
|
||
except Exception:
|
||
geom_np.setColorScale(1.0, 1.0, 1.0, 1.0)
|
||
patched += 1
|
||
except Exception:
|
||
continue
|
||
if patched:
|
||
print(f"[SSBOEditor] Applied non-black fallback material to {patched} geom nodes.")
|
||
|
||
# No custom effect needed — RP default rendering for maximum FPS
|
||
|
||
def _inject_ssbo_into_shadow_state(self, effect_path):
|
||
"""Inject SSBO inputs into RP shadow tag state"""
|
||
try:
|
||
if not hasattr(self.rp.tag_mgr, 'containers'): return
|
||
|
||
shadow_container = self.rp.tag_mgr.containers.get("shadow")
|
||
if not shadow_container: return
|
||
|
||
tag_value = self.model.get_tag(shadow_container.tag_name)
|
||
if not tag_value: return
|
||
|
||
effect = Effect.load(effect_path, {})
|
||
if effect is None: return
|
||
|
||
shadow_shader = effect.get_shader_obj("shadow")
|
||
if shadow_shader is None: return
|
||
|
||
# Since inputs are now on Nodes (Chunks), we just need to ensure the shader is applied.
|
||
# extra_inputs is no longer needed if the inputs are on the nodes themselves?
|
||
# Wait, RP might override state.
|
||
# But specific shader inputs on NodePath have priority over State inputs usually?
|
||
# Let's try applying without extra inputs first.
|
||
|
||
self.rp.tag_mgr.apply_state(
|
||
"shadow", self.model, shadow_shader,
|
||
tag_value, 65)
|
||
|
||
print(f"[SSBO Shadow] Re-applied shadow state (tag='{tag_value}')")
|
||
except Exception as e:
|
||
print(f"[SSBO Shadow] Error injecting shadow state: {e}")
|
||
|
||
def setup_gpu_picking(self):
|
||
"""Setup GPU Picking (Basic implementation)"""
|
||
self._teardown_gpu_picking()
|
||
|
||
controller = getattr(self, "controller", None)
|
||
if controller and not getattr(controller, "supports_gpu_picking", True):
|
||
print("[GPU Picking] Disabled for lightweight large-scene runtime.")
|
||
return
|
||
|
||
win_props = WindowProperties()
|
||
win_props.set_size(1, 1)
|
||
fb_props = FrameBufferProperties()
|
||
fb_props.set_rgba_bits(8, 8, 8, 8)
|
||
fb_props.set_depth_bits(16)
|
||
|
||
self.pick_buffer = self.base.graphicsEngine.make_output(
|
||
self.base.pipe, "pick_buffer", -100,
|
||
fb_props, win_props,
|
||
GraphicsPipe.BF_refuse_window,
|
||
self.base.win.get_gsg(), self.base.win
|
||
)
|
||
|
||
if not self.pick_buffer:
|
||
print("[GPU Picking] Failed to create buffer!")
|
||
return
|
||
|
||
self.pick_texture = Texture()
|
||
self.pick_texture.set_minfilter(Texture.FT_nearest)
|
||
self.pick_texture.set_magfilter(Texture.FT_nearest)
|
||
self.pick_buffer.add_render_texture(self.pick_texture, GraphicsOutput.RTM_copy_ram)
|
||
|
||
self.pick_cam = Camera("pick_camera")
|
||
self.pick_cam.set_camera_mask(self.pick_mask)
|
||
self.pick_cam_np = self.base.cam.attach_new_node(self.pick_cam)
|
||
self.pick_lens = self.base.camLens.make_copy()
|
||
self.pick_cam.set_lens(self.pick_lens)
|
||
|
||
dr = self.pick_buffer.make_display_region()
|
||
dr.set_camera(self.pick_cam_np)
|
||
|
||
# Load pick shader
|
||
current_dir = os.path.dirname(os.path.abspath(__file__))
|
||
pick_vert_path = os.path.join(current_dir, "shaders", "pick_id.vert")
|
||
pick_frag_path = os.path.join(current_dir, "shaders", "pick_id.frag")
|
||
|
||
try:
|
||
# Read shader source directly from OS filesystem to avoid
|
||
# Panda3D VFS case-mismatch issues on Windows.
|
||
with open(pick_vert_path, 'r', encoding='utf-8') as f:
|
||
vert_src = f.read().replace('\r', '')
|
||
with open(pick_frag_path, 'r', encoding='utf-8') as f:
|
||
frag_src = f.read().replace('\r', '')
|
||
pick_shader = Shader.make(Shader.SL_GLSL, vert_src, frag_src)
|
||
pick_scene = getattr(self.controller, "pick_model", None) or self.model
|
||
if pick_scene and not pick_scene.is_empty():
|
||
pick_scene.show(self.pick_mask)
|
||
self.pick_cam.set_scene(pick_scene or self._empty_pick_scene)
|
||
initial_state = NodePath("initial")
|
||
initial_state.set_shader(pick_shader, 100)
|
||
# Remove global SSBO input, Chunks have their own inputs
|
||
# initial_state.set_shader_input("transforms", ssbo)
|
||
self.pick_cam.set_initial_state(initial_state.get_state())
|
||
except Exception as e:
|
||
print(f"[GPU Picking] Warning: pick shaders failed to load: {e}")
|
||
print("Picking disabled.")
|
||
return
|
||
|
||
self.pick_buffer.set_active(False)
|
||
self.pick_buffer.set_clear_color(Vec4(0, 0, 0, 0))
|
||
self.pick_buffer.set_clear_color_active(True)
|
||
|
||
def _teardown_gpu_picking(self):
|
||
"""Release old GPU picking resources before rebuilding them."""
|
||
pick_cam_np = getattr(self, "pick_cam_np", None)
|
||
if pick_cam_np is not None:
|
||
try:
|
||
if not pick_cam_np.is_empty():
|
||
pick_cam_np.remove_node()
|
||
except Exception:
|
||
try:
|
||
if not pick_cam_np.isEmpty():
|
||
pick_cam_np.removeNode()
|
||
except Exception:
|
||
pass
|
||
self.pick_cam_np = None
|
||
self.pick_cam = None
|
||
self.pick_lens = None
|
||
|
||
pick_buffer = getattr(self, "pick_buffer", None)
|
||
if pick_buffer is not None:
|
||
try:
|
||
self.base.graphicsEngine.remove_window(pick_buffer)
|
||
except Exception:
|
||
try:
|
||
self.base.graphicsEngine.removeWindow(pick_buffer)
|
||
except Exception:
|
||
pass
|
||
self.pick_buffer = None
|
||
self.pick_texture = None
|
||
|
||
def _sync_pick_model_transform(self):
|
||
"""Sync pick-scene clone to current source model world transform."""
|
||
if not self.controller or not self.model:
|
||
return
|
||
pick_model = getattr(self.controller, "pick_model", None)
|
||
if pick_model is None:
|
||
return
|
||
try:
|
||
if pick_model.isEmpty():
|
||
return
|
||
except Exception:
|
||
try:
|
||
if pick_model.is_empty():
|
||
return
|
||
except Exception:
|
||
pass
|
||
try:
|
||
if hasattr(self.controller, "get_model_world_mat"):
|
||
world_mat = self.controller.get_model_world_mat()
|
||
else:
|
||
world_mat = LMatrix4f(self.model.getNetTransform().getMat())
|
||
try:
|
||
pick_model.set_mat(world_mat)
|
||
except Exception:
|
||
pick_model.setMat(world_mat)
|
||
except Exception:
|
||
pass
|
||
|
||
def _refresh_ssbo_proxy_center(self):
|
||
"""Update proxy center when source model transform changes."""
|
||
if self._ssbo_transform_active:
|
||
return
|
||
if not self.controller or not self._ssbo_selected_local_indices:
|
||
return
|
||
if self._ssbo_gizmo_proxy is None:
|
||
return
|
||
try:
|
||
if self._ssbo_gizmo_proxy.isEmpty():
|
||
return
|
||
except Exception:
|
||
return
|
||
try:
|
||
center = self.controller.get_selection_center(self._ssbo_selected_local_indices)
|
||
self._ssbo_gizmo_proxy.set_pos(center)
|
||
except Exception:
|
||
pass
|
||
|
||
def _is_model_attached(self):
|
||
"""Whether the SSBO render root is still attached to scene graph."""
|
||
if not self.model or self.model.is_empty():
|
||
return False
|
||
parent = self.model.get_parent()
|
||
return bool(parent) and not parent.is_empty()
|
||
|
||
def _sync_pick_scene_binding(self):
|
||
"""Switch pick camera scene based on current model attachment state."""
|
||
if not hasattr(self, "pick_cam") or not self.pick_cam:
|
||
return
|
||
|
||
if self._is_model_attached() and self.controller:
|
||
target_scene = getattr(self.controller, "pick_model", None) or self.model
|
||
else:
|
||
target_scene = self._empty_pick_scene
|
||
|
||
if not target_scene:
|
||
target_scene = self._empty_pick_scene
|
||
|
||
if self.pick_cam.get_scene() != target_scene:
|
||
self.pick_cam.set_scene(target_scene)
|
||
|
||
def pick_object(self, mx, my):
|
||
if (not self.pick_buffer or not self.pick_texture or not self.pick_lens or
|
||
not self.controller or not self.model):
|
||
return False
|
||
self._sync_pick_model_transform()
|
||
|
||
def _resolve_pick_selection_key(node_key):
|
||
resolved_key = node_key
|
||
try:
|
||
mouse_watcher = getattr(self.base, "mouseWatcherNode", None)
|
||
if mouse_watcher and mouse_watcher.is_button_down(KeyboardButton.control()):
|
||
parts = str(node_key).split("/")
|
||
if len(parts) >= 2 and parts[0] == getattr(self.controller, "tree_root_key", "0"):
|
||
resolved_key = "/".join(parts[:2])
|
||
except Exception:
|
||
pass
|
||
return resolved_key
|
||
|
||
try:
|
||
self.pick_lens.setAspectRatio(self.base.camLens.getAspectRatio())
|
||
except Exception:
|
||
pass
|
||
|
||
self.pick_lens.set_fov(0.1)
|
||
self.pick_lens.set_film_offset(0, 0)
|
||
self.pick_cam.set_lens(self.pick_lens)
|
||
|
||
near_point = Point3()
|
||
far_point = Point3()
|
||
self.base.camLens.extrude(Point2(mx, my), near_point, far_point)
|
||
|
||
self.pick_cam_np.set_pos(0, 0, 0)
|
||
self.pick_cam_np.look_at(far_point)
|
||
|
||
# Ensure pick transforms are up-to-date before rendering the pick buffer.
|
||
# The per-frame sync task may not have run yet for this frame.
|
||
self._sync_pick_transforms()
|
||
|
||
self.pick_buffer.set_active(True)
|
||
self.base.graphicsEngine.render_frame()
|
||
self.pick_buffer.set_active(False)
|
||
|
||
ram_image = self.pick_texture.get_ram_image_as("RGBA")
|
||
if ram_image:
|
||
data = memoryview(ram_image)
|
||
if len(data) >= 4:
|
||
r, g, b, a = data[0], data[1], data[2], data[3]
|
||
if a > 0 and b == 0:
|
||
hit_id = r + (g << 8)
|
||
node_key = self.controller.id_to_name.get(hit_id)
|
||
if node_key:
|
||
selection_key = _resolve_pick_selection_key(node_key)
|
||
print(f"[Pick] Hit: ID={hit_id} -> {node_key} (select={selection_key})")
|
||
self.select_node(selection_key)
|
||
return True
|
||
|
||
return False
|
||
|
||
|
||
def on_mouse_click(self):
|
||
# Skip SSBO picking when user is interacting with the TransformGizmo,
|
||
# otherwise pick_object would clear the selection and detach the gizmo
|
||
# before the gizmo's own mouse handler fires.
|
||
if self._transform_gizmo and self._transform_gizmo.is_hovering:
|
||
return
|
||
if self.base.mouseWatcherNode.has_mouse():
|
||
try:
|
||
win_width, win_height = self.base.win.getSize()
|
||
mpos = self.base.mouseWatcherNode.get_mouse()
|
||
window_x = (float(mpos.x) + 1.0) * 0.5 * float(win_width)
|
||
window_y = (1.0 - float(mpos.y)) * 0.5 * float(win_height)
|
||
process_imgui_click = getattr(self.base, "processImGuiMouseClick", None)
|
||
if callable(process_imgui_click) and process_imgui_click(window_x, window_y):
|
||
return
|
||
except Exception:
|
||
pass
|
||
self._sync_pick_model_transform()
|
||
self._refresh_ssbo_proxy_center()
|
||
mpos = self.base.mouseWatcherNode.get_mouse()
|
||
if self.pick_object(mpos.x, mpos.y):
|
||
return
|
||
|
||
# In SSBO picking mode, a miss should clear the current SSBO selection.
|
||
# Falling back to legacy collision picking here tends to immediately
|
||
# re-hit broad helper/collision shells from the selected root model,
|
||
# which makes "click blank space to deselect" fail for top-level nodes.
|
||
if self.has_active_selection():
|
||
self.clear_selection()
|
||
return
|
||
|
||
try:
|
||
win_width, win_height = self.base.win.getSize()
|
||
window_x = (float(mpos.x) + 1.0) * 0.5 * float(win_width)
|
||
window_y = (1.0 - float(mpos.y)) * 0.5 * float(win_height)
|
||
event_handler = getattr(self.base, "event_handler", None)
|
||
if event_handler and hasattr(event_handler, "mousePressEventLeft"):
|
||
event_handler.mousePressEventLeft({
|
||
"x": window_x,
|
||
"y": window_y,
|
||
})
|
||
return
|
||
except Exception as e:
|
||
print(f"[SSBOEditor] Legacy pick fallback failed: {e}")
|
||
|
||
self.clear_selection()
|
||
|
||
def toggle_debug(self):
|
||
self.debug_mode = not self.debug_mode
|
||
|
||
def bind_transform_gizmo(self, gizmo):
|
||
"""Bind a TransformGizmo so it follows SSBO selection."""
|
||
self._transform_gizmo = gizmo
|
||
|
||
def _start_pick_sync_task(self):
|
||
"""Start a per-frame task that syncs pick transforms for selected objects."""
|
||
self.base.task_mgr.remove("ssbo_pick_sync")
|
||
self.base.task_mgr.add(self._pick_sync_task, "ssbo_pick_sync")
|
||
|
||
def _stop_pick_sync_task(self):
|
||
"""Stop the per-frame pick sync task."""
|
||
self.base.task_mgr.remove("ssbo_pick_sync")
|
||
|
||
def _pick_sync_task(self, task):
|
||
"""Per-frame: keep pick model transforms in sync with render model."""
|
||
self._sync_pick_transforms()
|
||
return task.cont
|
||
|
||
def _reset_pick_sync_cache(self):
|
||
self._last_group_sync_mat = None
|
||
self._last_single_sync_gid = None
|
||
self._last_single_sync_mat = None
|
||
|
||
def _matrices_close(self, a, b, eps=1e-5):
|
||
"""Small helper for robust matrix change detection."""
|
||
for r in range(4):
|
||
ra = a.get_row(r)
|
||
rb = b.get_row(r)
|
||
if (abs(ra[0] - rb[0]) > eps or
|
||
abs(ra[1] - rb[1]) > eps or
|
||
abs(ra[2] - rb[2]) > eps or
|
||
abs(ra[3] - rb[3]) > eps):
|
||
return False
|
||
return True
|
||
|
||
def _sync_pick_root_transform(self):
|
||
"""
|
||
Keep pick root aligned with the render root transform.
|
||
This covers transforms applied to the whole imported model
|
||
(for example, moving box.glb from scene hierarchy).
|
||
"""
|
||
if not self.controller or not self.model or not self._is_model_attached():
|
||
return
|
||
|
||
pick_root = getattr(self.controller, "pick_model", None)
|
||
if not pick_root:
|
||
return
|
||
|
||
if self.model.is_empty() or pick_root.is_empty():
|
||
return
|
||
|
||
pick_root.set_mat(self.base.render, self.model.get_mat(self.base.render))
|
||
|
||
def _sync_pick_transforms(self):
|
||
"""Sync pick model transforms to match render model transforms."""
|
||
if not self.controller:
|
||
return
|
||
self._sync_pick_root_transform()
|
||
transform_ids = self.get_selection_transform_ids()
|
||
if not transform_ids:
|
||
return
|
||
|
||
# Group selection can contain thousands of objects.
|
||
# Only resync when proxy transform has changed.
|
||
proxy = getattr(self, "_group_proxy", None)
|
||
if proxy and not proxy.is_empty() and len(transform_ids) > 1:
|
||
proxy_world = proxy.get_mat(self.base.render)
|
||
if self._last_group_sync_mat and self._matrices_close(proxy_world, self._last_group_sync_mat):
|
||
return
|
||
self._last_group_sync_mat = LMatrix4f(proxy_world)
|
||
else:
|
||
self._last_group_sync_mat = None
|
||
|
||
if len(transform_ids) == 1:
|
||
gid = transform_ids[0]
|
||
obj_np = self.controller.id_to_object_np.get(gid)
|
||
pick_np = self.controller.id_to_pick_np.get(gid)
|
||
if not (obj_np and pick_np and not obj_np.is_empty() and not pick_np.is_empty()):
|
||
return
|
||
obj_world_mat = obj_np.get_mat(self.base.render)
|
||
if (
|
||
self._last_single_sync_gid == gid and
|
||
self._last_single_sync_mat and
|
||
self._matrices_close(obj_world_mat, self._last_single_sync_mat)
|
||
):
|
||
return
|
||
self._last_single_sync_gid = gid
|
||
self._last_single_sync_mat = LMatrix4f(obj_world_mat)
|
||
pick_world_mat = pick_np.get_mat(self.base.render)
|
||
if not self._matrices_close(obj_world_mat, pick_world_mat):
|
||
pick_np.set_mat(self.base.render, obj_world_mat)
|
||
chunk_id = self.controller.id_to_chunk.get(gid)
|
||
if chunk_id is not None and chunk_id in self.controller.chunks:
|
||
self.controller.chunks[chunk_id]["dirty"] = True
|
||
return
|
||
|
||
self._last_single_sync_gid = None
|
||
self._last_single_sync_mat = None
|
||
for gid in transform_ids:
|
||
obj_np = self.controller.id_to_object_np.get(gid)
|
||
pick_np = self.controller.id_to_pick_np.get(gid)
|
||
if obj_np and pick_np and not obj_np.is_empty() and not pick_np.is_empty():
|
||
obj_world_mat = obj_np.get_mat(self.base.render)
|
||
pick_world_mat = pick_np.get_mat(self.base.render)
|
||
if not self._matrices_close(obj_world_mat, pick_world_mat):
|
||
# Sync by world transform so this stays correct even when
|
||
# the model root itself has been moved in scene hierarchy.
|
||
pick_np.set_mat(self.base.render, obj_world_mat)
|
||
chunk_id = self.controller.id_to_chunk.get(gid)
|
||
if chunk_id is not None and chunk_id in self.controller.chunks:
|
||
self.controller.chunks[chunk_id]["dirty"] = True
|
||
|
||
def sync_scene_nodes_to_pick(self, nodes):
|
||
"""Sync transformed scene nodes to both pick data and visible static chunks."""
|
||
if not self.controller:
|
||
return
|
||
|
||
self._sync_pick_scene_binding()
|
||
self._sync_pick_root_transform()
|
||
|
||
valid_nodes = []
|
||
for node in nodes or []:
|
||
if not self._node_is_valid(node):
|
||
continue
|
||
duplicate = False
|
||
for existing in valid_nodes:
|
||
try:
|
||
if existing == node:
|
||
duplicate = True
|
||
break
|
||
except Exception:
|
||
pass
|
||
if not duplicate:
|
||
valid_nodes.append(node)
|
||
|
||
if not valid_nodes:
|
||
self._reset_pick_sync_cache()
|
||
return
|
||
|
||
affected_chunks = set()
|
||
|
||
for gid, obj_np in self.controller.id_to_object_np.items():
|
||
if not self._node_is_valid(obj_np):
|
||
continue
|
||
|
||
matched = False
|
||
for target in valid_nodes:
|
||
try:
|
||
if obj_np == target:
|
||
matched = True
|
||
break
|
||
except Exception:
|
||
pass
|
||
if not matched:
|
||
continue
|
||
|
||
is_attached = False
|
||
try:
|
||
is_attached = bool(obj_np.has_parent())
|
||
except Exception:
|
||
try:
|
||
is_attached = bool(obj_np.hasParent())
|
||
except Exception:
|
||
is_attached = False
|
||
|
||
is_visible = False
|
||
if is_attached:
|
||
try:
|
||
is_visible = not obj_np.is_hidden()
|
||
except Exception:
|
||
try:
|
||
is_visible = not obj_np.isHidden()
|
||
except Exception:
|
||
is_visible = True
|
||
|
||
pick_np = self.controller.id_to_pick_np.get(gid)
|
||
if pick_np and not pick_np.is_empty():
|
||
if is_visible:
|
||
try:
|
||
pick_np.show()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
pick_np.set_mat(self.base.render, obj_np.get_mat(self.base.render))
|
||
except Exception:
|
||
try:
|
||
pick_np.setMat(self.base.render, obj_np.getMat(self.base.render))
|
||
except Exception:
|
||
pass
|
||
else:
|
||
try:
|
||
pick_np.hide()
|
||
except Exception:
|
||
pass
|
||
|
||
chunk_id = self.controller.id_to_chunk.get(gid)
|
||
if chunk_id is not None and chunk_id in self.controller.chunks:
|
||
self.controller.chunks[chunk_id]["dirty"] = True
|
||
affected_chunks.add(chunk_id)
|
||
|
||
for chunk_id in affected_chunks:
|
||
chunk = self.controller.chunks.get(chunk_id)
|
||
if not chunk or chunk.get("dynamic_enabled"):
|
||
continue
|
||
try:
|
||
self.controller._rebuild_static_chunk(chunk_id)
|
||
except Exception:
|
||
pass
|
||
|
||
self._reset_pick_sync_cache()
|
||
|
||
def _update_outline_for_selection(self):
|
||
if not self._outline_manager:
|
||
return
|
||
transform_ids = self.get_selection_transform_ids()
|
||
if not self.controller or not transform_ids:
|
||
self._outline_manager.clear()
|
||
return
|
||
|
||
is_root_selection = (
|
||
self.controller and
|
||
self.selected_name == getattr(self.controller, "tree_root_key", None)
|
||
)
|
||
if is_root_selection:
|
||
self._outline_manager.clear()
|
||
return
|
||
|
||
targets = []
|
||
target_limit = max(1, int(getattr(self._outline_manager, "max_targets", 64)))
|
||
for gid in transform_ids:
|
||
obj_np = self.controller.id_to_object_np.get(gid)
|
||
if obj_np and not obj_np.is_empty():
|
||
targets.append(obj_np)
|
||
if len(targets) >= target_limit:
|
||
break
|
||
|
||
self._outline_manager.set_targets(targets)
|
||
|
||
def _node_is_valid(self, node):
|
||
if not node:
|
||
return False
|
||
try:
|
||
return not node.is_empty()
|
||
except Exception:
|
||
try:
|
||
return not node.isEmpty()
|
||
except Exception:
|
||
return False
|
||
|
||
def has_active_selection(self):
|
||
return bool(self.controller and self.selected_name is not None)
|
||
|
||
def is_flat_selection_mode(self):
|
||
if not self.controller:
|
||
return False
|
||
return not bool(getattr(self.controller, "id_to_object_np", {}) or {})
|
||
|
||
def get_selection_transform_ids(self):
|
||
if not self.controller or self.selected_name is None:
|
||
return []
|
||
return list(getattr(self, "transform_ids", []) or [])
|
||
|
||
def _is_root_selection(self):
|
||
return bool(
|
||
self.controller and
|
||
self.selected_name == getattr(self.controller, "tree_root_key", None)
|
||
)
|
||
|
||
def _is_top_level_source_child_selection(self, key=None):
|
||
if not self.controller:
|
||
return False
|
||
selected_key = key if key is not None else self.selected_name
|
||
if not selected_key or selected_key == getattr(self.controller, "tree_root_key", None):
|
||
return False
|
||
root_key = getattr(self.controller, "tree_root_key", None)
|
||
root_node = self.controller.tree_nodes.get(root_key, {}) if root_key else {}
|
||
top_level_children = root_node.get("children", []) or []
|
||
return selected_key in top_level_children
|
||
|
||
def _is_displayed_top_level_selection(self, key=None):
|
||
if not self.controller:
|
||
return False
|
||
selected_key = key if key is not None else self.selected_name
|
||
root_key = getattr(self.controller, "tree_root_key", None)
|
||
if not selected_key or not root_key or selected_key == root_key:
|
||
return False
|
||
|
||
current_key = selected_key
|
||
visited = set()
|
||
while current_key and current_key not in visited:
|
||
visited.add(current_key)
|
||
node = self.controller.tree_nodes.get(current_key)
|
||
if not node:
|
||
return False
|
||
parent_key = node.get("parent")
|
||
if parent_key == root_key:
|
||
return True
|
||
if not parent_key:
|
||
return False
|
||
if not self.controller.should_hide_tree_node(parent_key):
|
||
return False
|
||
current_key = parent_key
|
||
return False
|
||
|
||
def _resolve_top_level_source_child_key(self, key=None):
|
||
"""Return the direct child key under tree_root that owns the selection key."""
|
||
if not self.controller:
|
||
return None
|
||
selected_key = key if key is not None else self.selected_name
|
||
root_key = getattr(self.controller, "tree_root_key", None)
|
||
if not selected_key or not root_key or selected_key == root_key:
|
||
return None
|
||
|
||
current_key = selected_key
|
||
visited = set()
|
||
while current_key and current_key not in visited:
|
||
visited.add(current_key)
|
||
node = self.controller.tree_nodes.get(current_key)
|
||
if not node:
|
||
return None
|
||
parent_key = node.get("parent")
|
||
if parent_key == root_key:
|
||
return current_key
|
||
current_key = parent_key
|
||
return None
|
||
|
||
def _selection_equivalent_top_level_key(self, key=None):
|
||
"""Normalize wrapper selections to their equivalent top-level model key."""
|
||
if not self.controller:
|
||
return None
|
||
selected_key = key if key is not None else self.selected_name
|
||
if not selected_key:
|
||
return None
|
||
|
||
top_key = self._resolve_top_level_source_child_key(selected_key)
|
||
if not top_key:
|
||
return None
|
||
if selected_key == top_key:
|
||
return top_key
|
||
|
||
try:
|
||
selected_ids = set(self.controller.name_to_ids.get(selected_key, []) or [])
|
||
top_ids = set(self.controller.name_to_ids.get(top_key, []) or [])
|
||
except Exception:
|
||
return None
|
||
if not selected_ids or not top_ids:
|
||
return None
|
||
if selected_ids == top_ids:
|
||
return top_key
|
||
return None
|
||
|
||
def _should_use_model_root_for_top_level_selection(self, key=None):
|
||
if not self.controller:
|
||
return False
|
||
selected_key = key if key is not None else self.selected_name
|
||
root_key = getattr(self.controller, "tree_root_key", None)
|
||
if not selected_key or not root_key or selected_key == root_key:
|
||
return False
|
||
if not (
|
||
self._is_top_level_source_child_selection(selected_key)
|
||
or self._is_displayed_top_level_selection(selected_key)
|
||
):
|
||
return False
|
||
try:
|
||
root_node = self.controller.tree_nodes.get(root_key, {}) if root_key else {}
|
||
top_level_children = list(root_node.get("children", []) or [])
|
||
return len(top_level_children) <= 1
|
||
except Exception:
|
||
return False
|
||
|
||
def get_selection_scene_node(self):
|
||
"""Return a stable scene node for editor features that need one."""
|
||
if not self.controller or self.selected_name is None:
|
||
return None
|
||
|
||
has_dynamic_objects = bool(getattr(self.controller, "id_to_object_np", {}) or {})
|
||
transform_ids = self.get_selection_transform_ids()
|
||
|
||
if self._is_root_selection():
|
||
return self.model if self._node_is_valid(self.model) else None
|
||
|
||
if len(transform_ids) > 1:
|
||
proxy = getattr(self, "_group_proxy", None)
|
||
if proxy and self._node_is_valid(proxy):
|
||
return proxy
|
||
|
||
if self._should_use_model_root_for_top_level_selection():
|
||
return self.model if self._node_is_valid(self.model) else None
|
||
|
||
fallback_node = None
|
||
try:
|
||
fallback_node = getattr(self.controller, "key_to_node", {}).get(self.selected_name)
|
||
except Exception:
|
||
fallback_node = None
|
||
if self._node_is_valid(fallback_node):
|
||
return fallback_node
|
||
|
||
if not has_dynamic_objects:
|
||
return self.model if self._node_is_valid(self.model) else None
|
||
|
||
if len(self.selected_ids) >= 1:
|
||
obj_np = self.controller.id_to_object_np.get(self.selected_ids[0])
|
||
if self._node_is_valid(obj_np):
|
||
return obj_np
|
||
|
||
return None
|
||
|
||
def get_selection_runtime_material_node(self):
|
||
"""Return the runtime node that material editing should target."""
|
||
if self.controller and self.selected_name is not None:
|
||
fallback_node = getattr(self.controller, "key_to_node", {}).get(self.selected_name)
|
||
if self._node_is_valid(fallback_node):
|
||
return fallback_node
|
||
if not self.controller or not self.selected_ids:
|
||
return None
|
||
obj_np = self.controller.id_to_object_np.get(self.selected_ids[0])
|
||
if self._node_is_valid(obj_np):
|
||
return obj_np
|
||
return None
|
||
|
||
def get_selection_source_material_node(self):
|
||
"""Return the exact source-tree node for the currently edited material target."""
|
||
if not self.controller or not self.selected_ids:
|
||
return None
|
||
owner_key = self.controller.id_to_name.get(self.selected_ids[0])
|
||
if not owner_key:
|
||
return None
|
||
source_node = self._resolve_source_node_by_tree_key(owner_key)
|
||
if self._node_is_valid(source_node):
|
||
return source_node
|
||
return None
|
||
|
||
def get_selection_summary(self):
|
||
if not self.controller or self.selected_name is None:
|
||
return None
|
||
return {
|
||
"key": self.selected_name,
|
||
"display_name": self.controller.display_names.get(self.selected_name, self.selected_name),
|
||
"object_count": len(self.get_selection_transform_ids()),
|
||
"is_root": self._is_root_selection(),
|
||
"is_group": len(self.get_selection_transform_ids()) > 1 and not self._is_root_selection(),
|
||
}
|
||
|
||
def estimate_selection_cost(self, key=None):
|
||
"""Estimate how expensive a selection would be in hybrid SSBO mode."""
|
||
if not self.controller:
|
||
return {
|
||
"key": key,
|
||
"object_count": 0,
|
||
"chunk_count": 0,
|
||
"is_root": False,
|
||
"is_top_level_like": False,
|
||
}
|
||
|
||
selected_key = key if key is not None else self.selected_name
|
||
if selected_key is None:
|
||
return {
|
||
"key": None,
|
||
"object_count": 0,
|
||
"chunk_count": 0,
|
||
"is_root": False,
|
||
"is_top_level_like": False,
|
||
}
|
||
|
||
transform_ids = list(getattr(self.controller, "name_to_ids", {}).get(selected_key, []) or [])
|
||
chunk_ids = set()
|
||
for transform_id in transform_ids:
|
||
chunk_id = getattr(self.controller, "id_to_chunk", {}).get(transform_id)
|
||
if isinstance(chunk_id, (tuple, list)):
|
||
chunk_id = chunk_id[0] if chunk_id else None
|
||
if chunk_id is not None:
|
||
chunk_ids.add(chunk_id)
|
||
|
||
return {
|
||
"key": selected_key,
|
||
"object_count": len(transform_ids),
|
||
"chunk_count": len(chunk_ids),
|
||
"is_root": bool(selected_key == getattr(self.controller, "tree_root_key", None)),
|
||
"is_top_level_like": bool(
|
||
self._is_top_level_source_child_selection(selected_key)
|
||
or self._is_displayed_top_level_selection(selected_key)
|
||
),
|
||
}
|
||
|
||
def get_selection_key(self):
|
||
if not self.controller or self.selected_name is None:
|
||
return None
|
||
return self.selected_name
|
||
|
||
def get_selection_source_node(self):
|
||
if not self.controller or self.selected_name is None:
|
||
return None
|
||
if self._should_use_model_root_for_top_level_selection():
|
||
source_children = self._get_source_root_children()
|
||
if len(source_children) == 1 and self._node_is_valid(source_children[0]):
|
||
return source_children[0]
|
||
source_node = self._resolve_source_node_by_tree_key(self.selected_name)
|
||
if self._node_is_valid(source_node):
|
||
return source_node
|
||
fallback_scene_node = self.get_selection_scene_node()
|
||
if self.is_source_tree_node(fallback_scene_node):
|
||
return fallback_scene_node
|
||
return None
|
||
|
||
def is_source_tree_node(self, node):
|
||
if not self._node_is_valid(node) or not self._node_is_valid(self.source_model_root):
|
||
return False
|
||
current = node
|
||
while self._node_is_valid(current):
|
||
if current == self.source_model_root:
|
||
return True
|
||
try:
|
||
current = current.get_parent()
|
||
except Exception:
|
||
try:
|
||
current = current.getParent()
|
||
except Exception:
|
||
return False
|
||
return False
|
||
|
||
def refresh_runtime_from_source(self, preserve_selection=True):
|
||
if not self._get_source_root_children():
|
||
return False
|
||
|
||
selected_key = self.selected_name if preserve_selection else None
|
||
try:
|
||
# Loading/rebuilding from an already authoritative source tree must not
|
||
# snapshot the transient runtime state back into source again.
|
||
# Otherwise scene-open can overwrite freshly restored transforms with
|
||
# stale/identity runtime values before the rebuild happens.
|
||
self._clear_runtime_state(preserve_source_models=True, snapshot_transform=False)
|
||
self._rebuild_runtime_from_source_root(highlight_root_name=None)
|
||
self.force_static_chunk_idle_state()
|
||
if preserve_selection and selected_key and self.controller:
|
||
try:
|
||
if (
|
||
selected_key == getattr(self.controller, "tree_root_key", None)
|
||
or selected_key in getattr(self.controller, "tree_nodes", {})
|
||
or selected_key in getattr(self.controller, "name_to_ids", {})
|
||
):
|
||
self.select_node(selected_key)
|
||
except Exception:
|
||
pass
|
||
return True
|
||
except Exception as e:
|
||
print(f"[SSBOEditor] 从 source 刷新 runtime 失败: {e}")
|
||
return False
|
||
|
||
def get_source_tree_stats(self):
|
||
root = getattr(self, "source_model_root", None)
|
||
stats = {
|
||
"valid": False,
|
||
"has_parent": False,
|
||
"hidden": False,
|
||
"stashed": False,
|
||
"descendants": 0,
|
||
"geom_nodes": 0,
|
||
"top_children": 0,
|
||
"parent_name": "",
|
||
}
|
||
if not self._node_is_valid(root):
|
||
return stats
|
||
|
||
stats["valid"] = True
|
||
try:
|
||
stats["has_parent"] = bool(root.has_parent())
|
||
except Exception:
|
||
pass
|
||
try:
|
||
stats["hidden"] = bool(root.is_hidden())
|
||
except Exception:
|
||
pass
|
||
try:
|
||
stats["stashed"] = bool(root.is_stashed())
|
||
except Exception:
|
||
pass
|
||
try:
|
||
parent = root.get_parent()
|
||
if parent and not parent.is_empty():
|
||
stats["parent_name"] = parent.get_name() or ""
|
||
except Exception:
|
||
pass
|
||
try:
|
||
stats["descendants"] = root.find_all_matches("**").get_num_paths()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
stats["geom_nodes"] = len(list(root.find_all_matches("**/+GeomNode")))
|
||
except Exception:
|
||
pass
|
||
try:
|
||
stats["top_children"] = len([child for child in root.get_children() if not child.is_empty()])
|
||
except Exception:
|
||
pass
|
||
return stats
|
||
|
||
def force_static_chunk_idle_state(self):
|
||
"""Force hybrid chunk runtime back to fully static idle mode."""
|
||
controller = getattr(self, "controller", None)
|
||
chunks = getattr(controller, "chunks", None) if controller else None
|
||
if not controller or not isinstance(chunks, dict) or not chunks:
|
||
return False
|
||
|
||
rebuilt = 0
|
||
for chunk_id in sorted(chunks):
|
||
try:
|
||
controller._rebuild_static_chunk(chunk_id)
|
||
controller._set_chunk_dynamic(chunk_id, False)
|
||
rebuilt += 1
|
||
except Exception:
|
||
continue
|
||
|
||
if rebuilt:
|
||
print(f"[SSBOEditor] Forced static idle chunks: {rebuilt}")
|
||
return rebuilt > 0
|
||
|
||
def _sync_editor_selection_reference(self, node):
|
||
selection = getattr(self.base, "selection", None)
|
||
if not selection:
|
||
return
|
||
selection.selectedNode = node
|
||
selection.selectedObject = node
|
||
|
||
def _clear_editor_selection_visuals(self):
|
||
selection = getattr(self.base, "selection", None)
|
||
if not selection:
|
||
return
|
||
try:
|
||
selection.clearSelectionBox()
|
||
except Exception:
|
||
pass
|
||
try:
|
||
selection._updateSelectionOutline(None)
|
||
except Exception:
|
||
pass
|
||
try:
|
||
selection.clearGizmo()
|
||
except Exception:
|
||
pass
|
||
|
||
def _find_tree_key_for_scene_node(self, node):
|
||
if not self.controller or not self._node_is_valid(node):
|
||
return None
|
||
if self.is_source_tree_node(node):
|
||
source_key = self._resolve_tree_key_for_source_node(node)
|
||
if source_key:
|
||
return source_key
|
||
if self.model and node == self.model:
|
||
return getattr(self.controller, "tree_root_key", None)
|
||
try:
|
||
for key, mapped_node in getattr(self.controller, "key_to_node", {}).items():
|
||
if mapped_node == node:
|
||
return key
|
||
except Exception:
|
||
pass
|
||
for gid, obj_np in self.controller.id_to_object_np.items():
|
||
if obj_np == node:
|
||
return self.controller.id_to_name.get(gid)
|
||
return None
|
||
|
||
def sync_scene_selection(self, node):
|
||
"""Mirror scene-tree selection back into SSBO state, or clear stale SSBO state."""
|
||
if not self.controller:
|
||
return
|
||
|
||
target_key = self._find_tree_key_for_scene_node(node)
|
||
if target_key:
|
||
if target_key == self.selected_name:
|
||
return
|
||
self.select_node(target_key, sync_world_selection=False)
|
||
return
|
||
|
||
if self.has_active_selection():
|
||
self.clear_selection(sync_world_selection=False)
|
||
|
||
def clear_selection(self, sync_world_selection=True, snapshot_transform=True):
|
||
if snapshot_transform:
|
||
selected_top_synced = self._snapshot_selected_top_level_transform_to_source()
|
||
if not selected_top_synced:
|
||
self._snapshot_active_selection_transform_to_source()
|
||
self._stop_pick_sync_task()
|
||
self._reset_pick_sync_cache()
|
||
self._cleanup_group_proxy()
|
||
self.selected_name = None
|
||
self.selected_ids = []
|
||
self.transform_ids = []
|
||
if self._outline_manager:
|
||
self._outline_manager.clear()
|
||
if self.controller:
|
||
self.controller.set_active_ids([])
|
||
if self._transform_gizmo:
|
||
self._transform_gizmo.detach()
|
||
if sync_world_selection:
|
||
self._clear_editor_selection_visuals()
|
||
self._sync_editor_selection_reference(None)
|
||
|
||
def on_model_deleted(self, deleted_node):
|
||
"""Called by app deletion flow when SSBO root model is deleted."""
|
||
if not deleted_node or deleted_node.is_empty() or not self.model:
|
||
return
|
||
if deleted_node != self.model:
|
||
return
|
||
self.clear_selection()
|
||
self._sync_pick_scene_binding()
|
||
|
||
def reset_scene_state(self):
|
||
"""Remove the current SSBO model/controller state before loading another scene."""
|
||
self._clear_runtime_state(preserve_source_models=False)
|
||
|
||
def _cleanup_group_proxy(self):
|
||
"""Reparent objects back to their chunk and remove the group proxy."""
|
||
proxy = getattr(self, '_group_proxy', None)
|
||
if not proxy:
|
||
return
|
||
originals = getattr(self, '_group_original_parents', {})
|
||
# Sync pick transforms and mark chunks dirty before reparenting
|
||
for gid in originals:
|
||
obj_np = self.controller.id_to_object_np.get(gid)
|
||
pick_np = self.controller.id_to_pick_np.get(gid)
|
||
if obj_np and pick_np and not obj_np.is_empty() and not pick_np.is_empty():
|
||
pick_np.set_mat(self.base.render, obj_np.get_mat(self.base.render))
|
||
chunk_id = self.controller.id_to_chunk.get(gid)
|
||
if chunk_id is not None and chunk_id in self.controller.chunks:
|
||
self.controller.chunks[chunk_id]["dirty"] = True
|
||
# Reparent objects back to their original chunk parents
|
||
for gid, parent_np in originals.items():
|
||
obj_np = self.controller.id_to_object_np.get(gid)
|
||
if obj_np and not obj_np.is_empty() and parent_np and not parent_np.is_empty():
|
||
obj_np.wrt_reparent_to(parent_np)
|
||
if not proxy.is_empty():
|
||
proxy.remove_node()
|
||
self._group_proxy = None
|
||
self._group_original_parents = {}
|
||
self._group_proxy_initial_mat = None
|
||
self._group_proxy_source_initial_net_mat = None
|
||
|
||
def update_selection_mask(self):
|
||
pass # No selection mask texture needed without custom shader
|
||
|
||
def select_node(self, key, sync_world_selection=True):
|
||
selected_top_synced = self._snapshot_selected_top_level_transform_to_source()
|
||
if not selected_top_synced:
|
||
self._snapshot_active_selection_transform_to_source()
|
||
# Clean up previous group proxy before changing selection
|
||
self._cleanup_group_proxy()
|
||
self._reset_pick_sync_cache()
|
||
|
||
self.selected_name = key
|
||
preferred_ids_fn = getattr(self.controller, "get_preferred_selection_ids", None)
|
||
if callable(preferred_ids_fn):
|
||
self.selected_ids = preferred_ids_fn(key)
|
||
else:
|
||
self.selected_ids = self.controller.name_to_ids.get(key, [])
|
||
self.transform_ids = list(self.controller.name_to_ids.get(key, []) or [])
|
||
has_dynamic_objects = bool(getattr(self.controller, "id_to_object_np", {}) or {})
|
||
is_root_selection = (
|
||
self.controller and
|
||
key == getattr(self.controller, "tree_root_key", None)
|
||
)
|
||
is_displayed_top_level_selection = self._is_displayed_top_level_selection(key)
|
||
use_model_root_for_top_level_selection = self._should_use_model_root_for_top_level_selection(key)
|
||
if sync_world_selection:
|
||
self._clear_editor_selection_visuals()
|
||
|
||
# Root selection should stay lightweight, but top-level imported model
|
||
# groups still need a stable proxy so their local transform can be
|
||
# snapshotted back into source_root correctly.
|
||
if (
|
||
is_root_selection
|
||
or use_model_root_for_top_level_selection
|
||
or not has_dynamic_objects
|
||
):
|
||
self.controller.set_active_ids([])
|
||
if self._outline_manager and not (not has_dynamic_objects and not is_root_selection):
|
||
self._outline_manager.clear()
|
||
fallback_scene_node = self.get_selection_scene_node()
|
||
if sync_world_selection:
|
||
self._sync_editor_selection_reference(fallback_scene_node)
|
||
if self._outline_manager and not is_root_selection and self._node_is_valid(fallback_scene_node):
|
||
self._outline_manager.set_targets([fallback_scene_node])
|
||
if sync_world_selection and not has_dynamic_objects:
|
||
selection = getattr(self.base, "selection", None)
|
||
if selection and self._node_is_valid(fallback_scene_node):
|
||
try:
|
||
selection.updateSelection(fallback_scene_node)
|
||
except Exception:
|
||
pass
|
||
if self._transform_gizmo:
|
||
if is_root_selection and self.model and not self.model.is_empty():
|
||
self._transform_gizmo.attach(self.model)
|
||
elif self._node_is_valid(fallback_scene_node):
|
||
self._transform_gizmo.attach(fallback_scene_node)
|
||
else:
|
||
self._transform_gizmo.detach()
|
||
self._stop_pick_sync_task()
|
||
return
|
||
|
||
self.controller.set_active_ids(self.transform_ids)
|
||
self._update_outline_for_selection()
|
||
|
||
if not self._transform_gizmo or not self.transform_ids:
|
||
if self._transform_gizmo:
|
||
self._transform_gizmo.detach()
|
||
return
|
||
|
||
if len(self.transform_ids) == 1:
|
||
# Single object: attach gizmo directly
|
||
obj_np = self.controller.id_to_object_np.get(self.transform_ids[0])
|
||
if obj_np and not obj_np.is_empty():
|
||
if sync_world_selection:
|
||
self._sync_editor_selection_reference(obj_np)
|
||
self._transform_gizmo.attach(obj_np)
|
||
self._start_pick_sync_task()
|
||
return
|
||
|
||
# Multiple objects (parent node): create a group proxy so all children
|
||
# follow the gizmo transform together.
|
||
from panda3d.core import Vec3
|
||
proxy = self.base.render.attach_new_node("ssbo_group_proxy")
|
||
try:
|
||
proxy.set_name(self.controller.display_names.get(key, "ssbo_group_proxy"))
|
||
proxy.setTag("is_ssbo_proxy", "1")
|
||
proxy.setTag("ssbo_selection_key", str(key))
|
||
except Exception:
|
||
pass
|
||
center = Vec3(0, 0, 0)
|
||
valid = []
|
||
for gid in self.transform_ids:
|
||
obj_np = self.controller.id_to_object_np.get(gid)
|
||
if obj_np and not obj_np.is_empty():
|
||
center += obj_np.get_pos(self.base.render)
|
||
valid.append(gid)
|
||
if not valid:
|
||
proxy.remove_node()
|
||
return
|
||
|
||
center /= len(valid)
|
||
proxy.set_pos(self.base.render, center)
|
||
|
||
self._group_proxy = proxy
|
||
self._group_original_parents = {}
|
||
self._group_proxy_initial_mat = None
|
||
self._group_proxy_source_initial_net_mat = None
|
||
for gid in valid:
|
||
obj_np = self.controller.id_to_object_np[gid]
|
||
self._group_original_parents[gid] = obj_np.get_parent()
|
||
obj_np.wrt_reparent_to(proxy)
|
||
|
||
source_node = self.get_selection_source_node()
|
||
if self._node_is_valid(source_node):
|
||
try:
|
||
self._group_proxy_initial_mat = LMatrix4f(proxy.get_mat(self.model))
|
||
except Exception:
|
||
try:
|
||
self._group_proxy_initial_mat = LMatrix4f(proxy.getMat(self.model))
|
||
except Exception:
|
||
self._group_proxy_initial_mat = None
|
||
try:
|
||
self._group_proxy_source_initial_net_mat = LMatrix4f(
|
||
source_node.get_mat(self.source_model_root)
|
||
)
|
||
except Exception:
|
||
try:
|
||
self._group_proxy_source_initial_net_mat = LMatrix4f(
|
||
source_node.getMat(self.source_model_root)
|
||
)
|
||
except Exception:
|
||
self._group_proxy_source_initial_net_mat = None
|
||
|
||
if sync_world_selection:
|
||
self._sync_editor_selection_reference(proxy)
|
||
self._transform_gizmo.attach(proxy)
|
||
# For huge groups, avoid per-frame full sync; we still sync on demand
|
||
# right before picking via pick_object().
|
||
if len(valid) <= self._pick_sync_bg_limit:
|
||
self._start_pick_sync_task()
|
||
else:
|
||
self._stop_pick_sync_task()
|
||
|
||
def _rebuild_filtered_tree_rows(self):
|
||
"""
|
||
Build a flattened tree-row list with depth info for rendering in ImGui,
|
||
while preserving source-model parent/child hierarchy.
|
||
"""
|
||
self.filtered_nodes = []
|
||
if not self.controller or not self.controller.tree_root_key:
|
||
return
|
||
|
||
search_lower = self.search_text.strip().lower()
|
||
|
||
def walk(key, depth):
|
||
node = self.controller.tree_nodes.get(key)
|
||
if not node:
|
||
return False, []
|
||
|
||
# Skip redundant wrapper nodes (e.g. ROOT under model file root),
|
||
# while preserving child hierarchy and selection mapping.
|
||
if self.controller.should_hide_tree_node(key):
|
||
merged_rows = []
|
||
merged_visible = False
|
||
for child_key in node["children"]:
|
||
visible, rows = walk(child_key, depth)
|
||
if visible:
|
||
merged_visible = True
|
||
merged_rows.extend(rows)
|
||
return merged_visible, merged_rows
|
||
|
||
display = self.controller.display_names.get(key, key)
|
||
obj_count = len(self.controller.name_to_ids.get(key, []))
|
||
name_match = (not search_lower) or (search_lower in display.lower())
|
||
|
||
child_rows = []
|
||
child_match = False
|
||
for child_key in node["children"]:
|
||
visible, rows = walk(child_key, depth + 1)
|
||
if visible:
|
||
child_match = True
|
||
child_rows.extend(rows)
|
||
|
||
visible = (not search_lower) or name_match or child_match
|
||
if not visible:
|
||
return False, []
|
||
|
||
row = (key, depth, display, obj_count)
|
||
return True, [row] + child_rows
|
||
|
||
_, rows = walk(self.controller.tree_root_key, 0)
|
||
self.filtered_nodes = rows
|
||
|
||
def focus_on_selected(self):
|
||
transform_ids = self.get_selection_transform_ids()
|
||
if self.selected_name and transform_ids:
|
||
first_id = transform_ids[0]
|
||
pos = self.controller.get_world_pos(first_id)
|
||
dist = 100
|
||
self.base.camera.set_pos(pos.x, pos.y - dist, pos.z + dist * 0.5)
|
||
self.base.camera.look_at(pos)
|
||
|
||
def draw_imgui(self):
|
||
if not self.controller: return
|
||
|
||
imgui.set_next_window_pos((10, 10), imgui.Cond_.first_use_ever)
|
||
imgui.set_next_window_size((350, 600), imgui.Cond_.first_use_ever)
|
||
|
||
expanded, opened = imgui.begin("Scene Tree (Component)")
|
||
if expanded:
|
||
imgui.text(f"FPS: {globalClock.getAverageFrameRate():.1f}")
|
||
imgui.separator()
|
||
|
||
changed, self.search_text = imgui.input_text("Search", self.search_text, 256)
|
||
|
||
if imgui.begin_child("ObjectList", (0, 380), child_flags=imgui.ChildFlags_.borders):
|
||
if self.search_text != self.last_search_text or not self.filtered_nodes:
|
||
self.last_search_text = self.search_text
|
||
self._rebuild_filtered_tree_rows()
|
||
|
||
count = len(self.filtered_nodes)
|
||
clipper = imgui.ListClipper()
|
||
clipper.begin(count)
|
||
while clipper.step():
|
||
for i in range(clipper.display_start, clipper.display_end):
|
||
key, depth, display, geom_count = self.filtered_nodes[i]
|
||
indent = " " * depth
|
||
label = f"{indent}{display} ({geom_count})##{key}"
|
||
is_selected = (key == self.selected_name)
|
||
if imgui.selectable(label, is_selected)[0]:
|
||
self.select_node(key)
|
||
imgui.end_child()
|
||
|
||
imgui.separator()
|
||
if self.selected_name:
|
||
selected_display = self.controller.display_names.get(self.selected_name, self.selected_name)
|
||
imgui.text_colored((1, 0.8, 0.2, 1), f"Selected: {selected_display}")
|
||
if imgui.button("Focus (F)"): self.focus_on_selected()
|
||
imgui.end()
|
||
|
||
# swap_transforms_task removed - motion blur disabled for performance
|
||
|
||
def update_task(self, task):
|
||
dt = globalClock.getDt()
|
||
io = imgui.get_io()
|
||
self._sync_pick_model_transform()
|
||
self._refresh_ssbo_proxy_center()
|
||
self._sync_pick_scene_binding()
|
||
# Scene-hierarchy transforms may move the whole SSBO model root; keep pick root in sync.
|
||
self._sync_pick_root_transform()
|
||
|
||
if io.want_capture_keyboard: return task.cont
|
||
|
||
transform_ids = self.get_selection_transform_ids()
|
||
if transform_ids and self.controller:
|
||
speed = 50 * dt
|
||
acc = Vec3(0, 0, 0)
|
||
if self.keys.get('arrow_up'): acc.z += speed
|
||
if self.keys.get('arrow_down'): acc.z -= speed
|
||
if self.keys.get('arrow_left'): acc.x -= speed
|
||
if self.keys.get('arrow_right'): acc.x += speed
|
||
if self.keys.get('z'): acc.y += speed
|
||
if self.keys.get('x'): acc.y -= speed
|
||
|
||
if acc.length_squared() > 0:
|
||
is_root_selection = (
|
||
self.selected_name == getattr(self.controller, "tree_root_key", None)
|
||
)
|
||
if is_root_selection and self.model and not self.model.is_empty():
|
||
next_pos = self.model.get_pos() + acc
|
||
if hasattr(self.model, "set_fluid_pos"):
|
||
self.model.set_fluid_pos(next_pos)
|
||
else:
|
||
self.model.set_pos(next_pos)
|
||
self._sync_pick_root_transform()
|
||
else:
|
||
for idx in transform_ids:
|
||
self.controller.move_object(idx, acc)
|
||
|
||
return task.cont
|