""" 空间音频效果处理器 实现专业的3D空间音频效果处理 """ import uuid import math import numpy as np from typing import Dict, List, Any, Optional, Tuple from panda3d.core import Vec3 class SpatialProcessor: """ 空间音频效果处理器 实现专业的3D空间音频效果处理 """ def __init__(self, plugin): """ 初始化空间音频效果处理器 Args: plugin: 音频效果插件实例 """ self.plugin = plugin self.effects: Dict[str, Dict[str, Any]] = {} self.stats = { 'total_effects': 0, 'active_effects': 0, 'effects_processed': 0, 'processing_time': 0.0, 'memory_usage': 0 } self.buffer_size = plugin.buffer_size if plugin else 4096 self.sample_rate = 44100 # 默认采样率 self.speed_of_sound = 343.0 # 声速 (米/秒) def create_effect(self, parameters: Dict[str, Any]) -> str: """ 创建空间音频效果 Args: parameters: 空间音频效果参数 Returns: 效果ID """ try: # 生成唯一ID effect_id = str(uuid.uuid4()) # 默认参数 default_params = { 'source_position': (0.0, 0.0, 0.0), # 音源位置 (x, y, z) 'listener_position': (0.0, 0.0, 0.0), # 听者位置 (x, y, z) 'listener_orientation': (0.0, 0.0, 0.0), # 听者方向 (heading, pitch, roll) 'min_distance': 1.0, # 最小距离 'max_distance': 100.0, # 最大距离 'rolloff_factor': 1.0, # 衰减因子 'cone_inner_angle': 360.0, # 内锥角 (度) 'cone_outer_angle': 360.0, # 外锥角 (度) 'cone_outer_gain': 1.0, # 外锥增益 'doppler_factor': 1.0, # 多普勒因子 'spread': 0.0, # 扩散角度 (度) 'air_absorption': 0.0, # 空气吸收 'room_rolloff': 0.0, # 房间衰减 'occlusion': 0.0, # 遮挡 (0.0-1.0) 'obstruction': 0.0, # 阻挡 (0.0-1.0) 'hrtf_enabled': False, # HRTF启用 'reverb_send': 0.0 # 混响发送 (0.0-1.0) } # 合并参数 effect_params = default_params.copy() effect_params.update(parameters) # 创建效果对象 effect = { 'id': effect_id, 'type': 'spatial', 'parameters': effect_params, 'active': True, 'buffers': {}, # 缓冲区 'hrtf_filters': {}, # HRTF滤波器 'distance': 0.0, # 当前距离 'azimuth': 0.0, # 方位角 'elevation': 0.0, # 仰角 'created_time': self._get_current_time(), 'process_count': 0 } # 初始化缓冲区 self._initialize_buffers(effect) # 初始化HRTF滤波器 if effect_params.get('hrtf_enabled', False): self._initialize_hrtf_filters(effect) # 存储效果 self.effects[effect_id] = effect # 更新统计信息 self.stats['total_effects'] += 1 self.stats['active_effects'] += 1 # 在插件中注册效果 if self.plugin: self.plugin.effects[effect_id] = effect.copy() print(f"✓ 空间音频效果创建成功: {effect_id}") return effect_id except Exception as e: print(f"✗ 创建空间音频效果失败: {e}") import traceback traceback.print_exc() return "" def _initialize_buffers(self, effect: Dict[str, Any]): """ 初始化缓冲区 Args: effect: 效果对象 """ effect_id = effect['id'] buffers = {} # 输入和输出缓冲区 buffers['input'] = np.zeros(self.buffer_size) buffers['output_left'] = np.zeros(self.buffer_size) buffers['output_right'] = np.zeros(self.buffer_size) # 延迟缓冲区（用于多普勒效应） buffers['delay_line'] = np.zeros(int(0.1 * self.sample_rate)) # 100ms延迟线 buffers['delay_index'] = 0 effect['buffers'] = buffers def _initialize_hrtf_filters(self, effect: Dict[str, Any]): """ 初始化HRTF滤波器 Args: effect: 效果对象 """ # 这里应该加载真实的HRTF数据 # 简化实现使用生成的滤波器 hrtf_filters = {} # 为不同的角度生成简化的HRTF滤波器 for azimuth in range(-180, 181, 15): # 每15度一个滤波器 for elevation in range(-90, 91, 15): # 生成简化的HRTF滤波器系数 left_filter = self._generate_simple_hrtf_filter(azimuth, elevation, 'left') right_filter = self._generate_simple_hrtf_filter(azimuth, elevation, 'right') hrtf_filters[(azimuth, elevation)] = { 'left': left_filter, 'right': right_filter } effect['hrtf_filters'] = hrtf_filters def _generate_simple_hrtf_filter(self, azimuth: int, elevation: int, channel: str) -> np.ndarray: """ 生成简化的HRTF滤波器 Args: azimuth: 方位角 (度) elevation: 仰角 (度) channel: 声道 ('left' 或 'right') Returns: 滤波器系数数组 """ # 简化的HRTF滤波器生成 # 实际应用中会使用真实的HRTF测量数据 # 滤波器长度 filter_length = 64 # 生成基于角度的简化的滤波器 filter_coeffs = np.zeros(filter_length) # 基于角度计算延迟和幅度 if channel == 'left': # 左耳滤波器 delay = max(0, int((1.0 - math.cos(math.radians(azimuth))) * 10)) amplitude = 0.5 + 0.5 * math.cos(math.radians(azimuth)) else: # 右耳滤波器 delay = max(0, int((1.0 - math.cos(math.radians(-azimuth))) * 10)) amplitude = 0.5 + 0.5 * math.cos(math.radians(-azimuth)) # 应用延迟和幅度 if delay < filter_length: filter_coeffs[delay] = amplitude return filter_coeffs def delete_effect(self, effect_id: str) -> bool: """ 删除空间音频效果 Args: effect_id: 效果ID Returns: 是否删除成功 """ if effect_id not in self.effects: print(f"✗ 空间音频效果不存在: {effect_id}") return False try: # 删除效果 del self.effects[effect_id] # 更新统计信息 self.stats['active_effects'] -= 1 # 从插件中移除效果 if self.plugin and effect_id in self.plugin.effects: del self.plugin.effects[effect_id] print(f"✓ 空间音频效果已删除: {effect_id}") return True except Exception as e: print(f"✗ 删除空间音频效果失败: {e}") return False def process(self, audio_data: Any, parameters: Dict[str, Any]) -> Any: """ 处理空间音频效果 Args: audio_data: 输入音频数据 parameters: 效果参数 Returns: 处理后的音频数据 """ try: import time process_start = time.time() # 如果输入是NumPy数组 if isinstance(audio_data, np.ndarray): processed_data = self._process_numpy_array(audio_data, parameters) else: # 对于其他类型的数据，返回原始数据 processed_data = audio_data # 更新统计信息 self.stats['effects_processed'] += 1 self.stats['processing_time'] += (time.time() - process_start) return processed_data except Exception as e: print(f"✗ 空间音频效果处理失败: {e}") return audio_data def _process_numpy_array(self, audio_data: np.ndarray, parameters: Dict[str, Any]) -> np.ndarray: """ 处理NumPy数组音频数据 Args: audio_data: 输入音频数据 parameters: 效果参数 Returns: 处理后的音频数据 """ # 获取参数 source_pos = Vec3(*parameters.get('source_position', (0.0, 0.0, 0.0))) listener_pos = Vec3(*parameters.get('listener_position', (0.0, 0.0, 0.0))) listener_orient = parameters.get('listener_orientation', (0.0, 0.0, 0.0)) min_distance = max(0.1, parameters.get('min_distance', 1.0)) max_distance = max(min_distance, parameters.get('max_distance', 100.0)) rolloff_factor = max(0.0, parameters.get('rolloff_factor', 1.0)) cone_inner_angle = max(0.0, min(360.0, parameters.get('cone_inner_angle', 360.0))) cone_outer_angle = max(cone_inner_angle, min(360.0, parameters.get('cone_outer_angle', 360.0))) cone_outer_gain = max(0.0, min(1.0, parameters.get('cone_outer_gain', 1.0))) doppler_factor = max(0.0, parameters.get('doppler_factor', 1.0)) spread = max(0.0, parameters.get('spread', 0.0)) air_absorption = max(0.0, parameters.get('air_absorption', 0.0)) occlusion = max(0.0, min(1.0, parameters.get('occlusion', 0.0))) obstruction = max(0.0, min(1.0, parameters.get('obstruction', 0.0))) hrtf_enabled = parameters.get('hrtf_enabled', False) reverb_send = max(0.0, min(1.0, parameters.get('reverb_send', 0.0))) # 计算距离 distance = (source_pos - listener_pos).length() # 计算方位角和仰角 azimuth, elevation = self._calculate_angles(source_pos, listener_pos, listener_orient) # 计算音量衰减 volume = self._calculate_volume_attenuation( distance, min_distance, max_distance, rolloff_factor) # 计算锥形效应 cone_gain = self._calculate_cone_gain( source_pos, listener_pos, listener_orient, cone_inner_angle, cone_outer_angle, cone_outer_gain) # 计算遮挡和阻挡 occlusion_gain = 1.0 - occlusion * 0.8 # 最多减少80%音量 obstruction_gain = 1.0 - obstruction * 0.5 # 最多减少50%音量 # 计算多普勒效应 doppler_shift = self._calculate_doppler_shift( source_pos, listener_pos, doppler_factor) # 计算空气吸收 air_absorption_gain = 1.0 - (distance / max_distance) * air_absorption * 0.5 # 综合增益 total_gain = (volume * cone_gain * occlusion_gain * obstruction_gain * air_absorption_gain) # 创建输出数组 if audio_data.ndim == 1: # 单声道输入，生成立体声输出 output_left = np.zeros_like(audio_data) output_right = np.zeros_like(audio_data) for i in range(len(audio_data)): sample = audio_data[i] # 应用增益 processed_sample = sample * total_gain # 应用HRTF或简单立体声处理 if hrtf_enabled: # 简化的HRTF应用 left_sample, right_sample = self._apply_hrtf( processed_sample, azimuth, elevation) else: # 简单的立体声平移 left_sample, right_sample = self._simple_stereo_pan( processed_sample, azimuth, spread) output_left[i] = left_sample output_right[i] = right_sample # 合并为立体声数组 output_data = np.array([output_left, output_right]) else: # 多声道处理 if audio_data.shape[0] >= 2: # 已经是立体声，应用空间效果 output_left = np.zeros_like(audio_data[0]) output_right = np.zeros_like(audio_data[1]) for i in range(audio_data.shape[1]): left_sample = audio_data[0, i] * total_gain right_sample = audio_data[1, i] * total_gain # 应用HRTF或简单立体声处理 if hrtf_enabled: # 简化的HRTF应用 new_left, new_right = self._apply_hrtf( (left_sample + right_sample) * 0.5, azimuth, elevation) output_left[i] = new_left output_right[i] = new_right else: # 简单的立体声平移 new_left, new_right = self._simple_stereo_pan( (left_sample + right_sample) * 0.5, azimuth, spread) output_left[i] = new_left output_right[i] = new_right output_data = np.array([output_left, output_right]) else: # 其他多声道情况，返回原始数据 output_data = audio_data # 确保输出在有效范围内 processed_data = np.clip(output_data, -1.0, 1.0) return processed_data def _calculate_angles(self, source_pos: Vec3, listener_pos: Vec3, listener_orient: Tuple[float, float, float]) -> Tuple[float, float]: """ 计算方位角和仰角 Args: source_pos: 音源位置 listener_pos: 听者位置 listener_orient: 听者方向 Returns: (方位角, 仰角) (度) """ # 计算相对位置 relative_pos = source_pos - listener_pos # 计算方位角 (水平角度) azimuth = math.degrees(math.atan2(relative_pos.x, -relative_pos.y)) # 计算仰角 (垂直角度) distance_xy = math.sqrt(relative_pos.x**2 + relative_pos.y**2) elevation = math.degrees(math.atan2(relative_pos.z, distance_xy)) return azimuth, elevation def _calculate_volume_attenuation(self, distance: float, min_distance: float, max_distance: float, rolloff_factor: float) -> float: """ 计算音量衰减 Args: distance: 距离 min_distance: 最小距离 max_distance: 最大距离 rolloff_factor: 衰减因子 Returns: 音量增益 (0.0-1.0) """ if distance <= min_distance: return 1.0 elif distance >= max_distance: return 0.0 else: # 反距离衰减模型 gain = min_distance / (min_distance + rolloff_factor * (distance - min_distance)) return max(0.0, min(1.0, gain)) def _calculate_cone_gain(self, source_pos: Vec3, listener_pos: Vec3, listener_orient: Tuple[float, float, float], inner_angle: float, outer_angle: float, outer_gain: float) -> float: """ 计算锥形效应增益 Args: source_pos: 音源位置 listener_pos: 听者位置 listener_orient: 听者方向 inner_angle: 内锥角 (度) outer_angle: 外锥角 (度) outer_gain: 外锥增益 Returns: 锥形增益 (0.0-1.0) """ # 简化的锥形效应计算 # 实际应用中需要考虑音源的朝向 if inner_angle >= 360.0 and outer_angle >= 360.0: return 1.0 # 计算听者相对于音源的角度 relative_pos = listener_pos - source_pos angle = math.degrees(math.acos(relative_pos.normalized().dot(Vec3(0, -1, 0)))) if angle <= inner_angle / 2.0: return 1.0 elif angle >= outer_angle / 2.0: return outer_gain else: # 线性插值 t = (angle - inner_angle / 2.0) / (outer_angle / 2.0 - inner_angle / 2.0) return 1.0 - t * (1.0 - outer_gain) def _calculate_doppler_shift(self, source_pos: Vec3, listener_pos: Vec3, doppler_factor: float) -> float: """ 计算多普勒频移 Args: source_pos: 音源位置 listener_pos: 听者位置 doppler_factor: 多普勒因子 Returns: 频移比率 """ # 简化的多普勒效应计算 # 实际应用中需要考虑音源和听者的速度 if doppler_factor <= 0.0: return 1.0 # 计算相对速度（简化为距离变化率） relative_velocity = (source_pos - listener_pos).length() / self.sample_rate ratio = (self.speed_of_sound - doppler_factor * relative_velocity) / self.speed_of_sound return max(0.5, min(2.0, ratio)) def _apply_hrtf(self, sample: float, azimuth: float, elevation: float) -> Tuple[float, float]: """ 应用HRTF Args: sample: 输入样本 azimuth: 方位角 (度) elevation: 仰角 (度) Returns: (左声道样本, 右声道样本) """ # 简化的HRTF应用 # 实际应用中会使用真实的HRTF滤波器 # 量化角度以匹配预生成的滤波器 azimuth_quantized = int(round(azimuth / 15.0)) * 15 elevation_quantized = int(round(elevation / 15.0)) * 15 # 限制角度范围 azimuth_quantized = max(-180, min(180, azimuth_quantized)) elevation_quantized = max(-90, min(90, elevation_quantized)) # 简化的HRTF效果 left_gain = 0.5 + 0.5 * math.cos(math.radians(azimuth)) right_gain = 0.5 + 0.5 * math.cos(math.radians(-azimuth)) # 应用仰角影响 elevation_factor = math.cos(math.radians(elevation)) left_gain *= elevation_factor right_gain *= elevation_factor return sample * left_gain, sample * right_gain def _simple_stereo_pan(self, sample: float, azimuth: float, spread: float) -> Tuple[float, float]: """ 简单的立体声平移 Args: sample: 输入样本 azimuth: 方位角 (度) spread: 扩散角度 Returns: (左声道样本, 右声道样本) """ # 将角度转换为-1到1的平移值 pan = math.sin(math.radians(azimuth)) # 应用扩散 if spread > 0: spread_factor = 1.0 - spread / 180.0 pan *= spread_factor # 计算左右声道增益 left_gain = 0.5 - 0.5 * pan right_gain = 0.5 + 0.5 * pan return sample * left_gain, sample * right_gain def set_parameter(self, effect_id: str, parameter: str, value: Any) -> bool: """ 设置效果参数 Args: effect_id: 效果ID parameter: 参数名 value: 参数值 Returns: 是否设置成功 """ if effect_id not in self.effects: print(f"✗ 空间音频效果不存在: {effect_id}") return False try: self.effects[effect_id]['parameters'][parameter] = value # 如果HRTF启用状态改变，重新初始化滤波器 if parameter == 'hrtf_enabled': if value: self._initialize_hrtf_filters(self.effects[effect_id]) else: self.effects[effect_id]['hrtf_filters'] = {} # 如果是插件中的效果，也更新插件中的副本 if self.plugin and effect_id in self.plugin.effects: self.plugin.effects[effect_id]['parameters'][parameter] = value if parameter == 'hrtf_enabled': self.plugin.effects[effect_id]['hrtf_filters'] = \ self.effects[effect_id]['hrtf_filters'].copy() print(f"✓ 空间音频效果参数已设置: {effect_id}.{parameter} = {value}") return True except Exception as e: print(f"✗ 设置空间音频效果参数失败: {e}") return False def get_parameters(self, effect_id: str) -> Dict[str, Any]: """ 获取效果参数 Args: effect_id: 效果ID Returns: 参数字典 """ if effect_id not in self.effects: return {} return self.effects[effect_id]['parameters'].copy() def enable_effect(self, effect_id: str) -> bool: """ 启用空间音频效果 Args: effect_id: 效果ID Returns: 是否启用成功 """ if effect_id not in self.effects: print(f"✗ 空间音频效果不存在: {effect_id}") return False try: self.effects[effect_id]['active'] = True self.stats['active_effects'] += 1 # 如果是插件中的效果，也更新插件中的副本 if self.plugin and effect_id in self.plugin.effects: self.plugin.effects[effect_id]['active'] = True print(f"✓ 空间音频效果已启用: {effect_id}") return True except Exception as e: print(f"✗ 启用空间音频效果失败: {e}") return False def disable_effect(self, effect_id: str) -> bool: """ 禁用空间音频效果 Args: effect_id: 效果ID Returns: 是否禁用成功 """ if effect_id not in self.effects: print(f"✗ 空间音频效果不存在: {effect_id}") return False try: self.effects[effect_id]['active'] = False self.stats['active_effects'] -= 1 # 如果是插件中的效果，也更新插件中的副本 if self.plugin and effect_id in self.plugin.effects: self.plugin.effects[effect_id]['active'] = False print(f"✓ 空间音频效果已禁用: {effect_id}") return True except Exception as e: print(f"✗ 禁用空间音频效果失败: {e}") return False def cleanup(self): """清理所有资源""" self.effects.clear() self.stats = { 'total_effects': 0, 'active_effects': 0, 'effects_processed': 0, 'processing_time': 0.0, 'memory_usage': 0 } print("✓ 空间音频效果处理器资源已清理") def get_stats(self) -> Dict[str, int]: """ 获取统计信息 Returns: 统计信息字典 """ return self.stats.copy() def _get_current_time(self) -> float: """ 获取当前时间（秒） Returns: 当前时间 """ if self.plugin and self.plugin.plugin_manager and self.plugin.plugin_manager.world: return self.plugin.plugin_manager.world.globalClock.getFrameTime() import time return time.time() def update(self, dt: float): """ 更新处理器状态 Args: dt: 时间增量 """ # 这里可以更新任何需要定期更新的状态 pass def set_sample_rate(self, sample_rate: int): """ 设置采样率 Args: sample_rate: 采样率 (Hz) """ self.sample_rate = sample_rate print(f"✓ 空间音频效果处理器采样率已设置: {sample_rate} Hz") def set_source_position(self, effect_id: str, position: Tuple[float, float, float]) -> bool: """ 设置音源位置 Args: effect_id: 效果ID position: 位置 (x, y, z) Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'source_position', position) def set_listener_position(self, effect_id: str, position: Tuple[float, float, float]) -> bool: """ 设置听者位置 Args: effect_id: 效果ID position: 位置 (x, y, z) Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'listener_position', position) def set_listener_orientation(self, effect_id: str, orientation: Tuple[float, float, float]) -> bool: """ 设置听者方向 Args: effect_id: 效果ID orientation: 方向 (heading, pitch, roll) Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'listener_orientation', orientation) def set_distance_model(self, effect_id: str, min_distance: float, max_distance: float, rolloff_factor: float) -> bool: """ 设置距离模型参数 Args: effect_id: 效果ID min_distance: 最小距离 max_distance: 最大距离 rolloff_factor: 衰减因子 Returns: 是否设置成功 """ success = True success &= self.set_parameter(effect_id, 'min_distance', max(0.1, min_distance)) success &= self.set_parameter(effect_id, 'max_distance', max(min_distance, max_distance)) success &= self.set_parameter(effect_id, 'rolloff_factor', max(0.0, rolloff_factor)) return success def set_cone_effect(self, effect_id: str, inner_angle: float, outer_angle: float, outer_gain: float) -> bool: """ 设置锥形效应参数 Args: effect_id: 效果ID inner_angle: 内锥角 (度) outer_angle: 外锥角 (度) outer_gain: 外锥增益 Returns: 是否设置成功 """ success = True success &= self.set_parameter(effect_id, 'cone_inner_angle', max(0.0, min(360.0, inner_angle))) success &= self.set_parameter(effect_id, 'cone_outer_angle', max(inner_angle, min(360.0, outer_angle))) success &= self.set_parameter(effect_id, 'cone_outer_gain', max(0.0, min(1.0, outer_gain))) return success def set_doppler_factor(self, effect_id: str, factor: float) -> bool: """ 设置多普勒因子 Args: effect_id: 效果ID factor: 多普勒因子 Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'doppler_factor', max(0.0, factor)) def set_spread(self, effect_id: str, spread: float) -> bool: """ 设置扩散角度 Args: effect_id: 效果ID spread: 扩散角度 (度) Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'spread', max(0.0, spread)) def set_air_absorption(self, effect_id: str, absorption: float) -> bool: """ 设置空气吸收 Args: effect_id: 效果ID absorption: 空气吸收系数 Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'air_absorption', max(0.0, min(1.0, absorption))) def set_occlusion(self, effect_id: str, occlusion: float) -> bool: """ 设置遮挡系数 Args: effect_id: 效果ID occlusion: 遮挡系数 (0.0-1.0) Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'occlusion', max(0.0, min(1.0, occlusion))) def set_obstruction(self, effect_id: str, obstruction: float) -> bool: """ 设置阻挡系数 Args: effect_id: 效果ID obstruction: 阻挡系数 (0.0-1.0) Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'obstruction', max(0.0, min(1.0, obstruction))) def enable_hrtf(self, effect_id: str, enable: bool) -> bool: """ 启用/禁用HRTF Args: effect_id: 效果ID enable: 是否启用 Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'hrtf_enabled', enable) def set_reverb_send(self, effect_id: str, send: float) -> bool: """ 设置混响发送量 Args: effect_id: 效果ID send: 混响发送量 (0.0-1.0) Returns: 是否设置成功 """ return self.set_parameter(effect_id, 'reverb_send', max(0.0, min(1.0, send))) def get_distance(self, effect_id: str) -> float: """ 获取当前距离 Args: effect_id: 效果ID Returns: 距离值 """ if effect_id not in self.effects: return 0.0 return self.effects[effect_id].get('distance', 0.0) def get_angles(self, effect_id: str) -> Tuple[float, float]: """ 获取当前角度 Args: effect_id: 效果ID Returns: (方位角, 仰角) (度) """ if effect_id not in self.effects: return (0.0, 0.0) effect = self.effects[effect_id] return (effect.get('azimuth', 0.0), effect.get('elevation', 0.0)) def create_preset(self, preset_name: str) -> Dict[str, Any]: """ 创建空间音频效果预设 Args: preset_name: 预设名称 Returns: 预设参数字典 """ presets = { 'close': { 'min_distance': 0.5, 'max_distance': 20.0, 'rolloff_factor': 1.0, 'doppler_factor': 1.0, 'air_absorption': 0.0 }, 'medium': { 'min_distance': 1.0, 'max_distance': 50.0, 'rolloff_factor': 0.8, 'doppler_factor': 0.8, 'air_absorption': 0.1 }, 'far': { 'min_distance': 5.0, 'max_distance': 100.0, 'rolloff_factor': 0.5, 'doppler_factor': 0.5, 'air_absorption': 0.3 }, 'outdoor': { 'min_distance': 2.0, 'max_distance': 200.0, 'rolloff_factor': 0.3, 'doppler_factor': 1.0, 'air_absorption': 0.5 }, 'indoor': { 'min_distance': 0.5, 'max_distance': 30.0, 'rolloff_factor': 1.2, 'doppler_factor': 0.7, 'air_absorption': 0.0 }, 'underwater': { 'min_distance': 1.0, 'max_distance': 40.0, 'rolloff_factor': 0.2, 'doppler_factor': 0.3, 'air_absorption': 0.8, 'speed_of_sound': 1500.0 # 水中声速 } } return presets.get(preset_name, {}).copy()