//! Embedded GUI cues. Device work and decoding never run on the Slint thread.
use crate::{ModsWindow, UiCue, UiSounds};
use rodio::{Source, buffer::SamplesBuffer};
use slint::ComponentHandle;
use std::{
io::Cursor,
sync::{
Arc,
atomic::{AtomicBool, AtomicU64, Ordering},
mpsc::{self, SyncSender},
},
time::{Duration, Instant},
};
const CUES: [UiCue; 10] = [
UiCue::Click,
UiCue::Confirm,
UiCue::Red,
UiCue::Tool,
UiCue::Tab,
UiCue::Checkbox,
UiCue::Selection,
UiCue::Dropdown,
UiCue::Slider,
UiCue::Cannot,
];
const FILES: [&str; 10] = [
"gui-click",
"gui-green-confirm",
"gui-red-button",
"gui-tool-button",
"gui-tab",
"gui-checkbox-click",
"list-box-click",
"gui-dropdown-open",
"gui-slider",
"cannot-build",
];
macro_rules! clip {
($name:literal) => {
include_bytes!(concat!("../../../assets/game/sounds/", $name, ".ogg")).as_slice()
};
}
const EMBEDDED: [&[u8]; 10] = [
clip!("gui-click"),
clip!("gui-green-confirm"),
clip!("gui-red-button"),
clip!("gui-tool-button"),
clip!("gui-tab"),
clip!("gui-checkbox-click"),
clip!("list-box-click"),
clip!("gui-dropdown-open"),
clip!("gui-slider"),
clip!("cannot-build"),
];
fn mapping(cue: UiCue) -> Option<(usize, f32)> {
CUES.iter()
.position(|c| *c == cue)
.map(|i| (i, if cue == UiCue::Red { 0.5 } else { 1.0 }))
}
fn decode(bytes: &[u8]) -> Option<SamplesBuffer> {
let source = rodio::Decoder::new_vorbis(Cursor::new(bytes.to_vec())).ok()?;
let (channels, rate) = (source.channels(), source.sample_rate());
let samples: Vec<_> = source.collect();
if samples.is_empty() || samples.iter().any(|v| !v.is_finite()) {
return None;
}
Some(SamplesBuffer::new(channels, rate, samples))
}
fn preload(payloads: &[&[u8]]) -> Vec<Option<SamplesBuffer>> {
payloads
.iter()
.enumerate()
.map(|(i, bytes)| {
let clip = decode(bytes);
if clip.is_none() {
eprintln!("UI audio: {} unavailable; cue disabled", FILES[i]);
}
clip
})
.collect()
}
trait Voice {
fn done(&self) -> bool;
fn stop(&self);
fn volume(&self, gain: f32);
}
impl Voice for rodio::Player {
fn done(&self) -> bool {
self.empty()
}
fn stop(&self) {
self.stop();
}
fn volume(&self, gain: f32) {
self.set_volume(gain);
}
}
trait Output {
fn available(&self) -> bool {
true
}
fn prepare(&self, clip: SamplesBuffer) -> SamplesBuffer {
clip
}
fn play(&self, clip: SamplesBuffer, gain: f32) -> Box<dyn Voice>;
}
struct DefaultOutput {
stream: rodio::MixerDeviceSink,
mixer: rodio::mixer::Mixer,
failed: Arc<AtomicBool>,
}
// Bound the final mix, not individual voices: rapid clicks keep their intended gain.
struct Clamped<S>(S);
impl<S: Source> Iterator for Clamped<S> {
type Item = f32;
fn next(&mut self) -> Option<f32> {
self.0.next().map(|v| v.clamp(-1.0, 1.0))
}
}
impl<S: Source> Source for Clamped<S> {
fn current_span_len(&self) -> Option<usize> {
self.0.current_span_len()
}
fn channels(&self) -> rodio::ChannelCount {
self.0.channels()
}
fn sample_rate(&self) -> rodio::SampleRate {
self.0.sample_rate()
}
fn total_duration(&self) -> Option<Duration> {
self.0.total_duration()
}
}
fn clamped_mixer(
channels: rodio::ChannelCount,
rate: rodio::SampleRate,
) -> (rodio::mixer::Mixer, Clamped<rodio::mixer::MixerSource>) {
let (mixer, source) = rodio::mixer::mixer(channels, rate);
// Rodio removes an empty nested mixer from its parent when it returns None.
// Keep it attached both before the first cue and during idle gaps.
mixer.add(rodio::source::Zero::new(channels, rate));
(mixer, Clamped(source))
}
impl DefaultOutput {
fn open(diagnostic: Arc<AtomicBool>) -> Result<Box<dyn Output>, String> {
let failed = Arc::new(AtomicBool::new(false));
let open = |small_buffer| {
let fail = failed.clone();
let diagnostic = diagnostic.clone();
let builder = rodio::DeviceSinkBuilder::from_default_device()
.map_err(|e| e.to_string())?
.with_error_callback(move |_e| {
fail.store(true, Ordering::Relaxed);
device_diagnostic(&diagnostic);
});
// Do not use open_default_sink(): its fallback enumerates other devices.
if small_buffer {
builder
.with_buffer_size(rodio::cpal::BufferSize::Fixed(512))
.open_stream()
} else {
builder.open_stream()
}
.map_err(|e| e.to_string())
};
let mut stream = open(true).or_else(|_| open(false))?;
failed.store(false, Ordering::Relaxed);
stream.log_on_drop(false);
let (mixer, source) = clamped_mixer(
stream.config().channel_count(),
stream.config().sample_rate(),
);
stream.mixer().add(source);
eprintln!("UI audio: default output initialized");
Ok(Box::new(Self {
stream,
mixer,
failed,
}))
}
}
impl Output for DefaultOutput {
fn available(&self) -> bool {
!self.failed.load(Ordering::Relaxed)
}
fn prepare(&self, clip: SamplesBuffer) -> SamplesBuffer {
let channels = self.stream.config().channel_count();
let rate = self.stream.config().sample_rate();
let samples: Vec<_> =
rodio::source::UniformSourceIterator::new(clip, channels, rate).collect();
SamplesBuffer::new(channels, rate, samples)
}
fn play(&self, clip: SamplesBuffer, gain: f32) -> Box<dyn Voice> {
let player = rodio::Player::connect_new(&self.mixer);
player.set_volume(gain);
player.append(clip);
Box::new(player)
}
}
fn device_diagnostic(logged: &AtomicBool) {
if !logged.swap(true, Ordering::Relaxed) {
eprintln!("UI audio: default output unavailable; staying silent");
}
}
struct Shared {
// Low byte = percent, bit 8 = enabled; higher bits invalidate queued events.
preferences: AtomicU64,
ready: AtomicBool,
retry: AtomicBool,
}
#[derive(Clone)]
pub struct UiAudio {
tx: SyncSender<Command>,
shared: Arc<Shared>,
}
struct Command {
cue: UiCue,
when: Instant,
preferences: u64,
}
impl Command {
fn current(&self, preferences: u64, now: Instant) -> bool {
self.preferences == preferences
&& preference_gain(preferences) > 0.0
&& now.duration_since(self.when) <= Duration::from_millis(100)
}
}
impl UiAudio {
pub fn start(enabled: bool, volume: u8) -> Self {
Self::with_factory(enabled, volume, |diagnostic| {
if cfg!(test) {
Err("test output disabled".into())
} else {
DefaultOutput::open(diagnostic)
}
})
}
fn with_factory(
enabled: bool,
volume: u8,
factory: impl Fn(Arc<AtomicBool>) -> Result<Box<dyn Output>, String> + Send + 'static,
) -> Self {
let (tx, rx) = mpsc::sync_channel::<Command>(32);
let shared = Arc::new(Shared {
preferences: AtomicU64::new(u64::from(volume.min(100)) | (u64::from(enabled) << 8)),
ready: AtomicBool::new(false),
retry: AtomicBool::new(false),
});
let state = shared.clone();
// No join on shutdown: a stalled device factory must never hold the UI open.
let _ = std::thread::Builder::new()
.name("ui-audio".into())
.spawn(move || {
let clips = preload(&EMBEDDED);
let diagnostic = Arc::new(AtomicBool::new(false));
let mut output: Option<Box<dyn Output>> = None;
let mut prepared = clips.clone();
let mut attempts = 0;
let mut voices = Voices::default();
let mut last_preferences = state.preferences.load(Ordering::Relaxed);
loop {
let preferences = state.preferences.load(Ordering::Relaxed);
let gain = preference_gain(preferences);
if preferences != last_preferences {
if gain == 0.0 {
voices.stop();
} else {
voices.volume(gain);
}
last_preferences = preferences;
}
if output.as_ref().is_some_and(|o| !o.available()) {
state.ready.store(false, Ordering::Relaxed);
voices.stop();
output = None;
}
let retry = state.retry.swap(false, Ordering::Relaxed);
if output.is_none() && gain > 0.0 && (attempts == 0 || (retry && attempts < 2))
{
attempts += 1;
match factory(diagnostic.clone()) {
Ok(o) => {
prepared = clips
.iter()
.map(|c| c.clone().map(|c| o.prepare(c)))
.collect();
output = Some(o);
state.ready.store(true, Ordering::Relaxed);
}
Err(_) => device_diagnostic(&diagnostic),
}
}
match rx.recv_timeout(Duration::from_millis(8)) {
Ok(command) => {
let current = state.preferences.load(Ordering::Relaxed);
if !command.current(current, Instant::now()) {
continue;
}
if let Some(output) = &output {
voices.play(
command.cue,
Instant::now(),
&prepared,
output.as_ref(),
preference_gain(current),
);
}
}
Err(mpsc::RecvTimeoutError::Timeout) => voices.prune(),
Err(mpsc::RecvTimeoutError::Disconnected) => break,
}
}
voices.stop();
});
Self { tx, shared }
}
pub fn preferences(&self, enabled: bool, volume: u8) {
let previous = self
.shared
.preferences
.try_update(Ordering::Relaxed, Ordering::Relaxed, |old| {
Some(((old >> 16) + 1) << 16 | u64::from(enabled) << 8 | u64::from(volume.min(100)))
})
.unwrap();
if previous & 256 == 0 && enabled {
self.shared.retry.store(true, Ordering::Relaxed);
}
}
pub fn play(&self, cue: UiCue) {
let preferences = self.shared.preferences.load(Ordering::Relaxed);
if preference_gain(preferences) == 0.0 || !self.shared.ready.load(Ordering::Relaxed) {
return;
}
let _ = self.tx.try_send(Command {
cue,
when: Instant::now(),
preferences,
});
}
}
fn preference_gain(value: u64) -> f32 {
if value & 256 == 0 {
0.0
} else {
(value & 255).min(100) as f32 / 100.0
}
}
struct Active {
cue: UiCue,
gain: f32,
voice: Box<dyn Voice>,
}
#[derive(Default)]
struct Voices {
active: Vec<Active>,
last_error: Option<Instant>,
}
impl Voices {
fn prune(&mut self) {
self.active.retain(|v| !v.voice.done());
}
fn stop(&mut self) {
for v in self.active.drain(..) {
v.voice.stop();
}
}
fn volume(&self, volume: f32) {
for v in &self.active {
v.voice.volume((v.gain * volume).clamp(0.0, 1.0));
}
}
fn play(
&mut self,
cue: UiCue,
now: Instant,
clips: &[Option<SamplesBuffer>],
output: &dyn Output,
volume: f32,
) {
let Some((id, gain)) = mapping(cue) else {
return;
};
let Some(clip) = &clips[id] else { return };
if cue == UiCue::Cannot {
if self
.last_error
.is_some_and(|t| now.duration_since(t) < Duration::from_millis(250))
{
return;
}
self.last_error = Some(now);
}
self.prune();
if self.active.iter().filter(|v| v.cue == cue).count() >= 3
&& let Some(i) = self.active.iter().position(|v| v.cue == cue)
{
self.active.remove(i).voice.stop();
}
if self.active.len() >= 8 {
self.active.remove(0).voice.stop();
}
self.active.push(Active {
cue,
gain,
voice: output.play(clip.clone(), (gain * volume).clamp(0.0, 1.0)),
});
}
}
pub fn bind(app: &ModsWindow, enabled: bool, volume: u8) {
let audio = UiAudio::start(enabled, volume);
let playback = audio.clone();
app.global::<UiSounds>()
.on_play(move |cue| playback.play(cue));
app.global::<UiSounds>()
.on_preferences(move |enabled, volume| {
audio.preferences(enabled, volume.clamp(0, 100) as u8)
});
}
/// Synchronous refusals replace a control's normal cue; deferred failures sound once.
pub fn cannot(app: &ModsWindow) {
app.global::<UiSounds>().invoke_cannot();
}
#[cfg(test)]
#[path = "audio_tests.rs"]
mod tests;