1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use std::iter::Iterator;
use std::mem::replace;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;

use amethyst_core::cgmath::Transform;
use amethyst_core::transform::Transform as TransformComponent;
use rodio::{Sample, Source, SpatialSink};
use specs::{Entity, Fetch, Join, ReadStorage, System, WriteStorage};

use components::{AudioEmitter, AudioListener};

/// Syncs 3D transform data with the audio engine to provide 3D audio.
#[derive(Default)]
pub struct AudioSystem;

impl AudioSystem {
    /// Produces a new AudioSystem that uses the given listener.
    pub fn new() -> AudioSystem {
        Default::default()
    }
}

/// Add this structure to world as a resource with ID 0 to select an entity whose AudioListener
/// component will be used.
pub struct SelectedListener(pub Entity);

// Wraps a source and signals to another thread when that source has ended.
struct EndSignalSource<I: Source>
where
    <I as Iterator>::Item: Sample,
{
    input: I,
    signal: Arc<AtomicBool>,
}

impl<I: Source> EndSignalSource<I>
where
    <I as Iterator>::Item: Sample,
{
    pub fn new(input: I, signal: Arc<AtomicBool>) -> EndSignalSource<I> {
        EndSignalSource { input, signal }
    }
}

impl<I: Source> Iterator for EndSignalSource<I>
where
    <I as Iterator>::Item: Sample,
{
    type Item = <I as Iterator>::Item;

    fn next(&mut self) -> Option<Self::Item> {
        let next = self.input.next();
        if next.is_none() {
            self.signal.store(true, Ordering::Relaxed);
        }
        next
    }
}

impl<I: Source> Source for EndSignalSource<I>
where
    <I as Iterator>::Item: Sample,
{
    fn current_frame_len(&self) -> Option<usize> {
        self.input.current_frame_len()
    }

    fn channels(&self) -> u16 {
        self.input.channels()
    }

    fn samples_rate(&self) -> u32 {
        self.input.samples_rate()
    }

    fn total_duration(&self) -> Option<Duration> {
        self.input.total_duration()
    }
}

impl<'a> System<'a> for AudioSystem {
    type SystemData = (
        Fetch<'a, SelectedListener>,
        ReadStorage<'a, TransformComponent>,
        ReadStorage<'a, AudioListener>,
        WriteStorage<'a, AudioEmitter>,
    );

    fn run(&mut self, (select_listener, transform, listener, mut audio_emitter): Self::SystemData) {
        #[cfg(feature = "profiler")]
        profile_scope!("audio_system");
        // Process emitters and listener.
        if let Some(listener) = listener.get(select_listener.0) {
            if let Some(listener_transform) = transform.get(select_listener.0) {
                let listener_transform = listener_transform.0;
                let left_ear_position =
                    listener_transform.transform_point(listener.left_ear).into();
                let right_ear_position = listener_transform
                    .transform_point(listener.right_ear)
                    .into();
                for (transform, mut audio_emitter) in (&transform, &mut audio_emitter).join() {
                    let x = transform.0[3][0];
                    let y = transform.0[3][1];
                    let z = transform.0[3][2];
                    let emitter_position = [x, y, z];
                    // Remove all sinks whose sounds have ended.
                    audio_emitter.sinks.retain(|s| !s.1.load(Ordering::Relaxed));
                    for &mut (ref mut sink, _) in &mut audio_emitter.sinks {
                        sink.set_emitter_position(emitter_position);
                        sink.set_left_ear_position(left_ear_position);
                        sink.set_right_ear_position(right_ear_position);
                    }
                    if audio_emitter.sinks.is_empty() {
                        if let Some(mut picker) = replace(&mut audio_emitter.picker, None) {
                            if picker(&mut audio_emitter) {
                                audio_emitter.picker = Some(picker);
                            }
                        }
                    }
                    while let Some(source) = audio_emitter.sound_queue.pop() {
                        let sink = SpatialSink::new(
                            &listener.output.endpoint,
                            emitter_position,
                            left_ear_position,
                            right_ear_position,
                        );
                        let atomic_bool = Arc::new(AtomicBool::new(false));
                        sink.append(EndSignalSource::new(source, atomic_bool.clone()));
                        audio_emitter.sinks.push((sink, atomic_bool));
                    }
                }
            }
        }
    }
}