1207 lines
43 KiB
Python
1207 lines
43 KiB
Python
"""
|
||
高级骨骼动画系统 - 核心模块
|
||
提供完整的骨骼动画支持，包括加载、播放、控制等核心功能
|
||
"""
|
||
|
||
import math
|
||
import json
|
||
import os
|
||
from collections import defaultdict, deque
|
||
from typing import Dict, List, Tuple, Optional, Union, 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 *
|
||
from direct.showbase.DirectObject import DirectObject
|
||
from direct.distributed.ClockDelta import globalClockDelta
|
||
|
||
# 导入工具模块
|
||
from .tools import AnimationAnalyzer, AnimationEditor, DebugVisualizer, AnimationProfiler
|
||
|
||
# 定义常量
|
||
DEFAULT_ANIMATION_SETTINGS = {
|
||
'default_play_rate': 1.0,
|
||
'default_loop': False,
|
||
'blend_time': 0.3,
|
||
'max_actors': 1000,
|
||
'cache_size': 100,
|
||
'lod_distance_thresholds': [10.0, 25.0, 50.0],
|
||
'lod_frame_rates': [1.0, 0.5, 0.25, 0.1]
|
||
}
|
||
|
||
# 枚举定义
|
||
class AnimationState(Enum):
|
||
"""动画状态枚举"""
|
||
STOPPED = 0
|
||
PLAYING = 1
|
||
PAUSED = 2
|
||
BLENDING = 3
|
||
LOOPING = 4
|
||
|
||
class BlendMode(Enum):
|
||
"""混合模式枚举"""
|
||
LINEAR = 0
|
||
EASE_IN = 1
|
||
EASE_OUT = 2
|
||
EASE_IN_OUT = 3
|
||
OVERWRITE = 4
|
||
|
||
class LODLevel(Enum):
|
||
"""LOD级别枚举"""
|
||
HIGH = 0
|
||
MEDIUM = 1
|
||
LOW = 2
|
||
VERY_LOW = 3
|
||
|
||
@dataclass
|
||
class AnimationInfo:
|
||
"""动画信息数据类"""
|
||
name: str
|
||
frame_rate: float
|
||
num_frames: int
|
||
play_rate: float
|
||
current_frame: float
|
||
state: AnimationState
|
||
loop: bool
|
||
start_time: float
|
||
duration: float
|
||
blend_weight: float = 1.0
|
||
blend_in_time: float = 0.0
|
||
blend_out_time: float = 0.0
|
||
|
||
@dataclass
|
||
class ActorInfo:
|
||
"""Actor信息数据类"""
|
||
actor_id: str
|
||
actor: Actor
|
||
model_path: str
|
||
anim_paths: Dict[str, str]
|
||
position: Tuple[float, float, float]
|
||
scale: Union[float, Tuple[float, float, float]]
|
||
animations: Dict[str, AnimationInfo] = field(default_factory=dict)
|
||
active_animations: List[str] = field(default_factory=list)
|
||
lod_level: LODLevel = LODLevel.HIGH
|
||
last_update_time: float = 0.0
|
||
is_networked: bool = False
|
||
network_id: str = ""
|
||
|
||
@dataclass
|
||
class BlendInfo:
|
||
"""混合信息数据类"""
|
||
from_anim: str
|
||
to_anim: str
|
||
blend_time: float
|
||
blend_mode: BlendMode
|
||
current_time: float = 0.0
|
||
total_time: float = 0.0
|
||
active: bool = False
|
||
|
||
@dataclass
|
||
class IKChain:
|
||
"""IK链数据类"""
|
||
chain_name: str
|
||
end_effector: str
|
||
pole_vector: Optional[Tuple[float, float, float]]
|
||
iterations: int
|
||
enabled: bool = True
|
||
target_position: Optional[Tuple[float, float, float]] = None
|
||
|
||
class AnimationCache:
|
||
"""动画缓存系统"""
|
||
|
||
def __init__(self, max_size: int = 100):
|
||
self.max_size = max_size
|
||
self.cache: Dict[str, Any] = {}
|
||
self.access_order: deque = deque()
|
||
self.hits = 0
|
||
self.misses = 0
|
||
|
||
def get(self, key: str) -> Optional[Any]:
|
||
"""获取缓存项"""
|
||
if key in self.cache:
|
||
self.hits += 1
|
||
# 更新访问顺序
|
||
self.access_order.remove(key)
|
||
self.access_order.append(key)
|
||
return self.cache[key]
|
||
else:
|
||
self.misses += 1
|
||
return None
|
||
|
||
def put(self, key: str, value: Any) -> None:
|
||
"""放入缓存项"""
|
||
# 如果缓存已满，移除最久未使用的项
|
||
if len(self.cache) >= self.max_size:
|
||
oldest_key = self.access_order.popleft()
|
||
del self.cache[oldest_key]
|
||
|
||
self.cache[key] = value
|
||
self.access_order.append(key)
|
||
|
||
def invalidate(self, key: str) -> None:
|
||
"""使缓存项失效"""
|
||
if key in self.cache:
|
||
del self.cache[key]
|
||
self.access_order.remove(key)
|
||
|
||
def clear(self) -> None:
|
||
"""清空缓存"""
|
||
self.cache.clear()
|
||
self.access_order.clear()
|
||
self.hits = 0
|
||
self.misses = 0
|
||
|
||
def get_stats(self) -> Dict[str, Any]:
|
||
"""获取缓存统计信息"""
|
||
total_requests = self.hits + self.misses
|
||
hit_rate = self.hits / total_requests if total_requests > 0 else 0
|
||
return {
|
||
'size': len(self.cache),
|
||
'max_size': self.max_size,
|
||
'hits': self.hits,
|
||
'misses': self.misses,
|
||
'hit_rate': hit_rate
|
||
}
|
||
|
||
class AnimationCompressor:
|
||
"""动画压缩系统"""
|
||
|
||
def __init__(self):
|
||
self.position_threshold = 0.001
|
||
self.rotation_threshold = 0.01
|
||
self.scale_threshold = 0.001
|
||
|
||
def compress_keyframes(self, keyframes: List[Tuple[float, Tuple[float, float, float]]],
|
||
data_type: str = 'position') -> List[Tuple[float, Tuple[float, float, float]]]:
|
||
"""
|
||
压缩关键帧数据
|
||
:param keyframes: 关键帧列表 [(time, (x, y, z)), ...]
|
||
:param data_type: 数据类型 ('position', 'rotation', 'scale')
|
||
:return: 压缩后的关键帧列表
|
||
"""
|
||
if len(keyframes) <= 2:
|
||
return keyframes
|
||
|
||
compressed = [keyframes[0]] # 总是保留第一帧
|
||
last_keyframe = keyframes[0]
|
||
|
||
# 根据数据类型选择阈值
|
||
threshold = getattr(self, f'{data_type}_threshold', 0.001)
|
||
|
||
for i in range(1, len(keyframes) - 1):
|
||
current_keyframe = keyframes[i]
|
||
next_keyframe = keyframes[i + 1]
|
||
|
||
# 检查当前帧是否可以被简化
|
||
if not self._is_keyframe_necessary(last_keyframe, current_keyframe, next_keyframe, threshold, data_type):
|
||
continue
|
||
|
||
compressed.append(current_keyframe)
|
||
last_keyframe = current_keyframe
|
||
|
||
compressed.append(keyframes[-1]) # 总是保留最后一帧
|
||
return compressed
|
||
|
||
def _is_keyframe_necessary(self, prev_frame: Tuple[float, Tuple[float, float, float]],
|
||
current_frame: Tuple[float, Tuple[float, float, float]],
|
||
next_frame: Tuple[float, Tuple[float, float, float]],
|
||
threshold: float, data_type: str) -> bool:
|
||
"""
|
||
判断关键帧是否必要
|
||
:param prev_frame: 前一帧
|
||
:param current_frame: 当前帧
|
||
:param next_frame: 后一帧
|
||
:param threshold: 阈值
|
||
:param data_type: 数据类型
|
||
:return: 是否必要
|
||
"""
|
||
prev_time, prev_data = prev_frame
|
||
curr_time, curr_data = current_frame
|
||
next_time, next_data = next_frame
|
||
|
||
# 计算线性插值
|
||
t = (curr_time - prev_time) / (next_time - prev_time)
|
||
interpolated = tuple(prev_data[i] + t * (next_data[i] - prev_data[i]) for i in range(3))
|
||
|
||
# 计算与实际值的差异
|
||
diff = math.sqrt(sum((curr_data[i] - interpolated[i]) ** 2 for i in range(3)))
|
||
|
||
return diff > threshold
|
||
|
||
class SkeletalAnimationCore(DirectObject):
|
||
"""
|
||
骨骼动画核心系统
|
||
提供完整的骨骼动画管理功能
|
||
"""
|
||
|
||
def __init__(self, world):
|
||
"""
|
||
初始化骨骼动画核心系统
|
||
:param world: 世界对象
|
||
"""
|
||
super().__init__()
|
||
self.world = world
|
||
self.actors: Dict[str, ActorInfo] = {}
|
||
self.actor_configs: Dict[str, Dict[str, Any]] = {}
|
||
self.blend_infos: Dict[str, Dict[str, BlendInfo]] = defaultdict(dict)
|
||
self.ik_chains: Dict[str, Dict[str, IKChain]] = defaultdict(dict)
|
||
self.animation_cache = AnimationCache(DEFAULT_ANIMATION_SETTINGS['cache_size'])
|
||
self.compressor = AnimationCompressor()
|
||
self.event_handlers: Dict[str, List[Callable]] = defaultdict(list)
|
||
self.is_updating = False
|
||
self.update_task = None
|
||
|
||
# 工具系统
|
||
self.analyzer = AnimationAnalyzer(self)
|
||
self.editor = AnimationEditor(self)
|
||
self.visualizer = DebugVisualizer(world)
|
||
self.profiler = AnimationProfiler(self)
|
||
|
||
# 性能统计
|
||
self.stats = {
|
||
'actors_loaded': 0,
|
||
'animations_played': 0,
|
||
'blends_performed': 0,
|
||
'ik_calculations': 0,
|
||
'cache_hits': 0,
|
||
'cache_misses': 0
|
||
}
|
||
|
||
print("骨骼动画核心系统初始化完成")
|
||
|
||
def load_actor(self, model_path: str, anim_paths: Optional[Dict[str, str]] = None,
|
||
actor_id: Optional[str] = None, position: Tuple[float, float, float] = (0, 0, 0),
|
||
scale: Union[float, Tuple[float, float, float]] = 1.0) -> Tuple[Optional[Actor], str]:
|
||
"""
|
||
加载Actor模型
|
||
:param model_path: 模型文件路径
|
||
:param anim_paths: 动画文件路径字典 {anim_name: anim_path}
|
||
:param actor_id: Actor标识符，如果为None则自动生成
|
||
:param position: 位置坐标 (x, y, z)
|
||
:param scale: 缩放比例
|
||
:return: (Actor对象, actor_id)
|
||
"""
|
||
try:
|
||
# 检查模型文件是否存在
|
||
if not os.path.exists(model_path):
|
||
raise FileNotFoundError(f"模型文件不存在: {model_path}")
|
||
|
||
# 生成Actor ID
|
||
if actor_id is None:
|
||
actor_id = f"actor_{len(self.actors)}"
|
||
|
||
# 检查Actor是否已存在
|
||
if actor_id in self.actors:
|
||
print(f"警告: Actor {actor_id} 已存在，将被替换")
|
||
self.unload_actor(actor_id)
|
||
|
||
# 检查缓存
|
||
cache_key = f"actor_{model_path}_{hash(str(anim_paths))}"
|
||
cached_actor = self.animation_cache.get(cache_key)
|
||
|
||
if cached_actor:
|
||
actor = cached_actor
|
||
print(f"从缓存加载Actor: {actor_id}")
|
||
else:
|
||
# 创建Actor
|
||
if anim_paths:
|
||
# 验证动画文件
|
||
valid_anims = {}
|
||
for anim_name, anim_path in anim_paths.items():
|
||
if os.path.exists(anim_path):
|
||
valid_anims[anim_name] = anim_path
|
||
else:
|
||
print(f"警告: 动画文件不存在: {anim_path}")
|
||
actor = Actor(model_path, valid_anims)
|
||
else:
|
||
actor = Actor(model_path)
|
||
|
||
# 缓存Actor
|
||
self.animation_cache.put(cache_key, actor)
|
||
|
||
# 设置位置和缩放
|
||
actor.setPos(*position)
|
||
if isinstance(scale, (int, float)):
|
||
actor.setScale(scale)
|
||
else:
|
||
actor.setScale(*scale)
|
||
|
||
# 将Actor添加到场景中
|
||
actor.reparentTo(self.world.render)
|
||
actor.setName(actor_id)
|
||
|
||
# 创建Actor信息
|
||
actor_info = ActorInfo(
|
||
actor_id=actor_id,
|
||
actor=actor,
|
||
model_path=model_path,
|
||
anim_paths=anim_paths or {},
|
||
position=position,
|
||
scale=scale
|
||
)
|
||
|
||
# 初始化动画信息
|
||
for anim_name in actor.getAnimNames():
|
||
control = actor.getAnimControl(anim_name)
|
||
if control:
|
||
anim_info = AnimationInfo(
|
||
name=anim_name,
|
||
frame_rate=actor.getFrameRate(anim_name),
|
||
num_frames=actor.getNumFrames(anim_name),
|
||
play_rate=DEFAULT_ANIMATION_SETTINGS['default_play_rate'],
|
||
current_frame=0.0,
|
||
state=AnimationState.STOPPED,
|
||
loop=DEFAULT_ANIMATION_SETTINGS['default_loop'],
|
||
start_time=0.0,
|
||
duration=control.getDuration()
|
||
)
|
||
actor_info.animations[anim_name] = anim_info
|
||
|
||
# 存储Actor信息
|
||
self.actors[actor_id] = actor_info
|
||
self.actor_configs[actor_id] = {
|
||
'model_path': model_path,
|
||
'anim_paths': anim_paths,
|
||
'position': position,
|
||
'scale': scale
|
||
}
|
||
|
||
self.stats['actors_loaded'] += 1
|
||
print(f"成功加载Actor: {actor_id}")
|
||
print(f" 模型: {model_path}")
|
||
print(f" 位置: {position}")
|
||
print(f" 缩放: {scale}")
|
||
print(f" 可用动画: {list(actor_info.animations.keys())}")
|
||
|
||
return actor, actor_id
|
||
|
||
except Exception as e:
|
||
print(f"加载Actor失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return None, ""
|
||
|
||
def unload_actor(self, actor_id: str) -> bool:
|
||
"""
|
||
卸载Actor
|
||
:param actor_id: Actor标识符
|
||
:return: 是否成功卸载
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return False
|
||
|
||
try:
|
||
actor_info = self.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
# 停止所有动画
|
||
self.stop_all_animations(actor_id)
|
||
|
||
# 清理混合信息
|
||
if actor_id in self.blend_infos:
|
||
del self.blend_infos[actor_id]
|
||
|
||
# 清理IK链
|
||
if actor_id in self.ik_chains:
|
||
del self.ik_chains[actor_id]
|
||
|
||
# 从场景中移除
|
||
actor.cleanup()
|
||
|
||
# 从管理器中移除
|
||
del self.actors[actor_id]
|
||
if actor_id in self.actor_configs:
|
||
del self.actor_configs[actor_id]
|
||
|
||
print(f"已卸载Actor: {actor_id}")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"卸载Actor失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def play_animation(self, actor_id: str, anim_name: str, loop: bool = False,
|
||
play_rate: float = 1.0, start_frame: Optional[int] = None,
|
||
end_frame: Optional[int] = None) -> bool:
|
||
"""
|
||
播放动画
|
||
:param actor_id: Actor标识符
|
||
:param anim_name: 动画名称
|
||
:param loop: 是否循环播放
|
||
:param play_rate: 播放速度
|
||
:param start_frame: 起始帧
|
||
:param end_frame: 结束帧
|
||
:return: 是否成功播放
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return False
|
||
|
||
actor_info = self.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
# 检查动画是否存在
|
||
if anim_name not in actor.getAnimNames():
|
||
print(f"错误: 动画 {anim_name} 不存在于Actor {actor_id} 中")
|
||
print(f" 可用动画: {actor.getAnimNames()}")
|
||
return False
|
||
|
||
try:
|
||
# 设置播放速度
|
||
actor.setPlayRate(play_rate, anim_name)
|
||
|
||
# 播放动画
|
||
if loop:
|
||
if start_frame is not None and end_frame is not None:
|
||
actor.loop(anim_name, restart=False, fromFrame=start_frame, toFrame=end_frame)
|
||
else:
|
||
actor.loop(anim_name, restart=False)
|
||
else:
|
||
if start_frame is not None and end_frame is not None:
|
||
actor.play(anim_name, fromFrame=start_frame, toFrame=end_frame)
|
||
else:
|
||
actor.play(anim_name)
|
||
|
||
# 更新动画信息
|
||
if anim_name in actor_info.animations:
|
||
anim_info = actor_info.animations[anim_name]
|
||
anim_info.state = AnimationState.LOOPING if loop else AnimationState.PLAYING
|
||
anim_info.loop = loop
|
||
anim_info.play_rate = play_rate
|
||
anim_info.start_time = globalClock.getRealTime()
|
||
|
||
# 添加到活动动画列表
|
||
if anim_name not in actor_info.active_animations:
|
||
actor_info.active_animations.append(anim_name)
|
||
|
||
self.stats['animations_played'] += 1
|
||
print(f"播放动画: {anim_name} (Actor: {actor_id}, 循环: {loop}, 速度: {play_rate}x)")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"播放动画失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def stop_animation(self, actor_id: str, anim_name: Optional[str] = None) -> bool:
|
||
"""
|
||
停止动画
|
||
:param actor_id: Actor标识符
|
||
:param anim_name: 动画名称，如果为None则停止所有动画
|
||
:return: 是否成功停止
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return False
|
||
|
||
actor_info = self.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
try:
|
||
if anim_name:
|
||
# 停止指定动画
|
||
if anim_name in actor.getAnimNames():
|
||
actor.stop(anim_name)
|
||
# 从活动动画列表中移除
|
||
if anim_name in actor_info.active_animations:
|
||
actor_info.active_animations.remove(anim_name)
|
||
# 更新动画状态
|
||
if anim_name in actor_info.animations:
|
||
actor_info.animations[anim_name].state = AnimationState.STOPPED
|
||
print(f"停止动画: {anim_name} (Actor: {actor_id})")
|
||
else:
|
||
print(f"警告: 动画 {anim_name} 不存在于Actor {actor_id} 中")
|
||
else:
|
||
# 停止所有动画
|
||
actor.stop()
|
||
# 清空活动动画列表
|
||
actor_info.active_animations.clear()
|
||
# 更新所有动画状态
|
||
for anim_info in actor_info.animations.values():
|
||
anim_info.state = AnimationState.STOPPED
|
||
print(f"停止所有动画 (Actor: {actor_id})")
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"停止动画失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def stop_all_animations(self, actor_id: str) -> bool:
|
||
"""
|
||
停止指定Actor的所有动画
|
||
:param actor_id: Actor标识符
|
||
:return: 是否成功停止
|
||
"""
|
||
return self.stop_animation(actor_id)
|
||
|
||
def pause_animation(self, actor_id: str, anim_name: Optional[str] = None) -> bool:
|
||
"""
|
||
暂停动画
|
||
:param actor_id: Actor标识符
|
||
:param anim_name: 动画名称，如果为None则暂停所有动画
|
||
:return: 是否成功暂停
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return False
|
||
|
||
actor_info = self.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
try:
|
||
if anim_name:
|
||
if anim_name in actor.getAnimNames():
|
||
control = actor.getAnimControl(anim_name)
|
||
if control and control.isPlaying():
|
||
# 通过设置播放速度为0来模拟暂停
|
||
current_rate = actor.getPlayRate(anim_name)
|
||
actor.setPlayRate(0, anim_name)
|
||
# 更新动画状态
|
||
if anim_name in actor_info.animations:
|
||
actor_info.animations[anim_name].state = AnimationState.PAUSED
|
||
print(f"暂停动画: {anim_name} (Actor: {actor_id})")
|
||
return True
|
||
else:
|
||
print(f"警告: 动画 {anim_name} 不存在于Actor {actor_id} 中")
|
||
else:
|
||
# 暂停所有活动动画
|
||
success = False
|
||
for active_anim in actor_info.active_animations:
|
||
control = actor.getAnimControl(active_anim)
|
||
if control and control.isPlaying():
|
||
current_rate = actor.getPlayRate(active_anim)
|
||
actor.setPlayRate(0, active_anim)
|
||
if active_anim in actor_info.animations:
|
||
actor_info.animations[active_anim].state = AnimationState.PAUSED
|
||
success = True
|
||
if success:
|
||
print(f"暂停所有动画 (Actor: {actor_id})")
|
||
return success
|
||
|
||
except Exception as e:
|
||
print(f"暂停动画失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def resume_animation(self, actor_id: str, anim_name: Optional[str] = None) -> bool:
|
||
"""
|
||
恢复动画播放
|
||
:param actor_id: Actor标识符
|
||
:param anim_name: 动画名称，如果为None则恢复所有动画
|
||
:return: 是否成功恢复
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return False
|
||
|
||
actor_info = self.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
try:
|
||
if anim_name:
|
||
if anim_name in actor.getAnimNames():
|
||
control = actor.getAnimControl(anim_name)
|
||
if control and control.getPlayRate() == 0:
|
||
# 恢复正常播放速度
|
||
actor.setPlayRate(1.0, anim_name)
|
||
# 更新动画状态
|
||
if anim_name in actor_info.animations:
|
||
anim_state = AnimationState.LOOPING if actor_info.animations[anim_name].loop else AnimationState.PLAYING
|
||
actor_info.animations[anim_name].state = anim_state
|
||
print(f"恢复动画: {anim_name} (Actor: {actor_id})")
|
||
return True
|
||
else:
|
||
print(f"警告: 动画 {anim_name} 不存在于Actor {actor_id} 中")
|
||
else:
|
||
# 恢复所有暂停的动画
|
||
success = False
|
||
for active_anim in actor_info.active_animations:
|
||
control = actor.getAnimControl(active_anim)
|
||
if control and control.getPlayRate() == 0:
|
||
actor.setPlayRate(1.0, active_anim)
|
||
if active_anim in actor_info.animations:
|
||
anim_state = AnimationState.LOOPING if actor_info.animations[active_anim].loop else AnimationState.PLAYING
|
||
actor_info.animations[active_anim].state = anim_state
|
||
success = True
|
||
if success:
|
||
print(f"恢复所有动画 (Actor: {actor_id})")
|
||
return success
|
||
|
||
except Exception as e:
|
||
print(f"恢复动画失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def set_animation_speed(self, actor_id: str, anim_name: str, speed: float) -> bool:
|
||
"""
|
||
设置动画播放速度
|
||
:param actor_id: Actor标识符
|
||
:param anim_name: 动画名称
|
||
:param speed: 播放速度
|
||
:return: 是否成功设置
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return False
|
||
|
||
actor_info = self.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
try:
|
||
if anim_name in actor.getAnimNames():
|
||
actor.setPlayRate(speed, anim_name)
|
||
# 更新动画信息
|
||
if anim_name in actor_info.animations:
|
||
actor_info.animations[anim_name].play_rate = speed
|
||
print(f"设置动画速度: {anim_name} 为 {speed}x (Actor: {actor_id})")
|
||
return True
|
||
else:
|
||
print(f"警告: 动画 {anim_name} 不存在于Actor {actor_id} 中")
|
||
return False
|
||
|
||
except Exception as e:
|
||
print(f"设置动画速度失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def blend_animations(self, actor_id: str, from_anim: str, to_anim: str,
|
||
blend_time: float = 0.3, blend_mode: BlendMode = BlendMode.LINEAR) -> bool:
|
||
"""
|
||
混合两个动画
|
||
:param actor_id: Actor标识符
|
||
:param from_anim: 起始动画名称
|
||
:param to_anim: 目标动画名称
|
||
:param blend_time: 混合时间
|
||
:param blend_mode: 混合模式
|
||
:return: 是否成功开始混合
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return False
|
||
|
||
actor_info = self.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
# 检查动画是否存在
|
||
if from_anim not in actor.getAnimNames():
|
||
print(f"错误: 起始动画 {from_anim} 不存在于Actor {actor_id} 中")
|
||
return False
|
||
|
||
if to_anim not in actor.getAnimNames():
|
||
print(f"错误: 目标动画 {to_anim} 不存在于Actor {actor_id} 中")
|
||
return False
|
||
|
||
try:
|
||
# 创建混合信息
|
||
blend_info = BlendInfo(
|
||
from_anim=from_anim,
|
||
to_anim=to_anim,
|
||
blend_time=blend_time,
|
||
blend_mode=blend_mode,
|
||
current_time=0.0,
|
||
total_time=blend_time,
|
||
active=True
|
||
)
|
||
|
||
# 存储混合信息
|
||
blend_id = f"{from_anim}_to_{to_anim}"
|
||
self.blend_infos[actor_id][blend_id] = blend_info
|
||
|
||
# 开始混合过程
|
||
self._start_animation_blend(actor_info, blend_info)
|
||
|
||
self.stats['blends_performed'] += 1
|
||
print(f"开始动画混合: {from_anim} -> {to_anim} (Actor: {actor_id}, 时间: {blend_time}s)")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"动画混合失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def _start_animation_blend(self, actor_info: ActorInfo, blend_info: BlendInfo) -> None:
|
||
"""
|
||
开始动画混合过程
|
||
:param actor_info: Actor信息
|
||
:param blend_info: 混合信息
|
||
"""
|
||
actor = actor_info.actor
|
||
from_anim = blend_info.from_anim
|
||
to_anim = blend_info.to_anim
|
||
|
||
# 停止起始动画
|
||
actor.stop(from_anim)
|
||
|
||
# 播放目标动画
|
||
actor.play(to_anim)
|
||
|
||
# 设置混合权重（简化实现）
|
||
if to_anim in actor_info.animations:
|
||
actor_info.animations[to_anim].blend_weight = 1.0
|
||
|
||
def get_actor(self, actor_id: str) -> Optional[Actor]:
|
||
"""
|
||
获取Actor对象
|
||
:param actor_id: Actor标识符
|
||
:return: Actor对象或None
|
||
"""
|
||
if actor_id in self.actors:
|
||
return self.actors[actor_id].actor
|
||
return None
|
||
|
||
def get_actor_animations(self, actor_id: str) -> List[str]:
|
||
"""
|
||
获取Actor的所有动画名称
|
||
:param actor_id: Actor标识符
|
||
:return: 动画名称列表
|
||
"""
|
||
if actor_id in self.actors:
|
||
return list(self.actors[actor_id].animations.keys())
|
||
return []
|
||
|
||
def get_animation_info(self, actor_id: str, anim_name: str) -> Optional[Dict[str, Any]]:
|
||
"""
|
||
获取动画信息
|
||
:param actor_id: Actor标识符
|
||
:param anim_name: 动画名称
|
||
:return: 动画信息字典
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return None
|
||
|
||
actor_info = self.actors[actor_id]
|
||
|
||
if anim_name not in actor_info.animations:
|
||
print(f"错误: 动画 {anim_name} 不存在于Actor {actor_id} 中")
|
||
return None
|
||
|
||
anim_info = actor_info.animations[anim_name]
|
||
actor = actor_info.actor
|
||
control = actor.getAnimControl(anim_name) if anim_name in actor.getAnimNames() else None
|
||
|
||
return {
|
||
'name': anim_info.name,
|
||
'frame_rate': anim_info.frame_rate,
|
||
'num_frames': anim_info.num_frames,
|
||
'play_rate': anim_info.play_rate,
|
||
'current_frame': anim_info.current_frame,
|
||
'state': anim_info.state.name,
|
||
'loop': anim_info.loop,
|
||
'start_time': anim_info.start_time,
|
||
'duration': anim_info.duration,
|
||
'is_playing': control.isPlaying() if control else False,
|
||
'is_finished': control.isFinished() if control else True
|
||
}
|
||
|
||
def get_actor_info(self, actor_id: str) -> Optional[Dict[str, Any]]:
|
||
"""
|
||
获取Actor详细信息
|
||
:param actor_id: Actor标识符
|
||
:return: Actor信息字典
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return None
|
||
|
||
actor_info = self.actors[actor_id]
|
||
actor = actor_info.actor
|
||
|
||
return {
|
||
'id': actor_info.actor_id,
|
||
'model_path': actor_info.model_path,
|
||
'anim_paths': actor_info.anim_paths,
|
||
'position': actor.getPos().toTuple(),
|
||
'scale': actor.getScale().toTuple(),
|
||
'available_animations': list(actor_info.animations.keys()),
|
||
'active_animations': actor_info.active_animations.copy(),
|
||
'lod_level': actor_info.lod_level.name,
|
||
'has_character': actor.hasCharacter(),
|
||
'num_parts': actor.getNumParts(),
|
||
'bounds': {
|
||
'min': actor.getTightBounds()[0].toTuple() if actor.getTightBounds() else None,
|
||
'max': actor.getTightBounds()[1].toTuple() if actor.getTightBounds() else None
|
||
}
|
||
}
|
||
|
||
def set_actor_position(self, actor_id: str, x: float, y: float, z: float) -> bool:
|
||
"""
|
||
设置Actor位置
|
||
:param actor_id: Actor标识符
|
||
:param x: X坐标
|
||
:param y: Y坐标
|
||
:param z: Z坐标
|
||
:return: 是否成功设置
|
||
"""
|
||
if actor_id in self.actors:
|
||
self.actors[actor_id].actor.setPos(x, y, z)
|
||
self.actors[actor_id].position = (x, y, z)
|
||
if actor_id in self.actor_configs:
|
||
self.actor_configs[actor_id]['position'] = (x, y, z)
|
||
print(f"设置Actor {actor_id} 位置: ({x}, {y}, {z})")
|
||
return True
|
||
return False
|
||
|
||
def set_actor_scale(self, actor_id: str, scale: Union[float, Tuple[float, float, float]]) -> bool:
|
||
"""
|
||
设置Actor缩放
|
||
:param actor_id: Actor标识符
|
||
:param scale: 缩放值 (数值或(x, y, z)元组)
|
||
:return: 是否成功设置
|
||
"""
|
||
if actor_id in self.actors:
|
||
actor = self.actors[actor_id].actor
|
||
if isinstance(scale, (int, float)):
|
||
actor.setScale(scale)
|
||
else:
|
||
actor.setScale(*scale)
|
||
self.actors[actor_id].scale = scale
|
||
if actor_id in self.actor_configs:
|
||
self.actor_configs[actor_id]['scale'] = scale
|
||
print(f"设置Actor {actor_id} 缩放: {scale}")
|
||
return True
|
||
return False
|
||
|
||
def update(self, dt: float) -> None:
|
||
"""
|
||
更新动画系统
|
||
:param dt: 时间增量
|
||
"""
|
||
if not self.is_updating:
|
||
return
|
||
|
||
current_time = globalClock.getRealTime()
|
||
|
||
# 更新所有Actor
|
||
for actor_id, actor_info in self.actors.items():
|
||
# 更新动画信息
|
||
self._update_actor_animations(actor_info, dt, current_time)
|
||
|
||
# 更新混合
|
||
self._update_blends(actor_info, dt)
|
||
|
||
# 更新IK
|
||
self._update_ik(actor_info)
|
||
|
||
# 更新LOD
|
||
self._update_lod(actor_info, current_time)
|
||
|
||
# 更新工具系统
|
||
self._update_tools(dt)
|
||
|
||
def _update_actor_animations(self, actor_info: ActorInfo, dt: float, current_time: float) -> None:
|
||
"""
|
||
更新Actor动画
|
||
:param actor_info: Actor信息
|
||
:param dt: 时间增量
|
||
:param current_time: 当前时间
|
||
"""
|
||
actor = actor_info.actor
|
||
|
||
# 更新活动动画的当前帧信息
|
||
for anim_name in actor_info.active_animations:
|
||
if anim_name in actor_info.animations:
|
||
anim_info = actor_info.animations[anim_name]
|
||
control = actor.getAnimControl(anim_name) if anim_name in actor.getAnimNames() else None
|
||
|
||
if control and control.isPlaying():
|
||
anim_info.current_frame = actor.getCurrentFrame(anim_name)
|
||
anim_info.state = AnimationState.LOOPING if anim_info.loop else AnimationState.PLAYING
|
||
elif control and control.getPlayRate() == 0:
|
||
anim_info.state = AnimationState.PAUSED
|
||
else:
|
||
anim_info.state = AnimationState.STOPPED
|
||
|
||
actor_info.last_update_time = current_time
|
||
|
||
def _update_blends(self, actor_info: ActorInfo, dt: float) -> None:
|
||
"""
|
||
更新动画混合
|
||
:param actor_info: Actor信息
|
||
:param dt: 时间增量
|
||
"""
|
||
actor_id = actor_info.actor_id
|
||
|
||
if actor_id not in self.blend_infos:
|
||
return
|
||
|
||
# 更新所有混合
|
||
finished_blends = []
|
||
for blend_id, blend_info in self.blend_infos[actor_id].items():
|
||
if not blend_info.active:
|
||
continue
|
||
|
||
blend_info.current_time += dt
|
||
|
||
# 计算混合权重
|
||
t = min(1.0, blend_info.current_time / blend_info.total_time)
|
||
|
||
# 根据混合模式应用缓动函数
|
||
if blend_info.blend_mode == BlendMode.EASE_IN:
|
||
t = t * t
|
||
elif blend_info.blend_mode == BlendMode.EASE_OUT:
|
||
t = 1.0 - (1.0 - t) * (1.0 - t)
|
||
elif blend_info.blend_mode == BlendMode.EASE_IN_OUT:
|
||
t = t * t * (3.0 - 2.0 * t)
|
||
|
||
# 更新目标动画的混合权重
|
||
if blend_info.to_anim in actor_info.animations:
|
||
actor_info.animations[blend_info.to_anim].blend_weight = t
|
||
|
||
# 检查混合是否完成
|
||
if blend_info.current_time >= blend_info.total_time:
|
||
blend_info.active = False
|
||
finished_blends.append(blend_id)
|
||
|
||
# 移除已完成的混合
|
||
for blend_id in finished_blends:
|
||
del self.blend_infos[actor_id][blend_id]
|
||
|
||
def _update_ik(self, actor_info: ActorInfo) -> None:
|
||
"""
|
||
更新IK计算
|
||
:param actor_info: Actor信息
|
||
"""
|
||
actor_id = actor_info.actor_id
|
||
|
||
if actor_id not in self.ik_chains:
|
||
return
|
||
|
||
# 更新所有IK链
|
||
for chain_name, ik_chain in self.ik_chains[actor_id].items():
|
||
if not ik_chain.enabled or not ik_chain.target_position:
|
||
continue
|
||
|
||
self._solve_ik_chain(actor_info, ik_chain)
|
||
self.stats['ik_calculations'] += 1
|
||
|
||
def _solve_ik_chain(self, actor_info: ActorInfo, ik_chain: IKChain) -> None:
|
||
"""
|
||
解算IK链
|
||
:param actor_info: Actor信息
|
||
:param ik_chain: IK链信息
|
||
"""
|
||
actor = actor_info.actor
|
||
|
||
# 简化的CCD IK算法实现
|
||
end_effector = actor.exposeJoint(None, "modelRoot", ik_chain.end_effector)
|
||
if not end_effector:
|
||
return
|
||
|
||
target_pos = Point3(*ik_chain.target_position)
|
||
current_pos = end_effector.getPos(actor)
|
||
|
||
# 如果已经足够接近，不需要调整
|
||
distance = (target_pos - current_pos).length()
|
||
if distance < 0.001:
|
||
return
|
||
|
||
# CCD算法迭代
|
||
for _ in range(ik_chain.iterations):
|
||
# 从末端关节向前迭代调整
|
||
# 这里简化处理，实际应该遍历整条骨骼链
|
||
direction = target_pos - current_pos
|
||
direction.normalize()
|
||
|
||
# 简单的朝向调整
|
||
end_effector.lookAt(target_pos)
|
||
|
||
# 更新位置
|
||
current_pos = end_effector.getPos(actor)
|
||
distance = (target_pos - current_pos).length()
|
||
if distance < 0.001:
|
||
break
|
||
|
||
def _update_lod(self, actor_info: ActorInfo, current_time: float) -> None:
|
||
"""
|
||
更新LOD级别
|
||
:param actor_info: Actor信息
|
||
:param current_time: 当前时间
|
||
"""
|
||
# LOD更新可以基于距离、性能或其他因素
|
||
# 这里简化实现，实际项目中可能需要更复杂的逻辑
|
||
pass
|
||
|
||
def _update_tools(self, dt: float) -> None:
|
||
"""
|
||
更新工具系统
|
||
:param dt: 时间增量
|
||
"""
|
||
# 更新性能分析器
|
||
self.profiler.sample_performance()
|
||
|
||
# 更新调试可视化
|
||
self.visualizer.update_visualizations(self.actors)
|
||
|
||
def add_ik_chain(self, actor_id: str, chain_name: str, end_effector: str,
|
||
pole_vector: Optional[Tuple[float, float, float]] = None,
|
||
iterations: int = 10) -> bool:
|
||
"""
|
||
添加IK链
|
||
:param actor_id: Actor标识符
|
||
:param chain_name: 链名称
|
||
:param end_effector: 终端效应器（骨骼名称）
|
||
:param pole_vector: 极向量（用于控制弯曲方向）
|
||
:param iterations: 迭代次数
|
||
:return: 是否成功添加
|
||
"""
|
||
if actor_id not in self.actors:
|
||
print(f"错误: Actor {actor_id} 不存在")
|
||
return False
|
||
|
||
# 检查骨骼是否存在
|
||
actor = self.actors[actor_id].actor
|
||
effector_joint = actor.exposeJoint(None, "modelRoot", end_effector)
|
||
if not effector_joint:
|
||
print(f"错误: 未找到骨骼 {end_effector}")
|
||
return False
|
||
|
||
# 创建IK链
|
||
ik_chain = IKChain(
|
||
chain_name=chain_name,
|
||
end_effector=end_effector,
|
||
pole_vector=pole_vector,
|
||
iterations=iterations,
|
||
enabled=True
|
||
)
|
||
|
||
# 存储IK链
|
||
self.ik_chains[actor_id][chain_name] = ik_chain
|
||
print(f"添加IK链: {chain_name} -> {end_effector} (Actor: {actor_id})")
|
||
return True
|
||
|
||
def set_ik_target(self, actor_id: str, chain_name: str, target_pos: Tuple[float, float, float]) -> bool:
|
||
"""
|
||
设置IK目标位置
|
||
:param actor_id: Actor标识符
|
||
:param chain_name: 链名称
|
||
:param target_pos: 目标位置 (x, y, z)
|
||
:return: 是否成功设置
|
||
"""
|
||
if actor_id not in self.ik_chains or chain_name not in self.ik_chains[actor_id]:
|
||
print(f"错误: IK链 {chain_name} 不存在于Actor {actor_id} 中")
|
||
return False
|
||
|
||
# 设置目标位置
|
||
self.ik_chains[actor_id][chain_name].target_position = target_pos
|
||
return True
|
||
|
||
def enable_ik_chain(self, actor_id: str, chain_name: str, enabled: bool = True) -> bool:
|
||
"""
|
||
启用/禁用IK链
|
||
:param actor_id: Actor标识符
|
||
:param chain_name: 链名称
|
||
:param enabled: 是否启用
|
||
:return: 是否成功设置
|
||
"""
|
||
if actor_id not in self.ik_chains or chain_name not in self.ik_chains[actor_id]:
|
||
print(f"错误: IK链 {chain_name} 不存在于Actor {actor_id} 中")
|
||
return False
|
||
|
||
self.ik_chains[actor_id][chain_name].enabled = enabled
|
||
status = "启用" if enabled else "禁用"
|
||
print(f"{status}IK链: {chain_name} (Actor: {actor_id})")
|
||
return True
|
||
|
||
def get_cache_stats(self) -> Dict[str, Any]:
|
||
"""
|
||
获取缓存统计信息
|
||
:return: 缓存统计
|
||
"""
|
||
return self.animation_cache.get_stats()
|
||
|
||
def get_system_stats(self) -> Dict[str, Any]:
|
||
"""
|
||
获取系统统计信息
|
||
:return: 系统统计
|
||
"""
|
||
cache_stats = self.animation_cache.get_stats()
|
||
return {
|
||
'actors_count': len(self.actors),
|
||
'animations_played': self.stats['animations_played'],
|
||
'blends_performed': self.stats['blends_performed'],
|
||
'ik_calculations': self.stats['ik_calculations'],
|
||
'cache_stats': cache_stats,
|
||
'active_actors': len([a for a in self.actors.values() if a.active_animations])
|
||
}
|
||
|
||
def start_updating(self) -> None:
|
||
"""
|
||
开始更新动画系统
|
||
"""
|
||
if not self.is_updating:
|
||
self.is_updating = True
|
||
print("动画系统更新已启动")
|
||
|
||
def stop_updating(self) -> None:
|
||
"""
|
||
停止更新动画系统
|
||
"""
|
||
if self.is_updating:
|
||
self.is_updating = False
|
||
print("动画系统更新已停止")
|
||
|
||
def clear_cache(self) -> None:
|
||
"""
|
||
清空动画缓存
|
||
"""
|
||
self.animation_cache.clear()
|
||
print("动画缓存已清空")
|
||
|
||
def reset_stats(self) -> None:
|
||
"""
|
||
重置统计信息
|
||
"""
|
||
self.stats = {
|
||
'actors_loaded': 0,
|
||
'animations_played': 0,
|
||
'blends_performed': 0,
|
||
'ik_calculations': 0,
|
||
'cache_hits': 0,
|
||
'cache_misses': 0
|
||
}
|
||
self.animation_cache.hits = 0
|
||
self.animation_cache.misses = 0
|
||
print("统计信息已重置")
|
||
|
||
# 工具系统访问方法
|
||
def get_analyzer(self) -> AnimationAnalyzer:
|
||
"""
|
||
获取动画分析器
|
||
:return: AnimationAnalyzer实例
|
||
"""
|
||
return self.analyzer
|
||
|
||
def get_editor(self) -> AnimationEditor:
|
||
"""
|
||
获取动画编辑器
|
||
:return: AnimationEditor实例
|
||
"""
|
||
return self.editor
|
||
|
||
def get_visualizer(self) -> DebugVisualizer:
|
||
"""
|
||
获取调试可视化工具
|
||
:return: DebugVisualizer实例
|
||
"""
|
||
return self.visualizer
|
||
|
||
def get_profiler(self) -> AnimationProfiler:
|
||
"""
|
||
获取性能分析器
|
||
:return: AnimationProfiler实例
|
||
"""
|
||
return self.profiler |