use std::collections::VecDeque;

    mut track: ResMut<fundsp_kira::MainTrack>,

        fundsp_output.play(&fundsp_kira::Machine::new(
            pink() * 0.2 * envelope(|t| exp(-0.1 * t)),
            // pink() * 0.5 * envelope(|t| exp(-10.0 * t)),
            // pink() * 0.2,
        ));

        fundsp_output.play(
            &fundsp_kira::Machine::new(
                pink() * 0.2 * envelope(|t| exp(-0.1 * t)),
                // pink() * 0.5 * envelope(|t| exp(-10.0 * t)),
                // pink() * 0.2,
            ),
            &mut track,
        );

    mut fundsp_output: NonSendMut<fundsp_kira::FundspAudioOutput>,
    mut track: ResMut<fundsp_kira::MainTrack>,
    mut sample_pairs: Local<VecDeque<(f32, f32)>>,

    /// A fixed number of samples that we should keep in buffer
    const SAMPLES_TO_KEEP: usize = 512;
    // Update main track data
    let samples_stored = sample_pairs.len();
    sample_pairs.drain(0..(samples_stored.saturating_sub(SAMPLES_TO_KEEP)));
    sample_pairs.push_back(track.sample());

        if ui.button("Noisy").clicked() {
            use fundsp::hacker32::*;
            fundsp_output.play(
                &fundsp_kira::Machine::new(
                    pink() * 0.5 * envelope(|t| exp(-10.0 * t)),
                    // pink() * 0.2,
                ),
                &mut track,
            );
        }

        ui.collapsing("Audio Details", |ui| {
            // TODO Abstract this away into an egui widget for an *oscilloscope*
            use egui_plot::{Line, Plot, PlotPoints};
            let left_max = sample_pairs
                .iter()
                .map(|(s, _)| s.abs())
                .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Less))
                .unwrap_or_default();
            let left_wave: PlotPoints = sample_pairs
                .iter()
                .enumerate()
                .map(|(t, (s, _))| [t as f64, *s as f64])
                .chain((samples_stored..SAMPLES_TO_KEEP).map(|i| [i as f64, 0.0]))
                .collect();
            let left_line = Line::new(left_wave).color(egui::Color32::BLUE);
            let right_max = sample_pairs
                .iter()
                .map(|(_, s)| s.abs())
                .max_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Less))
                .unwrap_or_default();
            let right_wave: PlotPoints = sample_pairs
                .iter()
                .enumerate()
                .map(|(t, (_, s))| [t as f64, *s as f64])
                .chain((samples_stored..SAMPLES_TO_KEEP).map(|i| [i as f64, 0.0]))
                .collect();
            let right_line = Line::new(right_wave).color(egui::Color32::RED);
            ui.label("Main Track Oscilloscope");
            Plot::new("waveform")
                .view_aspect(4.0)
                .auto_bounds(egui::Vec2b::new(false, false))
                .show_grid(egui::Vec2b::new(false, true))
                .include_y(-left_max.max(right_max))
                .include_y(left_max.max(right_max))
                .include_x(0.0)
                .include_x(SAMPLES_TO_KEEP as f64)
                .show_axes(false)
                .show(ui, |plot_ui| {
                    plot_ui.line(left_line);
                    plot_ui.line(right_line);
                });
            ui.label(format!("MainTrack RMS: {:?}", track.rms()));
        });

};
use std::{
    convert::Infallible,
    marker::PhantomData,
    sync::{
        atomic::{AtomicBool, AtomicU32, Ordering},
        Arc, OnceLock,
    },

use std::{convert::Infallible, sync::OnceLock};

#[derive(Resource)]
pub struct DefaultTrack;

pub type MainTrack = Track<DefaultTrack>;

        app.init_non_send_resource::<FundspAudioOutput>();

        app.init_non_send_resource::<FundspAudioOutput>()
            .add_track::<DefaultTrack>();

    pub(crate) fn play<T: AudioUnit32 + Clone + 'static>(&mut self, machine: &Machine<T>) {

    pub fn play<N: AudioUnit32 + Clone + 'static, T: Resource>(
        &mut self,
        machine: &Machine<N>,
        track: &mut Track<T>,
    ) {

            // Stop the previous sound
            track.trackable.unload();
            // Recreate the Trackable
            let trackable = Trackable::default();
            track.trackable = trackable.clone();
            // Play the new sound
            // TODO Should this be queued?

                .play(Machined::<T>::new(

                .play(Machined::<N, T>::new(

                    track,

        }
    }
}
pub trait FundspAudioApp {
    fn add_track<T: Resource>(&mut self) -> &mut Self;
}
impl FundspAudioApp for App {
    fn add_track<T: Resource>(&mut self) -> &mut Self {
        self.insert_resource(Track::<T>::default())
    }
}
#[derive(Debug, Clone)]
struct ChannelDetails {
    rms: Arc<AtomicU32>,
    sample: Arc<AtomicU32>,
}
impl ChannelDetails {
    fn store_sample(&self, sample: f32) {
        self.sample.store(sample.to_bits(), Ordering::SeqCst);
    }
    fn store_rms(&self, rms: f32) {
        self.rms.store(rms.to_bits(), Ordering::SeqCst);
    }
    fn sample(&self) -> f32 {
        let sample_bits = self.sample.load(Ordering::SeqCst);
        f32::from_bits(sample_bits)
    }
    fn rms(&self) -> f32 {
        let rms_bits = self.rms.load(Ordering::SeqCst);
        f32::from_bits(rms_bits)
    }
}
impl Default for ChannelDetails {
    fn default() -> Self {
        Self {
            rms: Arc::new(AtomicU32::new(0.0f32.to_bits())),
            sample: Arc::new(AtomicU32::new(0.0f32.to_bits())),
        }
    }
}
#[derive(Debug)]
struct Trackable<T> {
    should_unload: Arc<AtomicBool>,
    left_channel: ChannelDetails,
    right_channel: ChannelDetails,
    _marker: PhantomData<T>,
}
impl<T> Clone for Trackable<T>
where
    T: Resource,
{
    fn clone(&self) -> Self {
        Self {
            should_unload: self.should_unload.clone(),
            left_channel: self.left_channel.clone(),
            right_channel: self.right_channel.clone(),
            _marker: PhantomData,
        }
    }
}
impl<T> Default for Trackable<T> {
    fn default() -> Self {
        Self {
            _marker: PhantomData,
            should_unload: Arc::new(AtomicBool::new(false)),
            left_channel: default(),
            right_channel: default(),
        }
    }
}
impl<T> Trackable<T> {
    /// Stops any sounds associated with this [`Trackable`]
    fn unload(&self) {
        self.should_unload.store(true, Ordering::SeqCst)
    }
}
#[derive(Resource)]
pub struct Track<T> {
    trackable: Trackable<T>,
    sample_rate: f64,
}
impl<T> Default for Track<T> {
    fn default() -> Self {
        Self {
            trackable: Trackable::default(),
            sample_rate: DEFAULT_SR,

impl<T> Track<T> {
    #[allow(dead_code)]
    /// Get this track's sample rate
    pub fn sample_rate(&self) -> f64 {
        self.sample_rate
    }

    #[allow(dead_code)]
    /// Get this track's sample mutably
    pub fn sample_rate_mut(&mut self) -> &mut f64 {
        &mut self.sample_rate
    }
    #[allow(dead_code)]
    /// Get the most recent sample values
    pub fn sample(&self) -> (f32, f32) {
        (
            self.trackable.left_channel.sample(),
            self.trackable.right_channel.sample(),
        )
    }
    #[allow(dead_code)]
    /// Get the most recent RMS values
    pub fn rms(&self) -> (f32, f32) {
        (
            self.trackable.left_channel.rms(),
            self.trackable.right_channel.rms(),
        )
    }
}

pub struct Machined<T> {
    node: T,

pub struct Machined<N, T> {
    node: N,

    trackable: Trackable<T>,

impl<T> Machined<T>

impl<N, T> Machined<N, T>

    T: AudioUnit32,

    N: AudioUnit32,
    T: Resource,

    fn new(node: T, settings: MachinedSettings) -> Self {
        Self { node, settings }

    fn new(mut node: N, settings: MachinedSettings, track: &Track<T>) -> Self {
        // Set the node sample rate from the track
        node.set_sample_rate(track.sample_rate);
        Self {
            node,
            settings,
            trackable: track.trackable.clone(),
        }

impl<T> SoundData for Machined<T>

impl<T, Track> SoundData for Machined<T, Track>

    Track: Resource,

        Ok((Box::new(FundspSound::new(self.node, self.settings)), ()))

        Ok((
            Box::new(FundspSound::new(
                self.node,
                self.settings,
                self.trackable.clone(),
            )),
            (),
        ))

pub struct FundspSound<T> {

pub struct FundspSound<T, Track> {

    trackable: Trackable<Track>,

impl<T> FundspSound<T>

impl<T, Track> FundspSound<T, Track>

    fn new(node: T, settings: MachinedSettings) -> Self {

    fn new(node: T, settings: MachinedSettings, trackable: Trackable<Track>) -> Self {

            trackable,

impl<T> Sound for FundspSound<T>

impl<T, Track> Sound for FundspSound<T, Track>

    Track: Send,

        // Report sample
        self.trackable.left_channel.store_sample(left);
        self.trackable.right_channel.store_sample(right);

        // Report RMS
        self.trackable.left_channel.store_rms(left_rms);
        self.trackable.right_channel.store_rms(right_rms);

        below_noise_floor

        let should_unload = self.trackable.should_unload.load(Ordering::Acquire);
        if should_unload {
            debug!("Stopping {self:p} due to unload!")
        }
        below_noise_floor || should_unload

egui_plot = "0.26"

 "egui_plot",

]
[[package]]
name = "egui_plot"
version = "0.26.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "803bfcb1ad294dd7f106e26ac9199730d16051496ddb66b10fdb6529eb43df58"
dependencies = [
 "egui",