1019 lines
37 KiB
Python
1019 lines
37 KiB
Python
"""
|
||
高级骨骼动画系统 - 工具模块
|
||
提供动画编辑、调试和分析工具
|
||
"""
|
||
|
||
import math
|
||
import json
|
||
from typing import Dict, List, Optional, Tuple, Any, Callable
|
||
from dataclasses import dataclass, field
|
||
from enum import Enum
|
||
|
||
from panda3d.core import *
|
||
from direct.actor.Actor import Actor
|
||
from direct.interval.IntervalGlobal import *
|
||
|
||
# 定义常量
|
||
TOOL_SETTINGS = {
|
||
'analyzer_update_rate': 10,
|
||
'debug_visualization_enabled': True,
|
||
'profiler_sampling_rate': 60
|
||
}
|
||
|
||
# 枚举定义
|
||
class AnimationAnalysisType(Enum):
|
||
"""动画分析类型枚举"""
|
||
PERFORMANCE = 0
|
||
QUALITY = 1
|
||
MEMORY = 2
|
||
COMPRESSION = 3
|
||
|
||
class DebugVisualizationMode(Enum):
|
||
"""调试可视化模式枚举"""
|
||
SKELETON = 0
|
||
BOUNDS = 1
|
||
NORMALS = 2
|
||
WIREFRAME = 3
|
||
COLLISION = 4
|
||
|
||
class AnimationEditMode(Enum):
|
||
"""动画编辑模式枚举"""
|
||
VIEW = 0
|
||
EDIT_KEYFRAME = 1
|
||
EDIT_CURVE = 2
|
||
EDIT_BONE = 3
|
||
|
||
@dataclass
|
||
class AnimationAnalysisResult:
|
||
"""动画分析结果数据类"""
|
||
actor_id: str
|
||
anim_name: str
|
||
analysis_type: AnimationAnalysisType
|
||
metrics: Dict[str, Any]
|
||
timestamp: float
|
||
recommendations: List[str] = field(default_factory=list)
|
||
|
||
@dataclass
|
||
class AnimationEditorState:
|
||
"""动画编辑器状态数据类"""
|
||
actor_id: str
|
||
anim_name: str
|
||
current_frame: int
|
||
selected_bones: List[str]
|
||
edit_mode: AnimationEditMode
|
||
keyframe_selection: List[int]
|
||
curve_editor_state: Dict[str, Any]
|
||
|
||
@dataclass
|
||
class PerformanceMetrics:
|
||
"""性能指标数据类"""
|
||
fps: float
|
||
frame_time: float
|
||
animation_update_time: float
|
||
memory_usage: int
|
||
actor_count: int
|
||
active_animations: int
|
||
|
||
class AnimationAnalyzer:
|
||
"""
|
||
动画分析器
|
||
提供动画性能、质量和内存使用分析
|
||
"""
|
||
|
||
def __init__(self, core_system):
|
||
"""
|
||
初始化动画分析器
|
||
:param core_system: 核心动画系统
|
||
"""
|
||
self.core_system = core_system
|
||
self.analysis_history: List[AnimationAnalysisResult] = []
|
||
self.is_analyzing = False
|
||
self.update_rate = TOOL_SETTINGS['analyzer_update_rate']
|
||
self.last_update_time = 0.0
|
||
|
||
print("动画分析器初始化完成")
|
||
|
||
def start_analysis(self) -> None:
|
||
"""
|
||
开始分析
|
||
"""
|
||
self.is_analyzing = True
|
||
print("动画分析已启动")
|
||
|
||
def stop_analysis(self) -> None:
|
||
"""
|
||
停止分析
|
||
"""
|
||
self.is_analyzing = False
|
||
print("动画分析已停止")
|
||
|
||
def analyze_animation(self, actor_id: str, anim_name: str,
|
||
analysis_type: AnimationAnalysisType = AnimationAnalysisType.PERFORMANCE) -> Optional[AnimationAnalysisResult]:
|
||
"""
|
||
分析指定动画
|
||
:param actor_id: Actor ID
|
||
:param anim_name: 动画名称
|
||
:param analysis_type: 分析类型
|
||
:return: 分析结果
|
||
"""
|
||
if actor_id not in self.core_system.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return None
|
||
|
||
actor_info = self.core_system.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
if anim_name not in actor.getAnimNames():
|
||
print(f"错误: 动画 {anim_name} 不存在于Actor {actor_id} 中")
|
||
return None
|
||
|
||
metrics = {}
|
||
recommendations = []
|
||
|
||
# 根据分析类型执行不同的分析
|
||
if analysis_type == AnimationAnalysisType.PERFORMANCE:
|
||
result = self._analyze_performance(actor_info, anim_name)
|
||
metrics.update(result[0])
|
||
recommendations.extend(result[1])
|
||
elif analysis_type == AnimationAnalysisType.QUALITY:
|
||
result = self._analyze_quality(actor_info, anim_name)
|
||
metrics.update(result[0])
|
||
recommendations.extend(result[1])
|
||
elif analysis_type == AnimationAnalysisType.MEMORY:
|
||
result = self._analyze_memory(actor_info, anim_name)
|
||
metrics.update(result[0])
|
||
recommendations.extend(result[1])
|
||
elif analysis_type == AnimationAnalysisType.COMPRESSION:
|
||
result = self._analyze_compression(actor_info, anim_name)
|
||
metrics.update(result[0])
|
||
recommendations.extend(result[1])
|
||
|
||
# 创建分析结果
|
||
analysis_result = AnimationAnalysisResult(
|
||
actor_id=actor_id,
|
||
anim_name=anim_name,
|
||
analysis_type=analysis_type,
|
||
metrics=metrics,
|
||
timestamp=globalClock.getRealTime(),
|
||
recommendations=recommendations
|
||
)
|
||
|
||
# 添加到历史记录
|
||
self.analysis_history.append(analysis_result)
|
||
if len(self.analysis_history) > 100: # 限制历史记录大小
|
||
self.analysis_history.pop(0)
|
||
|
||
return analysis_result
|
||
|
||
def _analyze_performance(self, actor_info: Any, anim_name: str) -> Tuple[Dict[str, Any], List[str]]:
|
||
"""
|
||
分析动画性能
|
||
:param actor_info: Actor信息
|
||
:param anim_name: 动画名称
|
||
:return: (指标, 建议)
|
||
"""
|
||
actor = actor_info.actor
|
||
metrics = {}
|
||
recommendations = []
|
||
|
||
# 获取动画控制
|
||
control = actor.getAnimControl(anim_name)
|
||
if control:
|
||
# 基本性能指标
|
||
metrics['frame_rate'] = actor.getFrameRate(anim_name)
|
||
metrics['num_frames'] = actor.getNumFrames(anim_name)
|
||
metrics['duration'] = control.getDuration()
|
||
metrics['is_looping'] = control.getLoop()
|
||
|
||
# 性能建议
|
||
if metrics['frame_rate'] and metrics['frame_rate'] < 15:
|
||
recommendations.append("动画帧率过低，建议优化关键帧")
|
||
|
||
if metrics['num_frames'] and metrics['num_frames'] > 1000:
|
||
recommendations.append("动画帧数过多，考虑分割或简化")
|
||
|
||
# 骨骼数量分析
|
||
bundle = actor.getPartBundleDict().get('modelRoot')
|
||
if bundle:
|
||
bone_count = bundle.getNumChildren()
|
||
metrics['bone_count'] = bone_count
|
||
|
||
if bone_count > 100:
|
||
recommendations.append("骨骼数量较多，可能影响性能")
|
||
|
||
return metrics, recommendations
|
||
|
||
def _analyze_quality(self, actor_info: Any, anim_name: str) -> Tuple[Dict[str, Any], List[str]]:
|
||
"""
|
||
分析动画质量
|
||
:param actor_info: Actor信息
|
||
:param anim_name: 动画名称
|
||
:return: (指标, 建议)
|
||
"""
|
||
actor = actor_info.actor
|
||
metrics = {}
|
||
recommendations = []
|
||
|
||
# 检查动画是否存在突变
|
||
prev_frame_data = None
|
||
large_changes = 0
|
||
|
||
control = actor.getAnimControl(anim_name)
|
||
if control:
|
||
num_frames = control.getNumFrames()
|
||
for frame in range(min(100, num_frames)): # 采样前100帧
|
||
actor.pose(anim_name, frame)
|
||
|
||
# 检查所有骨骼的变化
|
||
bundle = actor.getPartBundleDict().get('modelRoot')
|
||
if bundle:
|
||
for i in range(min(10, bundle.getNumChildren())): # 检查前10个骨骼
|
||
child = bundle.getChild(i)
|
||
if hasattr(child, 'getName'):
|
||
bone_name = child.getName()
|
||
joint = actor.exposeJoint(None, "modelRoot", bone_name)
|
||
if joint:
|
||
current_pos = joint.getPos()
|
||
if prev_frame_data and bone_name in prev_frame_data:
|
||
prev_pos = prev_frame_data[bone_name]
|
||
distance = (current_pos - prev_pos).length()
|
||
if distance > 1.0: # 阈值
|
||
large_changes += 1
|
||
|
||
if bone_name not in prev_frame_data:
|
||
prev_frame_data = {}
|
||
prev_frame_data[bone_name] = current_pos
|
||
|
||
metrics['large_position_changes'] = large_changes
|
||
|
||
if large_changes > 10:
|
||
recommendations.append("检测到大量位置突变，可能存在动画质量问题")
|
||
|
||
return metrics, recommendations
|
||
|
||
def _analyze_memory(self, actor_info: Any, anim_name: str) -> Tuple[Dict[str, Any], List[str]]:
|
||
"""
|
||
分析动画内存使用
|
||
:param actor_info: Actor信息
|
||
:param anim_name: 动画名称
|
||
:return: (指标, 建议)
|
||
"""
|
||
actor = actor_info.actor
|
||
metrics = {}
|
||
recommendations = []
|
||
|
||
# 估算内存使用 (简化)
|
||
control = actor.getAnimControl(anim_name)
|
||
if control:
|
||
num_frames = control.getNumFrames()
|
||
bundle = actor.getPartBundleDict().get('modelRoot')
|
||
bone_count = bundle.getNumChildren() if bundle else 0
|
||
|
||
# 简化的内存估算公式
|
||
estimated_memory = num_frames * bone_count * 64 # 每个骨骼关键帧约64字节
|
||
metrics['estimated_memory_bytes'] = estimated_memory
|
||
metrics['estimated_memory_kb'] = estimated_memory / 1024
|
||
|
||
if estimated_memory > 1024 * 1024: # 超过1MB
|
||
recommendations.append("动画内存使用较大，考虑压缩或简化")
|
||
|
||
return metrics, recommendations
|
||
|
||
def _analyze_compression(self, actor_info: Any, anim_name: str) -> Tuple[Dict[str, Any], List[str]]:
|
||
"""
|
||
分析动画压缩潜力
|
||
:param actor_info: Actor信息
|
||
:param anim_name: 动画名称
|
||
:return: (指标, 建议)
|
||
"""
|
||
actor = actor_info.actor
|
||
metrics = {}
|
||
recommendations = []
|
||
|
||
# 检查关键帧密度
|
||
control = actor.getAnimControl(anim_name)
|
||
if control:
|
||
num_frames = control.getNumFrames()
|
||
duration = control.getDuration()
|
||
|
||
if duration > 0:
|
||
fps = num_frames / duration
|
||
metrics['actual_fps'] = fps
|
||
|
||
# 检查是否可以降低帧率
|
||
if fps > 30:
|
||
metrics['recommended_fps'] = 30
|
||
recommendations.append(f"可以将帧率从{fps:.1f}降低到30以节省内存")
|
||
elif fps > 15:
|
||
metrics['recommended_fps'] = 15
|
||
recommendations.append(f"可以将帧率从{fps:.1f}降低到15以节省内存")
|
||
|
||
return metrics, recommendations
|
||
|
||
def get_actor_analysis_summary(self, actor_id: str) -> Optional[Dict[str, Any]]:
|
||
"""
|
||
获取Actor分析摘要
|
||
:param actor_id: Actor ID
|
||
:return: 分析摘要
|
||
"""
|
||
if actor_id not in self.core_system.actors:
|
||
return None
|
||
|
||
# 获取最新的分析结果
|
||
actor_analyses = [a for a in self.analysis_history if a.actor_id == actor_id]
|
||
if not actor_analyses:
|
||
return None
|
||
|
||
# 统计各类分析结果
|
||
performance_issues = len([a for a in actor_analyses
|
||
if a.analysis_type == AnimationAnalysisType.PERFORMANCE and a.recommendations])
|
||
quality_issues = len([a for a in actor_analyses
|
||
if a.analysis_type == AnimationAnalysisType.QUALITY and a.recommendations])
|
||
memory_issues = len([a for a in actor_analyses
|
||
if a.analysis_type == AnimationAnalysisType.MEMORY and a.recommendations])
|
||
|
||
return {
|
||
'actor_id': actor_id,
|
||
'total_analyses': len(actor_analyses),
|
||
'performance_issues': performance_issues,
|
||
'quality_issues': quality_issues,
|
||
'memory_issues': memory_issues,
|
||
'last_analysis_time': actor_analyses[-1].timestamp if actor_analyses else 0
|
||
}
|
||
|
||
def get_system_analysis_summary(self) -> Dict[str, Any]:
|
||
"""
|
||
获取系统分析摘要
|
||
:return: 分析摘要
|
||
"""
|
||
total_analyses = len(self.analysis_history)
|
||
actors_with_issues = len(set(a.actor_id for a in self.analysis_history if a.recommendations))
|
||
|
||
return {
|
||
'total_analyses': total_analyses,
|
||
'actors_analyzed': len(set(a.actor_id for a in self.analysis_history)),
|
||
'actors_with_issues': actors_with_issues,
|
||
'performance_analyses': len([a for a in self.analysis_history
|
||
if a.analysis_type == AnimationAnalysisType.PERFORMANCE]),
|
||
'quality_analyses': len([a for a in self.analysis_history
|
||
if a.analysis_type == AnimationAnalysisType.QUALITY]),
|
||
'memory_analyses': len([a for a in self.analysis_history
|
||
if a.analysis_type == AnimationAnalysisType.MEMORY])
|
||
}
|
||
|
||
class AnimationEditor:
|
||
"""
|
||
动画编辑器
|
||
提供关键帧编辑、曲线编辑等功能
|
||
"""
|
||
|
||
def __init__(self, core_system):
|
||
"""
|
||
初始化动画编辑器
|
||
:param core_system: 核心动画系统
|
||
"""
|
||
self.core_system = core_system
|
||
self.editor_states: Dict[str, AnimationEditorState] = {}
|
||
self.is_editing = False
|
||
self.edit_callbacks: List[Callable] = []
|
||
|
||
print("动画编辑器初始化完成")
|
||
|
||
def start_editing(self, actor_id: str, anim_name: str) -> bool:
|
||
"""
|
||
开始编辑动画
|
||
:param actor_id: Actor ID
|
||
:param anim_name: 动画名称
|
||
:return: 是否成功开始编辑
|
||
"""
|
||
if actor_id not in self.core_system.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return False
|
||
|
||
actor_info = self.core_system.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
if anim_name not in actor.getAnimNames():
|
||
print(f"错误: 动画 {anim_name} 不存在于Actor {actor_id} 中")
|
||
return False
|
||
|
||
# 创建编辑器状态
|
||
editor_state = AnimationEditorState(
|
||
actor_id=actor_id,
|
||
anim_name=anim_name,
|
||
current_frame=0,
|
||
selected_bones=[],
|
||
edit_mode=AnimationEditMode.VIEW,
|
||
keyframe_selection=[],
|
||
curve_editor_state={}
|
||
)
|
||
|
||
self.editor_states[f"{actor_id}:{anim_name}"] = editor_state
|
||
self.is_editing = True
|
||
|
||
print(f"开始编辑动画: {anim_name} (Actor: {actor_id})")
|
||
return True
|
||
|
||
def stop_editing(self, actor_id: str, anim_name: str) -> None:
|
||
"""
|
||
停止编辑动画
|
||
:param actor_id: Actor ID
|
||
:param anim_name: 动画名称
|
||
"""
|
||
key = f"{actor_id}:{anim_name}"
|
||
if key in self.editor_states:
|
||
del self.editor_states[key]
|
||
|
||
if not self.editor_states:
|
||
self.is_editing = False
|
||
|
||
print(f"停止编辑动画: {anim_name} (Actor: {actor_id})")
|
||
|
||
def set_edit_mode(self, actor_id: str, anim_name: str, mode: AnimationEditMode) -> None:
|
||
"""
|
||
设置编辑模式
|
||
:param actor_id: Actor ID
|
||
:param anim_name: 动画名称
|
||
:param mode: 编辑模式
|
||
"""
|
||
key = f"{actor_id}:{anim_name}"
|
||
if key in self.editor_states:
|
||
self.editor_states[key].edit_mode = mode
|
||
print(f"设置编辑模式为: {mode.name} (Actor: {actor_id}, 动画: {anim_name})")
|
||
|
||
def select_bones(self, actor_id: str, anim_name: str, bone_names: List[str]) -> None:
|
||
"""
|
||
选择骨骼
|
||
:param actor_id: Actor ID
|
||
:param anim_name: 动画名称
|
||
:param bone_names: 骨骼名称列表
|
||
"""
|
||
key = f"{actor_id}:{anim_name}"
|
||
if key in self.editor_states:
|
||
self.editor_states[key].selected_bones = bone_names
|
||
print(f"选择骨骼: {bone_names} (Actor: {actor_id}, 动画: {anim_name})")
|
||
|
||
def set_current_frame(self, actor_id: str, anim_name: str, frame: int) -> None:
|
||
"""
|
||
设置当前帧
|
||
:param actor_id: Actor ID
|
||
:param anim_name: 动画名称
|
||
:param frame: 帧号
|
||
"""
|
||
key = f"{actor_id}:{anim_name}"
|
||
if key in self.editor_states:
|
||
editor_state = self.editor_states[key]
|
||
editor_state.current_frame = frame
|
||
|
||
# 定位到指定帧
|
||
actor_info = self.core_system.actors[actor_id]
|
||
actor_info.actor.pose(anim_name, frame)
|
||
|
||
print(f"设置当前帧为: {frame} (Actor: {actor_id}, 动画: {anim_name})")
|
||
|
||
def add_keyframe(self, actor_id: str, anim_name: str, bone_name: str,
|
||
frame: int, position: Optional[Tuple[float, float, float]] = None,
|
||
rotation: Optional[Tuple[float, float, float]] = None,
|
||
scale: Optional[Tuple[float, float, float]] = None) -> None:
|
||
"""
|
||
添加关键帧
|
||
:param actor_id: Actor ID
|
||
:param anim_name: 动画名称
|
||
:param bone_name: 骨骼名称
|
||
:param frame: 帧号
|
||
:param position: 位置
|
||
:param rotation: 旋转
|
||
:param scale: 缩放
|
||
"""
|
||
# 这是一个简化的实现，实际项目中需要直接操作动画数据
|
||
print(f"添加关键帧: 骨骼={bone_name}, 帧={frame} (Actor: {actor_id}, 动画: {anim_name})")
|
||
print(f" 位置: {position}")
|
||
print(f" 旋转: {rotation}")
|
||
print(f" 缩放: {scale}")
|
||
|
||
# 触发编辑回调
|
||
for callback in self.edit_callbacks:
|
||
try:
|
||
callback('add_keyframe', {
|
||
'actor_id': actor_id,
|
||
'anim_name': anim_name,
|
||
'bone_name': bone_name,
|
||
'frame': frame,
|
||
'position': position,
|
||
'rotation': rotation,
|
||
'scale': scale
|
||
})
|
||
except Exception as e:
|
||
print(f"执行编辑回调失败: {e}")
|
||
|
||
def remove_keyframe(self, actor_id: str, anim_name: str, bone_name: str, frame: int) -> None:
|
||
"""
|
||
移除关键帧
|
||
:param actor_id: Actor ID
|
||
:param anim_name: 动画名称
|
||
:param bone_name: 骨骼名称
|
||
:param frame: 帧号
|
||
"""
|
||
print(f"移除关键帧: 骨骼={bone_name}, 帧={frame} (Actor: {actor_id}, 动画: {anim_name})")
|
||
|
||
# 触发编辑回调
|
||
for callback in self.edit_callbacks:
|
||
try:
|
||
callback('remove_keyframe', {
|
||
'actor_id': actor_id,
|
||
'anim_name': anim_name,
|
||
'bone_name': bone_name,
|
||
'frame': frame
|
||
})
|
||
except Exception as e:
|
||
print(f"执行编辑回调失败: {e}")
|
||
|
||
def modify_keyframe(self, actor_id: str, anim_name: str, bone_name: str, frame: int,
|
||
position: Optional[Tuple[float, float, float]] = None,
|
||
rotation: Optional[Tuple[float, float, float]] = None,
|
||
scale: Optional[Tuple[float, float, float]] = None) -> None:
|
||
"""
|
||
修改关键帧
|
||
:param actor_id: Actor ID
|
||
:param anim_name: 动画名称
|
||
:param bone_name: 骨骼名称
|
||
:param frame: 帧号
|
||
:param position: 新位置
|
||
:param rotation: 新旋转
|
||
:param scale: 新缩放
|
||
"""
|
||
print(f"修改关键帧: 骨骼={bone_name}, 帧={frame} (Actor: {actor_id}, 动画: {anim_name})")
|
||
print(f" 新位置: {position}")
|
||
print(f" 新旋转: {rotation}")
|
||
print(f" 新缩放: {scale}")
|
||
|
||
# 触发编辑回调
|
||
for callback in self.edit_callbacks:
|
||
try:
|
||
callback('modify_keyframe', {
|
||
'actor_id': actor_id,
|
||
'anim_name': anim_name,
|
||
'bone_name': bone_name,
|
||
'frame': frame,
|
||
'position': position,
|
||
'rotation': rotation,
|
||
'scale': scale
|
||
})
|
||
except Exception as e:
|
||
print(f"执行编辑回调失败: {e}")
|
||
|
||
def add_edit_callback(self, callback: Callable) -> None:
|
||
"""
|
||
添加编辑回调
|
||
:param callback: 回调函数
|
||
"""
|
||
self.edit_callbacks.append(callback)
|
||
print("添加编辑回调")
|
||
|
||
def remove_edit_callback(self, callback: Callable) -> None:
|
||
"""
|
||
移除编辑回调
|
||
:param callback: 回调函数
|
||
"""
|
||
if callback in self.edit_callbacks:
|
||
self.edit_callbacks.remove(callback)
|
||
print("移除编辑回调")
|
||
|
||
class DebugVisualizer:
|
||
"""
|
||
调试可视化工具
|
||
提供骨骼、边界框等可视化功能
|
||
"""
|
||
|
||
def __init__(self, world):
|
||
"""
|
||
初始化调试可视化工具
|
||
:param world: 世界对象
|
||
"""
|
||
self.world = world
|
||
self.visualizations: Dict[str, NodePath] = {}
|
||
self.enabled = TOOL_SETTINGS['debug_visualization_enabled']
|
||
self.mode = DebugVisualizationMode.SKELETON
|
||
|
||
print("调试可视化工具初始化完成")
|
||
|
||
def set_mode(self, mode: DebugVisualizationMode) -> None:
|
||
"""
|
||
设置可视化模式
|
||
:param mode: 模式
|
||
"""
|
||
self.mode = mode
|
||
print(f"调试可视化模式设置为: {mode.name}")
|
||
|
||
def enable_visualization(self, enabled: bool = True) -> None:
|
||
"""
|
||
启用/禁用可视化
|
||
:param enabled: 是否启用
|
||
"""
|
||
self.enabled = enabled
|
||
if not enabled:
|
||
self.clear_all_visualizations()
|
||
print(f"调试可视化已{'启用' if enabled else '禁用'}")
|
||
|
||
def visualize_actor_skeleton(self, actor_id: str, actor: Actor) -> None:
|
||
"""
|
||
可视化Actor骨骼
|
||
:param actor_id: Actor ID
|
||
:param actor: Actor对象
|
||
"""
|
||
if not self.enabled or self.mode != DebugVisualizationMode.SKELETON:
|
||
return
|
||
|
||
# 清除旧的可视化
|
||
self.clear_visualization(actor_id)
|
||
|
||
# 创建骨骼可视化节点
|
||
skeleton_node = self.world.render.attachNewNode(f"skeleton_vis_{actor_id}")
|
||
self.visualizations[actor_id] = skeleton_node
|
||
|
||
# 获取骨骼信息并绘制连线
|
||
bundle = actor.getPartBundleDict().get('modelRoot')
|
||
if bundle:
|
||
self._draw_skeleton_hierarchy(actor, bundle, skeleton_node)
|
||
|
||
def _draw_skeleton_hierarchy(self, actor: Actor, bundle, parent_node: NodePath) -> None:
|
||
"""
|
||
绘制骨骼层级
|
||
:param actor: Actor对象
|
||
:param bundle: 骨骼包
|
||
:param parent_node: 父节点
|
||
"""
|
||
# 这里简化实现，实际项目中需要遍历骨骼树并绘制连线
|
||
# 可以使用LineSegs或其他Panda3D绘图功能
|
||
|
||
# 示例：绘制一个简单的可视化表示
|
||
from panda3d.core import LineSegs
|
||
|
||
segs = LineSegs(f"skeleton_lines_{actor.getName()}")
|
||
segs.setColor(0, 1, 0, 1) # 绿色
|
||
segs.setThickness(2.0)
|
||
|
||
# 从根节点到各个子节点绘制线段（简化）
|
||
root_pos = Point3(0, 0, 0)
|
||
segs.moveTo(root_pos)
|
||
|
||
for i in range(min(5, bundle.getNumChildren())): # 只绘制前5个骨骼
|
||
child = bundle.getChild(i)
|
||
if hasattr(child, 'getName'):
|
||
bone_name = child.getName()
|
||
joint = actor.exposeJoint(None, "modelRoot", bone_name)
|
||
if joint:
|
||
joint_pos = joint.getPos()
|
||
segs.drawTo(joint_pos)
|
||
segs.moveTo(root_pos)
|
||
|
||
# 创建节点并附加到场景
|
||
lines_node = segs.create()
|
||
np = parent_node.attachNewNode(lines_node)
|
||
np.setBin("fixed", 40)
|
||
np.setDepthTest(False)
|
||
np.setDepthWrite(False)
|
||
|
||
def visualize_actor_bounds(self, actor_id: str, actor: Actor) -> None:
|
||
"""
|
||
可视化Actor边界框
|
||
:param actor_id: Actor ID
|
||
:param actor: Actor对象
|
||
"""
|
||
if not self.enabled or self.mode != DebugVisualizationMode.BOUNDS:
|
||
return
|
||
|
||
# 清除旧的可视化
|
||
self.clear_visualization(actor_id)
|
||
|
||
# 获取边界框
|
||
bounds = actor.getTightBounds()
|
||
if bounds:
|
||
min_point, max_point = bounds
|
||
|
||
# 创建边界框可视化
|
||
from panda3d.core import LineSegs
|
||
|
||
segs = LineSegs(f"bounds_vis_{actor_id}")
|
||
segs.setColor(1, 0, 0, 1) # 红色
|
||
segs.setThickness(1.0)
|
||
|
||
# 绘制立方体边界框
|
||
self._draw_wire_cube(segs, min_point, max_point)
|
||
|
||
# 创建节点并附加到场景
|
||
bounds_node = self.world.render.attachNewNode(segs.create())
|
||
bounds_node.setBin("fixed", 40)
|
||
bounds_node.setDepthTest(False)
|
||
bounds_node.setDepthWrite(False)
|
||
|
||
self.visualizations[actor_id] = bounds_node
|
||
|
||
def _draw_wire_cube(self, segs: LineSegs, min_point: Point3, max_point: Point3) -> None:
|
||
"""
|
||
绘制线框立方体
|
||
:param segs: LineSegs对象
|
||
:param min_point: 最小点
|
||
:param max_point: 最大点
|
||
"""
|
||
# 获取立方体的8个顶点
|
||
vertices = [
|
||
Point3(min_point.x, min_point.y, min_point.z),
|
||
Point3(max_point.x, min_point.y, min_point.z),
|
||
Point3(max_point.x, max_point.y, min_point.z),
|
||
Point3(min_point.x, max_point.y, min_point.z),
|
||
Point3(min_point.x, min_point.y, max_point.z),
|
||
Point3(max_point.x, min_point.y, max_point.z),
|
||
Point3(max_point.x, max_point.y, max_point.z),
|
||
Point3(min_point.x, max_point.y, max_point.z)
|
||
]
|
||
|
||
# 绘制12条边
|
||
edges = [
|
||
(0, 1), (1, 2), (2, 3), (3, 0), # 底面
|
||
(4, 5), (5, 6), (6, 7), (7, 4), # 顶面
|
||
(0, 4), (1, 5), (2, 6), (3, 7) # 垂直边
|
||
]
|
||
|
||
for start, end in edges:
|
||
segs.moveTo(vertices[start])
|
||
segs.drawTo(vertices[end])
|
||
|
||
def clear_visualization(self, actor_id: str) -> None:
|
||
"""
|
||
清除指定Actor的可视化
|
||
:param actor_id: Actor ID
|
||
"""
|
||
if actor_id in self.visualizations:
|
||
self.visualizations[actor_id].removeNode()
|
||
del self.visualizations[actor_id]
|
||
|
||
def clear_all_visualizations(self) -> None:
|
||
"""
|
||
清除所有可视化
|
||
"""
|
||
for np in self.visualizations.values():
|
||
np.removeNode()
|
||
self.visualizations.clear()
|
||
|
||
def update_visualizations(self, actors: Dict[str, Any]) -> None:
|
||
"""
|
||
更新所有可视化
|
||
:param actors: Actor字典
|
||
"""
|
||
if not self.enabled:
|
||
return
|
||
|
||
for actor_id, actor_info in actors.items():
|
||
actor = actor_info.actor
|
||
|
||
if self.mode == DebugVisualizationMode.SKELETON:
|
||
self.visualize_actor_skeleton(actor_id, actor)
|
||
elif self.mode == DebugVisualizationMode.BOUNDS:
|
||
self.visualize_actor_bounds(actor_id, actor)
|
||
|
||
class AnimationProfiler:
|
||
"""
|
||
动画性能分析器
|
||
提供详细的性能分析和优化建议
|
||
"""
|
||
|
||
def __init__(self, core_system):
|
||
"""
|
||
初始化动画性能分析器
|
||
:param core_system: 核心动画系统
|
||
"""
|
||
self.core_system = core_system
|
||
self.sampling_rate = TOOL_SETTINGS['profiler_sampling_rate']
|
||
self.is_profiling = False
|
||
self.profile_data: List[PerformanceMetrics] = []
|
||
self.last_sample_time = 0.0
|
||
|
||
print("动画性能分析器初始化完成")
|
||
|
||
def start_profiling(self) -> None:
|
||
"""
|
||
开始性能分析
|
||
"""
|
||
self.is_profiling = True
|
||
print("动画性能分析已启动")
|
||
|
||
def stop_profiling(self) -> None:
|
||
"""
|
||
停止性能分析
|
||
"""
|
||
self.is_profiling = False
|
||
print("动画性能分析已停止")
|
||
|
||
def sample_performance(self) -> None:
|
||
"""
|
||
采样性能数据
|
||
"""
|
||
if not self.is_profiling:
|
||
return
|
||
|
||
current_time = globalClock.getRealTime()
|
||
if current_time - self.last_sample_time < 1.0 / self.sampling_rate:
|
||
return
|
||
|
||
self.last_sample_time = current_time
|
||
|
||
# 收集性能指标
|
||
metrics = self._collect_metrics()
|
||
self.profile_data.append(metrics)
|
||
|
||
# 限制数据大小
|
||
if len(self.profile_data) > 1000:
|
||
self.profile_data.pop(0)
|
||
|
||
def _collect_metrics(self) -> PerformanceMetrics:
|
||
"""
|
||
收集性能指标
|
||
:return: 性能指标
|
||
"""
|
||
# 获取FPS和帧时间
|
||
fps = globalClock.getAverageFrameRate()
|
||
frame_time = globalClock.getDt()
|
||
|
||
# 估算动画更新时间（简化）
|
||
animation_update_time = frame_time * 0.3 # 假设动画更新占总帧时间的30%
|
||
|
||
# 估算内存使用（简化）
|
||
memory_usage = len(self.core_system.actors) * 1024 * 1024 # 假设每个Actor约1MB
|
||
|
||
# 统计Actor和动画数量
|
||
actor_count = len(self.core_system.actors)
|
||
active_animations = sum(len(info.active_animations) for info in self.core_system.actors.values())
|
||
|
||
return PerformanceMetrics(
|
||
fps=fps,
|
||
frame_time=frame_time,
|
||
animation_update_time=animation_update_time,
|
||
memory_usage=memory_usage,
|
||
actor_count=actor_count,
|
||
active_animations=active_animations
|
||
)
|
||
|
||
def get_performance_report(self) -> Dict[str, Any]:
|
||
"""
|
||
获取性能报告
|
||
:return: 性能报告
|
||
"""
|
||
if not self.profile_data:
|
||
return {}
|
||
|
||
# 计算统计数据
|
||
fps_values = [m.fps for m in self.profile_data]
|
||
frame_time_values = [m.frame_time for m in self.profile_data]
|
||
update_time_values = [m.animation_update_time for m in self.profile_data]
|
||
memory_values = [m.memory_usage for m in self.profile_data]
|
||
|
||
return {
|
||
'sample_count': len(self.profile_data),
|
||
'duration_seconds': len(self.profile_data) / self.sampling_rate,
|
||
'fps': {
|
||
'average': sum(fps_values) / len(fps_values),
|
||
'min': min(fps_values),
|
||
'max': max(fps_values),
|
||
'std_dev': self._calculate_std_dev(fps_values)
|
||
},
|
||
'frame_time': {
|
||
'average': sum(frame_time_values) / len(frame_time_values),
|
||
'min': min(frame_time_values),
|
||
'max': max(frame_time_values),
|
||
'std_dev': self._calculate_std_dev(frame_time_values)
|
||
},
|
||
'animation_update_time': {
|
||
'average': sum(update_time_values) / len(update_time_values),
|
||
'min': min(update_time_values),
|
||
'max': max(update_time_values),
|
||
'std_dev': self._calculate_std_dev(update_time_values)
|
||
},
|
||
'memory_usage': {
|
||
'average': sum(memory_values) / len(memory_values),
|
||
'min': min(memory_values),
|
||
'max': max(memory_values),
|
||
'current': memory_values[-1] if memory_values else 0
|
||
},
|
||
'actor_stats': {
|
||
'current_actor_count': self.profile_data[-1].actor_count if self.profile_data else 0,
|
||
'current_active_animations': self.profile_data[-1].active_animations if self.profile_data else 0
|
||
}
|
||
}
|
||
|
||
def _calculate_std_dev(self, values: List[float]) -> float:
|
||
"""
|
||
计算标准差
|
||
:param values: 数值列表
|
||
:return: 标准差
|
||
"""
|
||
if len(values) < 2:
|
||
return 0.0
|
||
|
||
mean = sum(values) / len(values)
|
||
variance = sum((x - mean) ** 2 for x in values) / (len(values) - 1)
|
||
return math.sqrt(variance)
|
||
|
||
def get_optimization_recommendations(self) -> List[str]:
|
||
"""
|
||
获取优化建议
|
||
:return: 优化建议列表
|
||
"""
|
||
if not self.profile_data:
|
||
return []
|
||
|
||
latest = self.profile_data[-1]
|
||
recommendations = []
|
||
|
||
# FPS相关建议
|
||
if latest.fps < 30:
|
||
recommendations.append("FPS过低，建议优化动画系统或减少同时播放的动画数量")
|
||
|
||
# 内存相关建议
|
||
if latest.memory_usage > 512 * 1024 * 1024: # 超过512MB
|
||
recommendations.append("内存使用过高，建议检查Actor加载和卸载逻辑")
|
||
|
||
# Actor数量建议
|
||
if latest.actor_count > 100:
|
||
recommendations.append("Actor数量较多，建议使用LOD或视锥剔除优化")
|
||
|
||
# 动画数量建议
|
||
if latest.active_animations > 200:
|
||
recommendations.append("同时播放的动画过多，建议限制同时活动的动画数量")
|
||
|
||
return recommendations
|
||
|
||
# 使用示例和测试代码
|
||
def example_analyzer_usage(core_system):
|
||
"""
|
||
动画分析器使用示例
|
||
"""
|
||
print("=== 动画分析器使用示例 ===")
|
||
|
||
# 创建分析器
|
||
analyzer = AnimationAnalyzer(core_system)
|
||
analyzer.start_analysis()
|
||
|
||
# 分析示例（假设有Actor）
|
||
# 在实际使用中，这里会分析真实的Actor和动画
|
||
print("动画分析器示例完成")
|
||
return analyzer
|
||
|
||
def example_editor_usage(core_system):
|
||
"""
|
||
动画编辑器使用示例
|
||
"""
|
||
print("=== 动画编辑器使用示例 ===")
|
||
|
||
# 创建编辑器
|
||
editor = AnimationEditor(core_system)
|
||
|
||
# 添加编辑回调
|
||
def edit_callback(event_type, data):
|
||
print(f"编辑事件: {event_type}, 数据: {data}")
|
||
|
||
editor.add_edit_callback(edit_callback)
|
||
|
||
print("动画编辑器示例完成")
|
||
return editor
|
||
|
||
def example_visualizer_usage(world):
|
||
"""
|
||
调试可视化工具使用示例
|
||
"""
|
||
print("=== 调试可视化工具使用示例 ===")
|
||
|
||
# 创建可视化工具
|
||
visualizer = DebugVisualizer(world)
|
||
visualizer.enable_visualization(True)
|
||
visualizer.set_mode(DebugVisualizationMode.SKELETON)
|
||
|
||
print("调试可视化工具示例完成")
|
||
return visualizer
|
||
|
||
def example_profiler_usage(core_system):
|
||
"""
|
||
动画性能分析器使用示例
|
||
"""
|
||
print("=== 动画性能分析器使用示例 ===")
|
||
|
||
# 创建分析器
|
||
profiler = AnimationProfiler(core_system)
|
||
profiler.start_profiling()
|
||
|
||
# 采样性能数据
|
||
profiler.sample_performance()
|
||
|
||
# 获取性能报告
|
||
report = profiler.get_performance_report()
|
||
print(f"性能报告: {report}")
|
||
|
||
# 获取优化建议
|
||
recommendations = profiler.get_optimization_recommendations()
|
||
print(f"优化建议: {recommendations}")
|
||
|
||
print("动画性能分析器示例完成")
|
||
return profiler
|
||
|
||
if __name__ == "__main__":
|
||
print("动画工具模块加载完成") |