use std::sync::Arc;
use std::time::Duration;
use glam::{DQuat, DVec3};
use kira::{
effect::{
filter::{FilterBuilder, FilterHandle, FilterMode},
reverb::{ReverbBuilder, ReverbHandle},
},
sound::static_sound::{StaticSoundData, StaticSoundHandle, StaticSoundSettings},
track::{
SendTrackBuilder, SendTrackHandle, SpatialTrackBuilder, SpatialTrackDistances,
SpatialTrackHandle,
},
AudioManager, AudioManagerSettings, Decibels, DefaultBackend, Easing, Frame, Mix, Tween,
};
use crate::backend::{AudioOut, SourceId, SourcePool};
use crate::synth::SoundBuffer;
use crate::{AcousticsConfig, ListenerAcoustics, SoundKey, SourceAcoustics};
const FAST_TWEEN_MS: u64 = 120;
const ENV_TWEEN_MS: u64 = 1000;
const STEAL_TWEEN_MS: u64 = 15;
pub const DEFAULT_POOL: usize = 24;
const LISTENER_LOWPASS_FLOOR_HZ: f32 = 40.0;
fn tween(ms: u64) -> Tween {
Tween {
duration: Duration::from_millis(ms),
easing: Easing::Linear,
..Default::default()
}
}
fn mint_pos(p: DVec3) -> mint::Vector3<f32> {
p.as_vec3().into()
}
fn mix_to_db(mix: f32) -> Decibels {
if mix <= 1e-4 {
Decibels::SILENCE
} else {
Decibels((20.0 * mix.log10()).max(Decibels::SILENCE.0))
}
}
struct PoolTrack {
track: SpatialTrackHandle,
filter: FilterHandle,
sound: Option<StaticSoundHandle>,
}
pub struct KiraAudio {
#[allow(dead_code)]
manager: AudioManager<DefaultBackend>,
send: SendTrackHandle,
listener: kira::listener::ListenerHandle,
send_id: kira::track::SendTrackId,
reverb: ReverbHandle,
listener_filter: Option<FilterHandle>,
listener_cutoff: f32,
tracks: Vec<PoolTrack>,
pool: SourcePool,
sounds: Vec<StaticSoundData>,
}
impl KiraAudio {
pub fn new() -> Result<Self, Box<dyn std::error::Error>> {
Self::with_capacity(DEFAULT_POOL)
}
pub fn with_capacity(pool: usize) -> Result<Self, Box<dyn std::error::Error>> {
Self::with_options(pool, false)
}
pub fn with_options(
pool: usize,
listener_lowpass: bool,
) -> Result<Self, Box<dyn std::error::Error>> {
let mut settings = AudioManagerSettings::<DefaultBackend>::default();
let listener_filter = listener_lowpass.then(|| {
settings.main_track_builder.add_effect(
FilterBuilder::new()
.mode(FilterMode::LowPass)
.cutoff(f64::from(crate::LISTENER_LOWPASS_OPEN_HZ)),
)
});
let mut manager = AudioManager::<DefaultBackend>::new(settings)?;
let listener = manager.add_listener(
mint_pos(DVec3::ZERO),
mint::Quaternion::from([0.0, 0.0, 0.0, 1.0]),
)?;
let mut send_builder = SendTrackBuilder::new().volume(Decibels::SILENCE);
let reverb = send_builder.add_effect(
ReverbBuilder::new()
.feedback(0.6)
.damping(0.4)
.mix(Mix(1.0)),
);
let send = manager.add_send_track(send_builder)?;
let send_id = send.id();
let distances = SpatialTrackDistances {
min_distance: 1.0,
max_distance: 96.0,
};
let mut tracks = Vec::with_capacity(pool.max(1));
for _ in 0..pool.max(1) {
let mut builder = SpatialTrackBuilder::new()
.distances(distances)
.with_send(send_id, Decibels(0.0));
let filter = builder.add_effect(
FilterBuilder::new()
.mode(FilterMode::LowPass)
.cutoff(f64::from(crate::OPEN_CUTOFF_HZ)),
);
let track = manager.add_spatial_sub_track(&listener, mint_pos(DVec3::ZERO), builder)?;
tracks.push(PoolTrack {
track,
filter,
sound: None,
});
}
let pool_len = tracks.len();
Ok(Self {
manager,
send,
listener,
send_id,
reverb,
listener_filter,
listener_cutoff: crate::LISTENER_LOWPASS_OPEN_HZ,
tracks,
pool: SourcePool::new(pool_len),
sounds: Vec::new(),
})
}
fn to_static(sound: &SoundBuffer) -> StaticSoundData {
let frames: Arc<[Frame]> = sound.samples.iter().map(|&s| Frame::new(s, s)).collect();
StaticSoundData {
sample_rate: sound.sample_rate,
frames,
settings: StaticSoundSettings::default(),
slice: None,
}
}
fn start(
&mut self,
sound: SoundKey,
at: DVec3,
looping: bool,
initial: Option<&SourceAcoustics>,
) -> Option<SourceId> {
let data = self.sounds.get(sound.0)?.clone();
let tracks = &self.tracks;
let (idx, id) = self.pool.allocate(looping, |i| {
tracks[i].track.num_sounds() == 0
})?;
let data = if looping { data.loop_region(..) } else { data };
let send_id = self.send_id;
let slot = &mut self.tracks[idx];
if let Some(mut old) = slot.sound.take() {
old.stop(tween(STEAL_TWEEN_MS));
}
slot.track.set_position(mint_pos(at), tween(0));
let clear = SourceAcoustics::clear(&AcousticsConfig::default());
let a = initial.unwrap_or(&clear);
slot.track.set_volume(Decibels(a.gain_db), tween(0));
slot.filter
.set_cutoff(f64::from(a.lowpass_cutoff_hz), tween(0));
let _ = slot
.track
.set_send(send_id, Decibels(a.reverb_send_db), tween(0));
slot.sound = slot.track.play(data).ok();
slot.sound.as_ref()?;
Some(id)
}
}
impl AudioOut for KiraAudio {
fn register(&mut self, sound: &SoundBuffer) -> SoundKey {
self.sounds.push(Self::to_static(sound));
SoundKey(self.sounds.len() - 1)
}
fn set_listener(&mut self, pos: DVec3, orientation: DQuat) {
let q = orientation.as_quat();
self.listener
.set_position(mint_pos(pos), tween(FAST_TWEEN_MS));
self.listener.set_orientation(
mint::Quaternion::from([q.x, q.y, q.z, q.w]),
tween(FAST_TWEEN_MS),
);
}
fn play(
&mut self,
sound: SoundKey,
at: DVec3,
initial: Option<&SourceAcoustics>,
) -> Option<SourceId> {
self.start(sound, at, false, initial)
}
fn play_loop(
&mut self,
sound: SoundKey,
at: DVec3,
initial: Option<&SourceAcoustics>,
) -> Option<SourceId> {
self.start(sound, at, true, initial)
}
fn stop(&mut self, id: SourceId) {
if let Some(idx) = self.pool.release(id) {
if let Some(sound) = self.tracks[idx].sound.as_mut() {
sound.stop(tween(FAST_TWEEN_MS));
}
self.tracks[idx].sound = None;
}
}
fn set_source_position(&mut self, id: SourceId, pos: DVec3) {
if let Some(idx) = self.pool.slot_of(id) {
self.tracks[idx]
.track
.set_position(mint_pos(pos), tween(FAST_TWEEN_MS));
}
}
fn apply_source(&mut self, id: SourceId, acoustics: &SourceAcoustics) {
let Some(idx) = self.pool.slot_of(id) else {
return;
};
let t = tween(FAST_TWEEN_MS);
let slot = &mut self.tracks[idx];
slot.track.set_volume(Decibels(acoustics.gain_db), t);
slot.filter
.set_cutoff(f64::from(acoustics.lowpass_cutoff_hz), t);
let _ = slot
.track
.set_send(self.send_id, Decibels(acoustics.reverb_send_db), t);
}
fn set_source_pitch(&mut self, id: SourceId, factor: f32) {
let Some(idx) = self.pool.slot_of(id) else {
return;
};
if let Some(sound) = self.tracks[idx].sound.as_mut() {
sound.set_playback_rate(f64::from(factor), tween(FAST_TWEEN_MS));
}
}
fn set_listener_lowpass(&mut self, cutoff_hz: f32) {
if !cutoff_hz.is_finite() {
return;
}
let Some(filter) = self.listener_filter.as_mut() else {
return; };
let cutoff = cutoff_hz.clamp(LISTENER_LOWPASS_FLOOR_HZ, crate::LISTENER_LOWPASS_OPEN_HZ);
if cutoff == self.listener_cutoff {
return;
}
self.listener_cutoff = cutoff;
filter.set_cutoff(f64::from(cutoff), tween(FAST_TWEEN_MS));
}
fn apply_listener(&mut self, acoustics: &ListenerAcoustics) {
let t = tween(ENV_TWEEN_MS);
self.reverb
.set_feedback(f64::from(acoustics.reverb_feedback), t);
self.reverb
.set_damping(f64::from(acoustics.reverb_damping), t);
self.send.set_volume(mix_to_db(acoustics.reverb_mix), t);
}
}