1180 lines
43 KiB
Python
1180 lines
43 KiB
Python
"""
|
|
效果处理器模块
|
|
负责创建和处理各种触觉效果
|
|
"""
|
|
|
|
import time
|
|
import math
|
|
from typing import Dict, Any, List, Optional
|
|
import threading
|
|
import random
|
|
|
|
class EffectType:
|
|
"""效果类型常量"""
|
|
SIMPLE = "simple"
|
|
PERIODIC = "periodic"
|
|
ENVELOPE = "envelope"
|
|
RAMP = "ramp"
|
|
CUSTOM = "custom"
|
|
NOISE = "noise"
|
|
IMPULSE = "impulse"
|
|
EXPLOSION = "explosion"
|
|
TEXTURE = "texture"
|
|
WIND = "wind"
|
|
WATER = "water"
|
|
HEAT = "heat"
|
|
COLD = "cold"
|
|
VIBRATION = "vibration"
|
|
PULSE = "pulse"
|
|
|
|
class EffectProcessor:
|
|
"""
|
|
效果处理器
|
|
负责创建和处理各种触觉效果
|
|
"""
|
|
|
|
def __init__(self, plugin):
|
|
"""
|
|
初始化效果处理器
|
|
|
|
Args:
|
|
plugin: 触觉反馈系统插件实例
|
|
"""
|
|
self.plugin = plugin
|
|
self.enabled = False
|
|
self.initialized = False
|
|
|
|
# 效果模板
|
|
self.effect_templates = {}
|
|
|
|
# 自定义效果
|
|
self.custom_effects = {}
|
|
self.effect_counter = 0
|
|
|
|
# 效果参数
|
|
self.effect_parameters = {
|
|
'simple': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.01, 10.0)
|
|
},
|
|
'periodic': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.01, 10.0),
|
|
'frequency': (1.0, 100.0),
|
|
'amplitude': (0.0, 1.0),
|
|
'offset': (0.0, 1.0),
|
|
'phase': (0.0, 360.0),
|
|
'waveform': ['sine', 'square', 'triangle', 'sawtooth']
|
|
},
|
|
'envelope': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.01, 10.0),
|
|
'attack_time': (0.0, 2.0),
|
|
'attack_level': (0.0, 1.0),
|
|
'fade_time': (0.0, 2.0),
|
|
'fade_level': (0.0, 1.0),
|
|
'sustain_level': (0.0, 1.0)
|
|
},
|
|
'ramp': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.01, 10.0),
|
|
'start_level': (0.0, 1.0),
|
|
'end_level': (0.0, 1.0),
|
|
'curve_type': ['linear', 'exponential', 'logarithmic']
|
|
},
|
|
'noise': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.01, 10.0),
|
|
'frequency': (1.0, 100.0),
|
|
'noise_type': ['white', 'pink', 'brown']
|
|
},
|
|
'impulse': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.001, 1.0),
|
|
'sharpness': (0.0, 1.0),
|
|
'shape': ['gaussian', 'exponential', 'linear']
|
|
},
|
|
'explosion': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.1, 5.0),
|
|
'rise_time': (0.01, 1.0),
|
|
'fall_time': (0.1, 2.0),
|
|
'frequency_start': (20.0, 100.0),
|
|
'frequency_end': (5.0, 50.0)
|
|
},
|
|
'texture': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.1, 10.0),
|
|
'frequency': (5.0, 50.0),
|
|
'roughness': (0.0, 1.0),
|
|
'spacing': (0.01, 1.0)
|
|
},
|
|
'wind': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.5, 30.0),
|
|
'frequency': (0.1, 10.0),
|
|
'turbulence': (0.0, 1.0),
|
|
'direction_variability': (0.0, 1.0)
|
|
},
|
|
'water': {
|
|
'intensity': (0.0, 1.0),
|
|
'duration': (0.5, 30.0),
|
|
'frequency': (0.5, 20.0),
|
|
'wave_height': (0.1, 5.0),
|
|
'viscosity': (0.1, 10.0)
|
|
}
|
|
}
|
|
|
|
# 预定义效果
|
|
self.predefined_effects = {
|
|
'click': {
|
|
'type': EffectType.IMPULSE,
|
|
'intensity': 0.8,
|
|
'duration': 0.05,
|
|
'sharpness': 0.9,
|
|
'shape': 'gaussian'
|
|
},
|
|
'buzz': {
|
|
'type': EffectType.PERIODIC,
|
|
'intensity': 0.6,
|
|
'duration': 0.5,
|
|
'frequency': 50.0,
|
|
'amplitude': 0.5,
|
|
'waveform': 'sine'
|
|
},
|
|
'rumble': {
|
|
'type': EffectType.PERIODIC,
|
|
'intensity': 0.7,
|
|
'duration': 1.0,
|
|
'frequency': 20.0,
|
|
'amplitude': 0.6,
|
|
'waveform': 'sine'
|
|
},
|
|
'pulse': {
|
|
'type': EffectType.PERIODIC,
|
|
'intensity': 0.5,
|
|
'duration': 0.3,
|
|
'frequency': 30.0,
|
|
'amplitude': 0.4,
|
|
'waveform': 'sine'
|
|
},
|
|
'heartbeat': {
|
|
'type': EffectType.ENVELOPE,
|
|
'intensity': 0.6,
|
|
'duration': 1.5,
|
|
'attack_time': 0.1,
|
|
'attack_level': 0.8,
|
|
'fade_time': 0.3,
|
|
'fade_level': 0.2,
|
|
'sustain_level': 0.5
|
|
},
|
|
'explosion': {
|
|
'type': EffectType.EXPLOSION,
|
|
'intensity': 1.0,
|
|
'duration': 2.0,
|
|
'rise_time': 0.05,
|
|
'fall_time': 0.8,
|
|
'frequency_start': 80.0,
|
|
'frequency_end': 10.0
|
|
},
|
|
'impact': {
|
|
'type': EffectType.IMPULSE,
|
|
'intensity': 0.9,
|
|
'duration': 0.1,
|
|
'sharpness': 0.7,
|
|
'shape': 'exponential'
|
|
},
|
|
'texture_rough': {
|
|
'type': EffectType.TEXTURE,
|
|
'intensity': 0.4,
|
|
'duration': 2.0,
|
|
'frequency': 15.0,
|
|
'roughness': 0.8,
|
|
'spacing': 0.05
|
|
},
|
|
'texture_smooth': {
|
|
'type': EffectType.TEXTURE,
|
|
'intensity': 0.3,
|
|
'duration': 2.0,
|
|
'frequency': 8.0,
|
|
'roughness': 0.2,
|
|
'spacing': 0.1
|
|
},
|
|
'wind_light': {
|
|
'type': EffectType.WIND,
|
|
'intensity': 0.2,
|
|
'duration': 5.0,
|
|
'frequency': 0.5,
|
|
'turbulence': 0.3,
|
|
'direction_variability': 0.2
|
|
},
|
|
'wind_strong': {
|
|
'type': EffectType.WIND,
|
|
'intensity': 0.7,
|
|
'duration': 5.0,
|
|
'frequency': 2.0,
|
|
'turbulence': 0.8,
|
|
'direction_variability': 0.5
|
|
},
|
|
'water_shallow': {
|
|
'type': EffectType.WATER,
|
|
'intensity': 0.3,
|
|
'duration': 3.0,
|
|
'frequency': 2.0,
|
|
'wave_height': 0.5,
|
|
'viscosity': 1.0
|
|
},
|
|
'water_deep': {
|
|
'type': EffectType.WATER,
|
|
'intensity': 0.6,
|
|
'duration': 3.0,
|
|
'frequency': 0.8,
|
|
'wave_height': 2.0,
|
|
'viscosity': 3.0
|
|
}
|
|
}
|
|
|
|
# 效果混合
|
|
self.effect_mixing = {
|
|
'max': self._mix_max,
|
|
'add': self._mix_add,
|
|
'multiply': self._mix_multiply,
|
|
'average': self._mix_average,
|
|
'weighted': self._mix_weighted
|
|
}
|
|
|
|
# 波形生成器
|
|
self.waveform_generators = {
|
|
'sine': self._generate_sine_wave,
|
|
'square': self._generate_square_wave,
|
|
'triangle': self._generate_triangle_wave,
|
|
'sawtooth': self._generate_sawtooth_wave
|
|
}
|
|
|
|
# 噪声生成器
|
|
self.noise_generators = {
|
|
'white': self._generate_white_noise,
|
|
'pink': self._generate_pink_noise,
|
|
'brown': self._generate_brown_noise
|
|
}
|
|
|
|
# 脉冲形状生成器
|
|
self.impulse_shapes = {
|
|
'gaussian': self._generate_gaussian_impulse,
|
|
'exponential': self._generate_exponential_impulse,
|
|
'linear': self._generate_linear_impulse
|
|
}
|
|
|
|
# 统计信息
|
|
self.stats = {
|
|
'templates_created': 0,
|
|
'effects_generated': 0,
|
|
'effects_processed': 0,
|
|
'custom_effects': 0,
|
|
'waveforms_generated': 0,
|
|
'noise_samples': 0
|
|
}
|
|
|
|
# 回调函数
|
|
self.effect_callbacks = {
|
|
'effect_created': [],
|
|
'effect_processed': [],
|
|
'template_registered': [],
|
|
'waveform_generated': []
|
|
}
|
|
|
|
# 缓存
|
|
self.waveform_cache = {}
|
|
self.noise_cache = {}
|
|
|
|
# 随机数生成器
|
|
self.random_generator = random.Random()
|
|
|
|
print("✓ 效果处理器已创建")
|
|
|
|
def initialize(self) -> bool:
|
|
"""
|
|
初始化效果处理器
|
|
|
|
Returns:
|
|
是否初始化成功
|
|
"""
|
|
try:
|
|
# 注册预定义效果为模板
|
|
for name, effect_data in self.predefined_effects.items():
|
|
self.register_effect_template(name, effect_data)
|
|
|
|
# 初始化缓存
|
|
self._initialize_cache()
|
|
|
|
self.initialized = True
|
|
print("✓ 效果处理器初始化完成")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ 效果处理器初始化失败: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return False
|
|
|
|
def enable(self) -> bool:
|
|
"""
|
|
启用效果处理器
|
|
|
|
Returns:
|
|
是否启用成功
|
|
"""
|
|
try:
|
|
if not self.initialized:
|
|
print("✗ 效果处理器未初始化")
|
|
return False
|
|
|
|
self.enabled = True
|
|
print("✓ 效果处理器已启用")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ 效果处理器启用失败: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return False
|
|
|
|
def disable(self):
|
|
"""禁用效果处理器"""
|
|
try:
|
|
self.enabled = False
|
|
print("✓ 效果处理器已禁用")
|
|
|
|
except Exception as e:
|
|
print(f"✗ 效果处理器禁用失败: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
|
|
def finalize(self):
|
|
"""清理效果处理器资源"""
|
|
try:
|
|
self.disable()
|
|
self.effect_templates.clear()
|
|
self.custom_effects.clear()
|
|
self.effect_callbacks.clear()
|
|
self.waveform_cache.clear()
|
|
self.noise_cache.clear()
|
|
self.initialized = False
|
|
print("✓ 效果处理器资源已清理")
|
|
|
|
except Exception as e:
|
|
print(f"✗ 效果处理器资源清理失败: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
|
|
def update(self, dt: float):
|
|
"""
|
|
更新效果处理器状态
|
|
|
|
Args:
|
|
dt: 时间增量
|
|
"""
|
|
try:
|
|
if not self.enabled:
|
|
return
|
|
|
|
# 清理缓存（定期清理以节省内存）
|
|
self._cleanup_cache()
|
|
|
|
except Exception as e:
|
|
print(f"✗ 效果处理器更新失败: {e}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
|
|
def _initialize_cache(self):
|
|
"""初始化缓存"""
|
|
try:
|
|
# 预生成常用波形
|
|
common_frequencies = [10, 20, 30, 50, 100]
|
|
common_durations = [0.1, 0.5, 1.0, 2.0]
|
|
|
|
for freq in common_frequencies:
|
|
for duration in common_durations:
|
|
cache_key = f"sine_{freq}_{duration}"
|
|
self.waveform_cache[cache_key] = self._generate_sine_wave(freq, duration, 100)
|
|
|
|
print("✓ 波形缓存初始化完成")
|
|
except Exception as e:
|
|
print(f"✗ 波形缓存初始化失败: {e}")
|
|
|
|
def _cleanup_cache(self):
|
|
"""清理缓存"""
|
|
try:
|
|
# 保持缓存大小在合理范围内
|
|
max_cache_size = 1000
|
|
|
|
if len(self.waveform_cache) > max_cache_size:
|
|
# 移除最旧的一半缓存
|
|
keys_to_remove = list(self.waveform_cache.keys())[:max_cache_size//2]
|
|
for key in keys_to_remove:
|
|
del self.waveform_cache[key]
|
|
|
|
if len(self.noise_cache) > max_cache_size:
|
|
# 移除最旧的一半缓存
|
|
keys_to_remove = list(self.noise_cache.keys())[:max_cache_size//2]
|
|
for key in keys_to_remove:
|
|
del self.noise_cache[key]
|
|
|
|
except Exception as e:
|
|
print(f"✗ 缓存清理失败: {e}")
|
|
|
|
def register_effect_template(self, name: str, template: Dict[str, Any]) -> bool:
|
|
"""
|
|
注册效果模板
|
|
|
|
Args:
|
|
name: 模板名称
|
|
template: 模板数据
|
|
|
|
Returns:
|
|
是否注册成功
|
|
"""
|
|
try:
|
|
self.effect_templates[name] = template.copy()
|
|
self.stats['templates_created'] += 1
|
|
|
|
# 触发模板注册回调
|
|
self._trigger_effect_callback('template_registered', {
|
|
'template_name': name,
|
|
'template_data': template
|
|
})
|
|
|
|
print(f"✓ 效果模板已注册: {name}")
|
|
return True
|
|
|
|
except Exception as e:
|
|
print(f"✗ 效果模板注册失败: {e}")
|
|
return False
|
|
|
|
def unregister_effect_template(self, name: str) -> bool:
|
|
"""
|
|
注销效果模板
|
|
|
|
Args:
|
|
name: 模板名称
|
|
|
|
Returns:
|
|
是否注销成功
|
|
"""
|
|
try:
|
|
if name in self.effect_templates:
|
|
del self.effect_templates[name]
|
|
print(f"✓ 效果模板已注销: {name}")
|
|
return True
|
|
else:
|
|
print(f"✗ 效果模板不存在: {name}")
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f"✗ 效果模板注销失败: {e}")
|
|
return False
|
|
|
|
def create_effect_from_template(self, template_name: str,
|
|
overrides: Dict[str, Any] = None) -> Optional[Dict[str, Any]]:
|
|
"""
|
|
从模板创建效果
|
|
|
|
Args:
|
|
template_name: 模板名称
|
|
overrides: 覆盖参数
|
|
|
|
Returns:
|
|
效果数据字典或None
|
|
"""
|
|
try:
|
|
if template_name not in self.effect_templates:
|
|
print(f"✗ 效果模板不存在: {template_name}")
|
|
return None
|
|
|
|
# 获取模板数据
|
|
template = self.effect_templates[template_name].copy()
|
|
|
|
# 应用覆盖参数
|
|
if overrides:
|
|
template.update(overrides)
|
|
|
|
# 添加创建时间戳
|
|
template['created_time'] = time.time()
|
|
|
|
# 触发效果创建回调
|
|
self._trigger_effect_callback('effect_created', {
|
|
'template_name': template_name,
|
|
'effect_data': template
|
|
})
|
|
|
|
self.stats['effects_generated'] += 1
|
|
print(f"✓ 效果已从模板创建: {template_name}")
|
|
return template
|
|
|
|
except Exception as e:
|
|
print(f"✗ 从模板创建效果失败: {e}")
|
|
return None
|
|
|
|
def create_custom_effect(self, effect_type: str, parameters: Dict[str, Any]) -> int:
|
|
"""
|
|
创建自定义效果
|
|
|
|
Args:
|
|
effect_type: 效果类型
|
|
parameters: 效果参数
|
|
|
|
Returns:
|
|
效果ID
|
|
"""
|
|
try:
|
|
effect_id = self.effect_counter
|
|
self.effect_counter += 1
|
|
|
|
custom_effect = {
|
|
'id': effect_id,
|
|
'type': effect_type,
|
|
'parameters': parameters,
|
|
'created_time': time.time()
|
|
}
|
|
|
|
self.custom_effects[effect_id] = custom_effect
|
|
self.stats['custom_effects'] += 1
|
|
|
|
# 触发效果创建回调
|
|
self._trigger_effect_callback('effect_created', {
|
|
'effect_id': effect_id,
|
|
'effect_data': custom_effect
|
|
})
|
|
|
|
print(f"✓ 自定义效果已创建: {effect_type} (ID: {effect_id})")
|
|
return effect_id
|
|
|
|
except Exception as e:
|
|
print(f"✗ 自定义效果创建失败: {e}")
|
|
return -1
|
|
|
|
def remove_custom_effect(self, effect_id: int) -> bool:
|
|
"""
|
|
移除自定义效果
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
|
|
Returns:
|
|
是否移除成功
|
|
"""
|
|
try:
|
|
if effect_id in self.custom_effects:
|
|
del self.custom_effects[effect_id]
|
|
self.stats['custom_effects'] -= 1
|
|
print(f"✓ 自定义效果已移除: ID {effect_id}")
|
|
return True
|
|
else:
|
|
print(f"✗ 自定义效果不存在: ID {effect_id}")
|
|
return False
|
|
|
|
except Exception as e:
|
|
print(f"✗ 自定义效果移除失败: {e}")
|
|
return False
|
|
|
|
def get_custom_effect(self, effect_id: int) -> Optional[Dict[str, Any]]:
|
|
"""
|
|
获取自定义效果
|
|
|
|
Args:
|
|
effect_id: 效果ID
|
|
|
|
Returns:
|
|
效果数据字典或None
|
|
"""
|
|
return self.custom_effects.get(effect_id)
|
|
|
|
def get_all_custom_effects(self) -> Dict[int, Dict[str, Any]]:
|
|
"""
|
|
获取所有自定义效果
|
|
|
|
Returns:
|
|
所有自定义效果字典
|
|
"""
|
|
return self.custom_effects.copy()
|
|
|
|
def process_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""
|
|
处理效果并计算当前强度
|
|
|
|
Args:
|
|
effect_data: 效果数据
|
|
time_progress: 时间进度(0.0-1.0)
|
|
|
|
Returns:
|
|
当前强度值(0.0-1.0)
|
|
"""
|
|
try:
|
|
effect_type = effect_data.get('type', EffectType.SIMPLE)
|
|
intensity = effect_data.get('intensity', 1.0)
|
|
|
|
# 根据效果类型计算强度
|
|
if effect_type == EffectType.SIMPLE:
|
|
current_intensity = self._process_simple_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.PERIODIC:
|
|
current_intensity = self._process_periodic_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.ENVELOPE:
|
|
current_intensity = self._process_envelope_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.RAMP:
|
|
current_intensity = self._process_ramp_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.NOISE:
|
|
current_intensity = self._process_noise_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.IMPULSE:
|
|
current_intensity = self._process_impulse_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.EXPLOSION:
|
|
current_intensity = self._process_explosion_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.TEXTURE:
|
|
current_intensity = self._process_texture_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.WIND:
|
|
current_intensity = self._process_wind_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.WATER:
|
|
current_intensity = self._process_water_effect(effect_data, time_progress)
|
|
elif effect_type == EffectType.CUSTOM:
|
|
current_intensity = self._process_custom_effect(effect_data, time_progress)
|
|
else:
|
|
current_intensity = intensity # 默认返回固定强度
|
|
|
|
# 应用总体强度
|
|
current_intensity *= intensity
|
|
|
|
# 触发效果处理回调
|
|
self._trigger_effect_callback('effect_processed', {
|
|
'effect_data': effect_data,
|
|
'time_progress': time_progress,
|
|
'current_intensity': current_intensity
|
|
})
|
|
|
|
self.stats['effects_processed'] += 1
|
|
return max(0.0, min(1.0, current_intensity))
|
|
|
|
except Exception as e:
|
|
print(f"✗ 效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_simple_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理简单效果"""
|
|
return 1.0 # 固定强度
|
|
|
|
def _process_periodic_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理周期性效果"""
|
|
try:
|
|
frequency = effect_data.get('frequency', 10.0)
|
|
amplitude = effect_data.get('amplitude', 1.0)
|
|
offset = effect_data.get('offset', 0.0)
|
|
phase = effect_data.get('phase', 0.0)
|
|
waveform = effect_data.get('waveform', 'sine')
|
|
duration = effect_data.get('duration', 1.0)
|
|
|
|
# 生成波形
|
|
generator = self.waveform_generators.get(waveform, self._generate_sine_wave)
|
|
cache_key = f"{waveform}_{frequency}_{duration}"
|
|
|
|
# 检查缓存
|
|
if cache_key in self.waveform_cache:
|
|
waveform_data = self.waveform_cache[cache_key]
|
|
else:
|
|
# 生成波形数据
|
|
sample_count = max(100, int(frequency * duration * 10))
|
|
waveform_data = generator(frequency, duration, sample_count)
|
|
self.waveform_cache[cache_key] = waveform_data
|
|
self.stats['waveforms_generated'] += 1
|
|
|
|
# 计算当前样本索引
|
|
sample_index = int(time_progress * (len(waveform_data) - 1))
|
|
sample_index = max(0, min(len(waveform_data) - 1, sample_index))
|
|
|
|
# 获取波形值
|
|
waveform_value = waveform_data[sample_index]
|
|
|
|
# 应用振幅和偏移
|
|
result = offset + amplitude * waveform_value
|
|
|
|
return max(0.0, min(1.0, result))
|
|
except Exception as e:
|
|
print(f"✗ 周期性效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_envelope_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理包络效果"""
|
|
try:
|
|
attack_time = effect_data.get('attack_time', 0.1)
|
|
attack_level = effect_data.get('attack_level', 1.0)
|
|
fade_time = effect_data.get('fade_time', 0.1)
|
|
fade_level = effect_data.get('fade_level', 0.0)
|
|
sustain_level = effect_data.get('sustain_level', 0.5)
|
|
duration = effect_data.get('duration', 1.0)
|
|
|
|
if time_progress <= attack_time / duration:
|
|
# 攻击阶段
|
|
attack_progress = time_progress / (attack_time / duration)
|
|
return attack_progress * attack_level
|
|
elif time_progress >= 1.0 - (fade_time / duration):
|
|
# 衰减阶段
|
|
fade_progress = (time_progress - (1.0 - (fade_time / duration))) / (fade_time / duration)
|
|
return fade_level + (1.0 - fade_progress) * (sustain_level - fade_level)
|
|
else:
|
|
# 保持阶段
|
|
return sustain_level
|
|
except Exception as e:
|
|
print(f"✗ 包络效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_ramp_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理斜坡效果"""
|
|
try:
|
|
start_level = effect_data.get('start_level', 0.0)
|
|
end_level = effect_data.get('end_level', 1.0)
|
|
curve_type = effect_data.get('curve_type', 'linear')
|
|
|
|
if curve_type == 'exponential':
|
|
# 指数曲线
|
|
return start_level + (end_level - start_level) * (time_progress ** 2)
|
|
elif curve_type == 'logarithmic':
|
|
# 对数曲线
|
|
if time_progress <= 0:
|
|
return start_level
|
|
return start_level + (end_level - start_level) * math.log10(1 + 9 * time_progress)
|
|
else:
|
|
# 线性曲线
|
|
return start_level + (end_level - start_level) * time_progress
|
|
except Exception as e:
|
|
print(f"✗ 斜坡效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_noise_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理噪声效果"""
|
|
try:
|
|
frequency = effect_data.get('frequency', 10.0)
|
|
noise_type = effect_data.get('noise_type', 'white')
|
|
duration = effect_data.get('duration', 1.0)
|
|
|
|
# 生成噪声
|
|
generator = self.noise_generators.get(noise_type, self._generate_white_noise)
|
|
cache_key = f"{noise_type}_{frequency}_{duration}"
|
|
|
|
# 检查缓存
|
|
if cache_key in self.noise_cache:
|
|
noise_data = self.noise_cache[cache_key]
|
|
else:
|
|
# 生成噪声数据
|
|
sample_count = max(100, int(frequency * duration * 10))
|
|
noise_data = generator(sample_count)
|
|
self.noise_cache[cache_key] = noise_data
|
|
self.stats['noise_samples'] += sample_count
|
|
|
|
# 计算当前样本索引
|
|
sample_index = int(time_progress * (len(noise_data) - 1))
|
|
sample_index = max(0, min(len(noise_data) - 1, sample_index))
|
|
|
|
# 获取噪声值
|
|
noise_value = noise_data[sample_index]
|
|
|
|
return max(0.0, min(1.0, noise_value))
|
|
except Exception as e:
|
|
print(f"✗ 噪声效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_impulse_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理脉冲效果"""
|
|
try:
|
|
duration = effect_data.get('duration', 0.1)
|
|
sharpness = effect_data.get('sharpness', 0.5)
|
|
shape = effect_data.get('shape', 'gaussian')
|
|
|
|
# 生成脉冲
|
|
generator = self.impulse_shapes.get(shape, self._generate_gaussian_impulse)
|
|
|
|
# 计算脉冲值
|
|
impulse_value = generator(time_progress, sharpness)
|
|
|
|
return max(0.0, min(1.0, impulse_value))
|
|
except Exception as e:
|
|
print(f"✗ 脉冲效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_explosion_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理爆炸效果"""
|
|
try:
|
|
rise_time = effect_data.get('rise_time', 0.05)
|
|
fall_time = effect_data.get('fall_time', 0.5)
|
|
frequency_start = effect_data.get('frequency_start', 80.0)
|
|
frequency_end = effect_data.get('frequency_end', 10.0)
|
|
duration = effect_data.get('duration', 1.0)
|
|
|
|
# 计算频率变化
|
|
frequency = frequency_start + (frequency_end - frequency_start) * time_progress
|
|
|
|
# 计算振幅包络
|
|
if time_progress <= rise_time / duration:
|
|
# 上升阶段
|
|
envelope = time_progress / (rise_time / duration)
|
|
else:
|
|
# 下降阶段
|
|
fall_progress = (time_progress - (rise_time / duration)) / ((duration - rise_time) / duration)
|
|
envelope = max(0.0, 1.0 - fall_progress)
|
|
|
|
# 生成振动
|
|
vibration = math.sin(2 * math.pi * frequency * time_progress * duration)
|
|
result = envelope * (vibration + 1.0) / 2.0 # 转换到0-1范围
|
|
|
|
return max(0.0, min(1.0, result))
|
|
except Exception as e:
|
|
print(f"✗ 爆炸效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_texture_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理纹理效果"""
|
|
try:
|
|
frequency = effect_data.get('frequency', 10.0)
|
|
roughness = effect_data.get('roughness', 0.5)
|
|
spacing = effect_data.get('spacing', 0.1)
|
|
|
|
# 生成纹理模式
|
|
texture_position = time_progress * frequency
|
|
texture_phase = texture_position - math.floor(texture_position)
|
|
|
|
# 根据粗糙度调整强度
|
|
if texture_phase < spacing:
|
|
# 纹理凸起
|
|
intensity = 1.0 - (texture_phase / spacing) * roughness
|
|
else:
|
|
# 纹理凹陷
|
|
intensity = 0.5 + 0.5 * roughness * math.sin(2 * math.pi * texture_phase)
|
|
|
|
return max(0.0, min(1.0, intensity))
|
|
except Exception as e:
|
|
print(f"✗ 纹理效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_wind_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理风效果"""
|
|
try:
|
|
frequency = effect_data.get('frequency', 1.0)
|
|
turbulence = effect_data.get('turbulence', 0.5)
|
|
direction_variability = effect_data.get('direction_variability', 0.3)
|
|
|
|
# 基础风模式
|
|
base_wind = math.sin(2 * math.pi * frequency * time_progress)
|
|
|
|
# 添加湍流
|
|
turbulence_effect = turbulence * math.sin(2 * math.pi * frequency * 5 * time_progress)
|
|
|
|
# 添加方向变化
|
|
direction_effect = direction_variability * math.sin(2 * math.pi * frequency * 0.2 * time_progress)
|
|
|
|
# 组合效果
|
|
result = (base_wind + turbulence_effect + direction_effect) / 3.0
|
|
result = (result + 1.0) / 2.0 # 转换到0-1范围
|
|
|
|
return max(0.0, min(1.0, result))
|
|
except Exception as e:
|
|
print(f"✗ 风效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_water_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理水效果"""
|
|
try:
|
|
frequency = effect_data.get('frequency', 1.0)
|
|
wave_height = effect_data.get('wave_height', 1.0)
|
|
viscosity = effect_data.get('viscosity', 1.0)
|
|
|
|
# 主波浪
|
|
main_wave = math.sin(2 * math.pi * frequency * time_progress)
|
|
|
|
# 次级波浪
|
|
secondary_wave = 0.5 * math.sin(2 * math.pi * frequency * 2.5 * time_progress + 0.5)
|
|
|
|
# 粘性阻尼
|
|
damping = math.exp(-viscosity * time_progress)
|
|
|
|
# 组合效果
|
|
result = (main_wave + secondary_wave) * damping * wave_height
|
|
result = (result + 1.0) / 2.0 # 转换到0-1范围
|
|
|
|
return max(0.0, min(1.0, result))
|
|
except Exception as e:
|
|
print(f"✗ 水效果处理失败: {e}")
|
|
return 0.0
|
|
|
|
def _process_custom_effect(self, effect_data: Dict[str, Any], time_progress: float) -> float:
|
|
"""处理自定义效果"""
|
|
# 这里可以实现更复杂的自定义效果处理逻辑
|
|
parameters = effect_data.get('parameters', {})
|
|
custom_intensity = parameters.get('intensity_multiplier', 1.0)
|
|
return custom_intensity # 默认返回固定强度
|
|
|
|
def _generate_sine_wave(self, frequency: float, duration: float, samples: int) -> List[float]:
|
|
"""生成正弦波"""
|
|
wave = []
|
|
for i in range(samples):
|
|
t = i / (samples - 1) * duration
|
|
value = math.sin(2 * math.pi * frequency * t)
|
|
wave.append(value)
|
|
return wave
|
|
|
|
def _generate_square_wave(self, frequency: float, duration: float, samples: int) -> List[float]:
|
|
"""生成方波"""
|
|
wave = []
|
|
for i in range(samples):
|
|
t = i / (samples - 1) * duration
|
|
value = 1.0 if math.sin(2 * math.pi * frequency * t) >= 0 else -1.0
|
|
wave.append(value)
|
|
return wave
|
|
|
|
def _generate_triangle_wave(self, frequency: float, duration: float, samples: int) -> List[float]:
|
|
"""生成三角波"""
|
|
wave = []
|
|
for i in range(samples):
|
|
t = i / (samples - 1) * duration
|
|
value = 2 * abs(2 * (frequency * t - math.floor(frequency * t + 0.5))) - 1
|
|
wave.append(value)
|
|
return wave
|
|
|
|
def _generate_sawtooth_wave(self, frequency: float, duration: float, samples: int) -> List[float]:
|
|
"""生成锯齿波"""
|
|
wave = []
|
|
for i in range(samples):
|
|
t = i / (samples - 1) * duration
|
|
value = 2 * (frequency * t - math.floor(frequency * t + 0.5))
|
|
wave.append(value)
|
|
return wave
|
|
|
|
def _generate_white_noise(self, samples: int) -> List[float]:
|
|
"""生成白噪声"""
|
|
noise = []
|
|
for _ in range(samples):
|
|
value = self.random_generator.uniform(-1.0, 1.0)
|
|
noise.append(value)
|
|
return noise
|
|
|
|
def _generate_pink_noise(self, samples: int) -> List[float]:
|
|
"""生成粉红噪声"""
|
|
noise = []
|
|
b = [0.0] * 7
|
|
for _ in range(samples):
|
|
white = self.random_generator.uniform(-1.0, 1.0)
|
|
b[0] = 0.99886 * b[0] + white * 0.0555179
|
|
b[1] = 0.99332 * b[1] + white * 0.0750759
|
|
b[2] = 0.96900 * b[2] + white * 0.1538520
|
|
b[3] = 0.86650 * b[3] + white * 0.3104856
|
|
b[4] = 0.55000 * b[4] + white * 0.5329522
|
|
b[5] = -0.7616 * b[5] - white * 0.0168980
|
|
pink = b[0] + b[1] + b[2] + b[3] + b[4] + b[5] + b[6] + white * 0.5362
|
|
b[6] = white * 0.115926
|
|
noise.append(pink / 5.0) # 归一化
|
|
return noise
|
|
|
|
def _generate_brown_noise(self, samples: int) -> List[float]:
|
|
"""生成布朗噪声"""
|
|
noise = []
|
|
last = 0.0
|
|
for _ in range(samples):
|
|
white = self.random_generator.uniform(-1.0, 1.0)
|
|
brown = (last + (0.02 * white)) / 1.02
|
|
last = brown
|
|
noise.append(brown * 3.5) # 补偿幅度
|
|
return noise
|
|
|
|
def _generate_gaussian_impulse(self, time_progress: float, sharpness: float) -> float:
|
|
"""生成高斯脉冲"""
|
|
try:
|
|
# 高斯函数: exp(-(x^2)/(2*sigma^2))
|
|
sigma = 0.2 * (1.0 - sharpness * 0.8) # 根据锐度调整宽度
|
|
x = (time_progress - 0.5) * 2 # 调整到-1到1范围
|
|
value = math.exp(-(x*x) / (2 * sigma * sigma))
|
|
return value
|
|
except Exception:
|
|
return 0.0
|
|
|
|
def _generate_exponential_impulse(self, time_progress: float, sharpness: float) -> float:
|
|
"""生成指数脉冲"""
|
|
try:
|
|
if time_progress < 0.5:
|
|
# 上升阶段
|
|
rise_factor = 1.0 + 9.0 * sharpness # 1到10
|
|
value = 1.0 - math.exp(-rise_factor * time_progress * 2)
|
|
else:
|
|
# 下降阶段
|
|
fall_factor = 1.0 + 9.0 * (1.0 - sharpness) # 1到10
|
|
value = math.exp(-fall_factor * (time_progress - 0.5) * 2)
|
|
return value
|
|
except Exception:
|
|
return 0.0
|
|
|
|
def _generate_linear_impulse(self, time_progress: float, sharpness: float) -> float:
|
|
"""生成线性脉冲"""
|
|
try:
|
|
peak_position = 0.3 + 0.4 * sharpness # 0.3到0.7
|
|
if time_progress < peak_position:
|
|
# 上升阶段
|
|
value = time_progress / peak_position
|
|
else:
|
|
# 下降阶段
|
|
value = 1.0 - (time_progress - peak_position) / (1.0 - peak_position)
|
|
return max(0.0, value)
|
|
except Exception:
|
|
return 0.0
|
|
|
|
def mix_effects(self, effects: List[Dict[str, Any]], time_progress: float,
|
|
mix_mode: str = 'max', weights: List[float] = None) -> float:
|
|
"""
|
|
混合多个效果
|
|
|
|
Args:
|
|
effects: 效果数据列表
|
|
time_progress: 时间进度(0.0-1.0)
|
|
mix_mode: 混合模式('max', 'add', 'multiply', 'average', 'weighted')
|
|
weights: 权重列表（用于加权混合）
|
|
|
|
Returns:
|
|
混合后的强度值(0.0-1.0)
|
|
"""
|
|
try:
|
|
intensities = []
|
|
for effect_data in effects:
|
|
intensity = self.process_effect(effect_data, time_progress)
|
|
intensities.append(intensity)
|
|
|
|
if not intensities:
|
|
return 0.0
|
|
|
|
# 根据混合模式计算最终强度
|
|
if mix_mode == 'weighted' and weights:
|
|
mix_function = self._mix_weighted
|
|
return mix_function(intensities, weights)
|
|
else:
|
|
mix_function = self.effect_mixing.get(mix_mode, self._mix_max)
|
|
return mix_function(intensities)
|
|
|
|
except Exception as e:
|
|
print(f"✗ 效果混合失败: {e}")
|
|
return 0.0
|
|
|
|
def _mix_max(self, intensities: List[float]) -> float:
|
|
"""最大值混合"""
|
|
return max(intensities)
|
|
|
|
def _mix_add(self, intensities: List[float]) -> float:
|
|
"""加法混合"""
|
|
return min(1.0, sum(intensities))
|
|
|
|
def _mix_multiply(self, intensities: List[float]) -> float:
|
|
"""乘法混合"""
|
|
result = 1.0
|
|
for intensity in intensities:
|
|
result *= max(0.0, intensity) # 避免负值影响
|
|
return result
|
|
|
|
def _mix_average(self, intensities: List[float]) -> float:
|
|
"""平均值混合"""
|
|
return sum(intensities) / len(intensities) if intensities else 0.0
|
|
|
|
def _mix_weighted(self, intensities: List[float], weights: List[float]) -> float:
|
|
"""加权混合"""
|
|
if len(intensities) != len(weights):
|
|
return self._mix_average(intensities)
|
|
|
|
weighted_sum = sum(intensity * weight for intensity, weight in zip(intensities, weights))
|
|
total_weight = sum(weights)
|
|
return weighted_sum / total_weight if total_weight > 0 else 0.0
|
|
|
|
def get_effect_parameters(self, effect_type: str) -> Dict[str, tuple]:
|
|
"""
|
|
获取效果参数信息
|
|
|
|
Args:
|
|
effect_type: 效果类型
|
|
|
|
Returns:
|
|
参数信息字典
|
|
"""
|
|
return self.effect_parameters.get(effect_type, {})
|
|
|
|
def get_predefined_effects(self) -> Dict[str, Dict[str, Any]]:
|
|
"""
|
|
获取预定义效果
|
|
|
|
Returns:
|
|
预定义效果字典
|
|
"""
|
|
return self.predefined_effects.copy()
|
|
|
|
def _trigger_effect_callback(self, callback_type: str, data: Dict[str, Any]):
|
|
"""
|
|
触发效果回调
|
|
|
|
Args:
|
|
callback_type: 回调类型
|
|
data: 回调数据
|
|
"""
|
|
try:
|
|
if callback_type in self.effect_callbacks:
|
|
for callback in self.effect_callbacks[callback_type]:
|
|
try:
|
|
callback(data)
|
|
except Exception as e:
|
|
print(f"✗ 效果回调执行失败: {e}")
|
|
except Exception as e:
|
|
print(f"✗ 效果回调触发失败: {e}")
|
|
|
|
def register_effect_callback(self, callback_type: str, callback: callable):
|
|
"""
|
|
注册效果回调
|
|
|
|
Args:
|
|
callback_type: 回调类型
|
|
callback: 回调函数
|
|
"""
|
|
try:
|
|
if callback_type in self.effect_callbacks:
|
|
self.effect_callbacks[callback_type].append(callback)
|
|
print(f"✓ 效果回调已注册: {callback_type}")
|
|
else:
|
|
print(f"✗ 无效的回调类型: {callback_type}")
|
|
except Exception as e:
|
|
print(f"✗ 效果回调注册失败: {e}")
|
|
|
|
def unregister_effect_callback(self, callback_type: str, callback: callable):
|
|
"""
|
|
注销效果回调
|
|
|
|
Args:
|
|
callback_type: 回调类型
|
|
callback: 回调函数
|
|
"""
|
|
try:
|
|
if callback_type in self.effect_callbacks:
|
|
if callback in self.effect_callbacks[callback_type]:
|
|
self.effect_callbacks[callback_type].remove(callback)
|
|
print(f"✓ 效果回调已注销: {callback_type}")
|
|
except Exception as e:
|
|
print(f"✗ 效果回调注销失败: {e}")
|
|
|
|
def get_stats(self) -> Dict[str, int]:
|
|
"""
|
|
获取统计信息
|
|
|
|
Returns:
|
|
统计信息字典
|
|
"""
|
|
return self.stats.copy()
|
|
|
|
def reset_stats(self):
|
|
"""重置统计信息"""
|
|
try:
|
|
self.stats = {
|
|
'templates_created': 0,
|
|
'effects_generated': 0,
|
|
'effects_processed': 0,
|
|
'custom_effects': 0,
|
|
'waveforms_generated': 0,
|
|
'noise_samples': 0
|
|
}
|
|
print("✓ 效果处理器统计信息已重置")
|
|
except Exception as e:
|
|
print(f"✗ 效果处理器统计信息重置失败: {e}") |