""" 高级骨骼动画系统 - 工具模块 提供动画编辑、调试和分析工具 """ 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("动画工具模块加载完成")