app.init_asset_loader::<SfxrLoader>();

        app.init_asset_loader::<SfxrLoader>()
            .init_asset_loader::<DebugSfxrLoader>()
            .init_asset::<Sfxr>();

#[derive(serde::Deserialize)]
struct Sfxr {
    amp: Option<f32>,
    f: f32,

#[derive(serde::Deserialize, serde::Serialize, Asset, TypePath, Debug)]
pub enum Sfxr {
    PinkExp { amp: Option<f32>, f: f32 },

        Machine::new(pink() * sfxr.amp.unwrap_or(1.0) * envelope(move |t| exp(-sfxr.f * t)))

        match sfxr {
            Sfxr::PinkExp { amp, f } => {
                Machine::new(pink() * amp.unwrap_or(1.0) * envelope(move |t| exp(-f * t)))
            }
        }
    }
}
// Also let's us load in the Sfxr itself, for debugging purposes
#[derive(Default)]
struct DebugSfxrLoader;
impl AssetLoader for DebugSfxrLoader {
    type Asset = Sfxr;
    type Settings = ();
    type Error = SfxrLoaderError;
    fn load<'a>(
        &'a self,
        reader: &'a mut Reader,
        _settings: &'a Self::Settings,
        _load_context: &'a mut LoadContext,
    ) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
        Box::pin(async move {
            let mut bytes = Vec::new();
            reader.read_to_end(&mut bytes).await?;
            let sfxr = ron::de::from_bytes::<Sfxr>(&bytes)?;
            Ok(sfxr)
        })

    fn extensions(&self) -> &[&str] {
        &["sfxr.ron"]
    }

use bevy_asset_loader::prelude::*;

        app.add_systems(Update, debug_view_window.run_if(in_state(GameState::InRun)))
            .add_systems(Startup, setup_debug_collection);

        app.add_systems(Update, debug_view_window.run_if(in_state(GameState::InRun)));
    }
    fn finish(&self, app: &mut App) {
        app.configure_loading_state(
            LoadingStateConfig::new(GameState::Booting).load_collection::<DebugAssets>(),
        );

#[derive(Resource)]

#[derive(Resource, AssetCollection)]

    #[asset(path = "debug.sfxr.ron")]

    #[asset(path = "debug.sfxr.ron")]
    noisy_handle_sfxr: Handle<crate::sfxr::Sfxr>,

fn setup_debug_collection(
    // mut machines: ResMut<Assets<fundsp_kira::Machine>>,
    asset_server: Res<AssetServer>,
    mut commands: Commands,
) {
    // use fundsp::hacker32::*;
    // let noisy_handle = machines.add(fundsp_kira::Machine::new(
    //     pink() * envelope(|t| exp(-5.0 * t)),
    //     // pink() * 0.2,
    // ));
    let noisy_handle = asset_server.load("debug.sfxr.ron");
    commands.insert_resource(DebugAssets { noisy_handle })
}

    assets: Option<Res<DebugAssets>>,

    assets: Res<DebugAssets>,
    sfxrs: Res<Assets<crate::sfxr::Sfxr>>,

            if let Some(assets) = assets {
                track.play(assets.noisy_handle.clone());
            } else {
                warn!("Debug asset noisy_handle not loaded...");

            track.play(assets.noisy_handle.clone());
        }
        ui.collapsing("Debug Sfxr", |ui| {
            // Show our homework
            if let Some(sfxr) = sfxrs.get(assets.noisy_handle_sfxr.clone()) {
                ui.label(format!("{sfxr:#?}"));

        }

        });

(

PinkExp(

    f: 1.0,

    f: 20.0,