From 2acc6b0e22898c7cb1ac77fbec4f1282a6e34306 Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Sat, 4 Nov 2023 20:41:05 +0100
Subject: [PATCH 1/2] Update to bevy main

---
 CHANGELOG.md                  |  2 ++
 Cargo.toml                    | 11 ++++++--
 README.md                     |  5 ++--
 examples/spacial.rs           |  2 +-
 examples/stress_test.rs       |  7 +++--
 src/audio.rs                  |  9 ++++--
 src/audio_output.rs           | 39 ++++++++++++++------------
 src/channel/dynamic.rs        | 52 +++++++++++++++++++++--------------
 src/channel/typed.rs          | 39 ++++++++++++++++----------
 src/instance.rs               |  5 ++--
 src/lib.rs                    |  9 +++---
 src/source/flac_loader.rs     | 35 +++++++++++++++++------
 src/source/mod.rs             |  6 ++--
 src/source/mp3_loader.rs      | 35 +++++++++++++++++------
 src/source/ogg_loader.rs      | 35 +++++++++++++++++------
 src/source/settings_loader.rs | 45 ++++++++++++++++++++++++------
 src/source/wav_loader.rs      | 36 +++++++++++++++++-------
 17 files changed, 251 insertions(+), 121 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d3d4bef..fe3c25e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,7 @@
 # Changelog
 
+- Update to Bevy `0.12`
+
 ## v0.17.0
 - Multiply instance volume with channel volume ([#103](https://github.com/NiklasEi/bevy_kira_audio/issues/103))
 - Allow playing a paused sound using `.play(...).paused()` ([#105](https://github.com/NiklasEi/bevy_kira_audio/issues/105))
diff --git a/Cargo.toml b/Cargo.toml
index 08f6f4e..49f7abc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,8 +22,9 @@ wav = ["kira/wav"]
 settings_loader = ["dep:ron", "dep:serde", "kira/serde"]
 
 [dependencies]
-bevy = { version = "0.11", default-features = false, features = ["bevy_asset"] }
+bevy = { git = "https://github.com/bevyengine/bevy", default-features = false, features = ["bevy_asset"] }
 anyhow = "1.0"
+uuid = { version = "1", features = ["fast-rng"] }
 kira = { version = "0.8", default-features = false, features = ["cpal"] }
 ron = { version = "0.8", optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true }
@@ -31,7 +32,7 @@ parking_lot = "0.12"
 thiserror = "1.0"
 
 [dev-dependencies.bevy]
-version = "0.11"
+git = "https://github.com/bevyengine/bevy"
 default-features = false
 features = [
     "bevy_asset",
@@ -44,7 +45,11 @@ features = [
     "bevy_sprite",
     "bevy_gltf",
     "bevy_scene",
-    "bevy_pbr","tonemapping_luts", "ktx2" , "zstd"
+    "bevy_pbr",
+    "tonemapping_luts",
+    "ktx2",
+    "zstd",
+    "multi-threaded"
 ]
 
 [[example]]
diff --git a/README.md b/README.md
index 8cf5e2f..af6a8c5 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ Sound can be played in channels. Each channel has controls to pause or stop play
 
 ## Usage
 
-*Note: the Bevy feature `bevy_audio` is enabled by default and not compatible with this plugin. Make sure to not have the `bevy_audio` feature enabled if you want to use `bevy_kira_audio`. The same goes for Bevy's `vorbis` feature. See [Bevys' Cargo file](https://github.com/bevyengine/bevy/blob/v0.9.0/Cargo.toml#L27-L40) for a list of all default features of version `0.9` and list them manually in your Cargo file excluding the ones you do not want. Make sure to set `default-features` to `false` for the Bevy dependency. You can take a look at [bevy_game_template's cargo file as an example](https://github.com/NiklasEi/bevy_game_template/blob/main/Cargo.toml).*
+*Note: the Bevy feature `bevy_audio` is enabled by default and not compatible with this plugin. Make sure to not have the `bevy_audio` feature enabled if you want to use `bevy_kira_audio`. The same goes for Bevy's `vorbis` feature. See [Bevys' Cargo file](https://github.com/bevyengine/bevy/blob/v0.12.0/Cargo.toml#L33-L57) for a list of all default features of version `0.12` and list them manually in your Cargo file excluding the ones you do not want. Make sure to set `default-features` to `false` for the Bevy dependency. You can take a look at [bevy_game_template's cargo file as an example](https://github.com/NiklasEi/bevy_game_template/blob/main/Cargo.toml).*
 
 
 To play audio, you usually want to load audio files as assets. This requires `AssetLoaders`. `bevy_kira_audio` comes with loaders for most common audio formats. You can enable them with the features `ogg` (enabled by default), `mp3`, `wav`, or `flac`. The following example assumes that the feature `ogg` is enabled.
@@ -90,6 +90,7 @@ The main branch is compatible with the latest Bevy release.
 Compatibility of `bevy_kira_audio` versions:
 | `bevy_kira_audio` | `bevy`  |
 |  :--              |  :--    |
+| `0.18`            | `0.12`  |
 | `0.16` - `0.17`   | `0.11`  |
 | `0.15`            | `0.10`  |
 | `0.13` - `0.14`   | `0.9`   |
@@ -98,7 +99,7 @@ Compatibility of `bevy_kira_audio` versions:
 | `0.8`             | `0.6`   |
 | `0.4` - `0.7`     | `0.5`   |
 | `0.3`             | `0.4`   |
-| `main`            | `0.10`  |
+| `main`            | `0.12`  |
 | `bevy_main`       | `main`  |
 
 ## License
diff --git a/examples/spacial.rs b/examples/spacial.rs
index 4533985..dccc986 100644
--- a/examples/spacial.rs
+++ b/examples/spacial.rs
@@ -212,7 +212,7 @@ fn player_look(
     if let Ok(window) = primary_window.get_single() {
         let delta_state = state.as_mut();
         for mut transform in query.iter_mut() {
-            for ev in delta_state.reader_motion.iter(&motion) {
+            for ev in delta_state.reader_motion.read(&motion) {
                 match window.cursor.grab_mode {
                     CursorGrabMode::None => (),
                     _ => {
diff --git a/examples/stress_test.rs b/examples/stress_test.rs
index 8451130..7be1848 100644
--- a/examples/stress_test.rs
+++ b/examples/stress_test.rs
@@ -43,7 +43,7 @@ fn check(
     mut commands: Commands,
 ) {
     if let Some(handle) = handle {
-        if asset_server.get_load_state(handle.0.id()) == LoadState::Loaded {
+        if asset_server.get_load_state(handle.0.id()) == Some(LoadState::Loaded) {
             commands.insert_resource(AudioHandle(handle.0.clone()));
             commands.remove_resource::<LoadingAudioHandle>();
         }
@@ -52,8 +52,9 @@ fn check(
 
 fn play(handle: Option<Res<AudioHandle>>, audio: Res<Audio>) {
     if let Some(handle) = handle {
-        // the max number here depends on your hardware.
-        // If you get warnings and/or stuttered sounds try reducing the amount.
+        // The max number here depends on your hardware.
+        // If you get warnings and/or stuttered sounds try reducing the amount and/or changing the
+        // capacities of the `AudioSettings` in the `main` method.
         for _ in 0..75 {
             audio.play(handle.0.clone());
         }
diff --git a/src/audio.rs b/src/audio.rs
index d2e48cc..e028e13 100644
--- a/src/audio.rs
+++ b/src/audio.rs
@@ -7,9 +7,10 @@ use crate::instance::AudioInstance;
 use crate::source::AudioSource;
 use crate::AudioSystemSet;
 use bevy::app::{App, PreUpdate};
-use bevy::asset::{Handle, HandleId};
+use bevy::asset::{AssetId, Handle};
 use bevy::ecs::system::Resource;
 use bevy::prelude::{default, IntoSystemConfigs, PostUpdate};
+use bevy::utils::Uuid;
 use kira::sound::static_sound::{StaticSoundData, StaticSoundHandle};
 use kira::sound::EndPosition;
 use kira::tween::Value;
@@ -185,9 +186,11 @@ impl<'a> Drop for PlayAudioCommand<'a> {
 
 impl<'a> PlayAudioCommand<'a> {
     pub(crate) fn new(source: Handle<AudioSource>, que: &'a dyn AudioCommandQue) -> Self {
-        let handle_id = HandleId::random::<AudioInstance>();
+        let asset_id = AssetId::Uuid {
+            uuid: Uuid::new_v4(),
+        };
         Self {
-            instance_handle: Handle::<AudioInstance>::weak(handle_id),
+            instance_handle: Handle::<AudioInstance>::Weak(asset_id),
             source,
             settings: PartialSoundSettings::default(),
             que,
diff --git a/src/audio_output.rs b/src/audio_output.rs
index 51b1d55..dcf8030 100644
--- a/src/audio_output.rs
+++ b/src/audio_output.rs
@@ -56,7 +56,7 @@ impl<B: Backend> AudioOutput<B> {
         if let Some(instances) = self.instances.get_mut(channel) {
             let tween = map_tween(tween);
             for instance in instances {
-                if let Some(instance) = audio_instances.get_mut(instance) {
+                if let Some(instance) = audio_instances.get_mut(instance.id()) {
                     match instance.handle.stop(tween) {
                         Err(CommandError::CommandQueueFull) => {
                             return AudioCommandResult::Retry;
@@ -82,7 +82,7 @@ impl<B: Backend> AudioOutput<B> {
         if let Some(instance_handles) = self.instances.get_mut(channel) {
             let tween = map_tween(tween);
             for instance in instance_handles.iter_mut() {
-                if let Some(instance) = audio_instances.get_mut(instance) {
+                if let Some(instance) = audio_instances.get_mut(instance.id()) {
                     if kira::sound::PlaybackState::Playing == instance.handle.state() {
                         if let Err(error) = instance.handle.pause(tween) {
                             error!("Failed to pause instance: {:?}", error);
@@ -111,7 +111,7 @@ impl<B: Backend> AudioOutput<B> {
         if let Some(instances) = self.instances.get_mut(channel) {
             let tween = map_tween(tween);
             for instance in instances.iter_mut() {
-                if let Some(instance) = audio_instances.get_mut(instance) {
+                if let Some(instance) = audio_instances.get_mut(instance.id()) {
                     if instance.handle.state() == kira::sound::PlaybackState::Paused
                         || instance.handle.state() == kira::sound::PlaybackState::Pausing
                         || instance.handle.state() == kira::sound::PlaybackState::Stopping
@@ -141,7 +141,7 @@ impl<B: Backend> AudioOutput<B> {
         if let Some(instances) = self.instances.get_mut(channel) {
             let tween = map_tween(tween);
             for instance in instances.iter_mut() {
-                if let Some(instance) = audio_instances.get_mut(instance) {
+                if let Some(instance) = audio_instances.get_mut(instance.id()) {
                     if let Err(error) = instance.handle.set_volume(volume, tween) {
                         error!("Failed to set volume for instance: {:?}", error);
                     }
@@ -169,7 +169,7 @@ impl<B: Backend> AudioOutput<B> {
         if let Some(instances) = self.instances.get_mut(channel) {
             let tween = map_tween(tween);
             for instance in instances.iter_mut() {
-                if let Some(instance) = audio_instances.get_mut(instance) {
+                if let Some(instance) = audio_instances.get_mut(instance.id()) {
                     if let Err(error) = instance.handle.set_panning(panning, tween) {
                         error!("Failed to set panning for instance: {:?}", error);
                     }
@@ -197,7 +197,7 @@ impl<B: Backend> AudioOutput<B> {
         if let Some(instances) = self.instances.get_mut(channel) {
             let tween = map_tween(tween);
             for instance in instances.iter_mut() {
-                if let Some(instance) = audio_instances.get_mut(instance) {
+                if let Some(instance) = audio_instances.get_mut(instance.id()) {
                     if let Err(error) = instance.handle.set_playback_rate(playback_rate, tween) {
                         error!("Failed to set playback rate for instance: {:?}", error);
                     }
@@ -271,8 +271,8 @@ impl<B: Backend> AudioOutput<B> {
                 error!("Failed to set playback rate for instance: {:?}", error);
             }
         }
-        let instance_handle = audio_instances.set(
-            instance_handle,
+        audio_instances.insert(
+            &instance_handle,
             AudioInstance {
                 handle: sound_handle,
             },
@@ -462,8 +462,9 @@ mod test {
     use super::*;
     use crate::channel::AudioControl;
     use crate::{Audio, AudioPlugin};
-    use bevy::asset::{AssetPlugin, HandleId};
+    use bevy::asset::{AssetId, AssetPlugin};
     use bevy::prelude::*;
+    use bevy::utils::Uuid;
     use kira::manager::backend::mock::MockBackend;
     use kira::manager::AudioManagerSettings;
 
@@ -483,10 +484,12 @@ mod test {
             instances: HashMap::default(),
             channels: HashMap::default(),
         };
-        let audio_handle_one: Handle<AudioSource> =
-            Handle::<AudioSource>::weak(HandleId::random::<AudioSource>());
-        let audio_handle_two: Handle<AudioSource> =
-            Handle::<AudioSource>::weak(HandleId::random::<AudioSource>());
+        let audio_handle_one: Handle<AudioSource> = Handle::<AudioSource>::Weak(AssetId::Uuid {
+            uuid: Uuid::from_u128(1758302748397294),
+        });
+        let audio_handle_two: Handle<AudioSource> = Handle::<AudioSource>::Weak(AssetId::Uuid {
+            uuid: Uuid::from_u128(2537024739048739),
+        });
 
         let channel = AudioChannel::<Audio>::default();
         channel.play(audio_handle_one.clone());
@@ -526,10 +529,12 @@ mod test {
             instances: HashMap::default(),
             channels: HashMap::default(),
         };
-        let audio_handle_one: Handle<AudioSource> =
-            Handle::<AudioSource>::weak(HandleId::random::<AudioSource>());
-        let audio_handle_two: Handle<AudioSource> =
-            Handle::<AudioSource>::weak(HandleId::random::<AudioSource>());
+        let audio_handle_one: Handle<AudioSource> = Handle::<AudioSource>::Weak(AssetId::Uuid {
+            uuid: Uuid::from_u128(13290473942075938),
+        });
+        let audio_handle_two: Handle<AudioSource> = Handle::<AudioSource>::Weak(AssetId::Uuid {
+            uuid: Uuid::from_u128(243290473942075938),
+        });
 
         let channel = AudioChannel::<Audio>::default();
         channel.play(audio_handle_one);
diff --git a/src/channel/dynamic.rs b/src/channel/dynamic.rs
index a9c9175..327a291 100644
--- a/src/channel/dynamic.rs
+++ b/src/channel/dynamic.rs
@@ -5,7 +5,7 @@ use crate::audio::{
 use crate::channel::AudioCommandQue;
 use crate::instance::AudioInstance;
 use crate::{AudioControl, AudioSource, PlaybackState};
-use bevy::asset::{Handle, HandleId};
+use bevy::asset::{AssetId, Handle};
 use bevy::ecs::system::Resource;
 use bevy::utils::hashbrown::hash_map::Iter;
 use bevy::utils::HashMap;
@@ -17,7 +17,7 @@ use std::collections::VecDeque;
 #[derive(Default)]
 pub struct DynamicAudioChannel {
     pub(crate) commands: RwLock<VecDeque<AudioCommand>>,
-    pub(crate) states: HashMap<HandleId, PlaybackState>,
+    pub(crate) states: HashMap<AssetId<AudioInstance>, PlaybackState>,
 }
 
 impl AudioCommandQue for DynamicAudioChannel {
@@ -235,13 +235,15 @@ impl DynamicAudioChannels {
 mod tests {
     use crate::channel::dynamic::DynamicAudioChannels;
     use crate::channel::*;
-    use bevy::asset::HandleId;
+    use bevy::asset::AssetId;
+    use bevy::utils::Uuid;
 
     #[test]
     fn state_is_queued_if_command_is_queued() {
         let mut audio = DynamicAudioChannels::default();
-        let audio_handle: Handle<AudioSource> =
-            Handle::<AudioSource>::weak(HandleId::default::<AudioSource>());
+        let audio_handle: Handle<AudioSource> = Handle::<AudioSource>::Weak(AssetId::Uuid {
+            uuid: Uuid::from_u128(43290473942075938),
+        });
         let instance_handle = audio.create_channel("test").play(audio_handle).handle();
 
         assert_eq!(
@@ -253,7 +255,9 @@ mod tests {
     #[test]
     fn state_is_stopped_if_command_is_not_queued_and_id_not_in_state_map() {
         let mut audio = DynamicAudioChannels::default();
-        let instance_handle = Handle::<AudioInstance>::weak(HandleId::default::<AudioInstance>());
+        let instance_handle = Handle::<AudioInstance>::Weak(AssetId::Uuid {
+            uuid: Uuid::from_u128(43290473942075938),
+        });
 
         assert_eq!(
             audio.create_channel("test").state(&instance_handle),
@@ -264,7 +268,9 @@ mod tests {
     #[test]
     fn state_is_fetched_from_state_map() {
         let mut audio = DynamicAudioChannels::default();
-        let instance_handle = Handle::<AudioInstance>::weak(HandleId::default::<AudioInstance>());
+        let instance_handle = Handle::<AudioInstance>::Weak(AssetId::Uuid {
+            uuid: Uuid::from_u128(43290473942075938),
+        });
         audio.create_channel("test");
         audio.channels.get_mut("test").unwrap().states.insert(
             instance_handle.id(),
@@ -281,26 +287,30 @@ mod tests {
     fn finds_playing_sound() {
         let mut audio = DynamicAudioChannels::default();
         audio.create_channel("test");
-        audio
-            .channels
-            .get_mut("test")
-            .unwrap()
-            .states
-            .insert(HandleId::default::<AudioInstance>(), PlaybackState::Queued);
         audio.channels.get_mut("test").unwrap().states.insert(
-            HandleId::default::<AudioInstance>(),
+            AssetId::Uuid {
+                uuid: Uuid::from_u128(143290473942075938),
+            },
+            PlaybackState::Queued,
+        );
+        audio.channels.get_mut("test").unwrap().states.insert(
+            AssetId::Uuid {
+                uuid: Uuid::from_u128(243290473942075938),
+            },
             PlaybackState::Paused { position: 42. },
         );
-        audio
-            .channels
-            .get_mut("test")
-            .unwrap()
-            .states
-            .insert(HandleId::default::<AudioInstance>(), PlaybackState::Stopped);
+        audio.channels.get_mut("test").unwrap().states.insert(
+            AssetId::Uuid {
+                uuid: Uuid::from_u128(343290473942075938),
+            },
+            PlaybackState::Stopped,
+        );
         assert!(!audio.channel("test").is_playing_sound());
 
         audio.channels.get_mut("test").unwrap().states.insert(
-            HandleId::default::<AudioInstance>(),
+            AssetId::Uuid {
+                uuid: Uuid::from_u128(43290473942075938),
+            },
             PlaybackState::Playing { position: 42. },
         );
         assert!(audio.channel("test").is_playing_sound());
diff --git a/src/channel/typed.rs b/src/channel/typed.rs
index be965e5..9df56a7 100644
--- a/src/channel/typed.rs
+++ b/src/channel/typed.rs
@@ -5,7 +5,7 @@ use crate::audio::{
 use crate::channel::AudioCommandQue;
 use crate::instance::AudioInstance;
 use crate::{AudioControl, AudioSource, PlaybackState};
-use bevy::asset::{Handle, HandleId};
+use bevy::asset::{AssetId, Handle};
 use bevy::ecs::system::Resource;
 use bevy::utils::HashMap;
 use kira::Volume;
@@ -20,7 +20,7 @@ use std::marker::PhantomData;
 #[derive(Resource)]
 pub struct AudioChannel<T> {
     pub(crate) commands: RwLock<VecDeque<AudioCommand>>,
-    pub(crate) states: HashMap<HandleId, PlaybackState>,
+    pub(crate) states: HashMap<AssetId<AudioInstance>, PlaybackState>,
     _marker: PhantomData<T>,
 }
 
@@ -190,13 +190,14 @@ mod test {
     use crate::channel::typed::AudioChannel;
     use crate::channel::*;
     use crate::Audio;
-    use bevy::asset::{Handle, HandleId};
+    use bevy::asset::{AssetId, Handle};
+    use bevy::utils::Uuid;
 
     #[test]
     fn state_is_queued_if_command_is_queued() {
         let audio = AudioChannel::<Audio>::default();
         let audio_handle: Handle<AudioSource> =
-            Handle::<AudioSource>::weak(HandleId::default::<AudioSource>());
+            Handle::<AudioSource>::Weak(AssetId::<AudioSource>::default());
         let instance_handle = audio.play(audio_handle).handle();
 
         assert_eq!(audio.state(&instance_handle), PlaybackState::Queued);
@@ -205,7 +206,7 @@ mod test {
     #[test]
     fn state_is_stopped_if_command_is_not_queued_and_id_not_in_state_map() {
         let audio = AudioChannel::<Audio>::default();
-        let instance_handle = Handle::weak(HandleId::random::<AudioInstance>());
+        let instance_handle = Handle::<AudioInstance>::Weak(AssetId::<AudioInstance>::default());
 
         assert_eq!(audio.state(&instance_handle), PlaybackState::Stopped);
     }
@@ -213,7 +214,7 @@ mod test {
     #[test]
     fn state_is_fetched_from_state_map() {
         let mut audio = AudioChannel::<Audio>::default();
-        let instance_handle = Handle::weak(HandleId::random::<AudioInstance>());
+        let instance_handle = Handle::<AudioInstance>::Weak(AssetId::<AudioInstance>::default());
         audio.states.insert(
             instance_handle.id(),
             PlaybackState::Pausing { position: 42. },
@@ -228,20 +229,30 @@ mod test {
     #[test]
     fn finds_playing_sound() {
         let mut audio = AudioChannel::<Audio>::default();
-        audio
-            .states
-            .insert(HandleId::random::<AudioInstance>(), PlaybackState::Queued);
         audio.states.insert(
-            HandleId::random::<AudioInstance>(),
+            AssetId::Uuid {
+                uuid: Uuid::from_u128(43290473942075938),
+            },
+            PlaybackState::Queued,
+        );
+        audio.states.insert(
+            AssetId::Uuid {
+                uuid: Uuid::from_u128(432952340473942075938),
+            },
             PlaybackState::Paused { position: 42. },
         );
-        audio
-            .states
-            .insert(HandleId::random::<AudioInstance>(), PlaybackState::Stopped);
+        audio.states.insert(
+            AssetId::Uuid {
+                uuid: Uuid::from_u128(46254624324354345324),
+            },
+            PlaybackState::Stopped,
+        );
         assert!(!audio.is_playing_sound());
 
         audio.states.insert(
-            HandleId::random::<AudioInstance>(),
+            AssetId::Uuid {
+                uuid: Uuid::from_u128(70973842759324739),
+            },
             PlaybackState::Playing { position: 42. },
         );
         assert!(audio.is_playing_sound());
diff --git a/src/instance.rs b/src/instance.rs
index 06d25a9..05b7dbc 100644
--- a/src/instance.rs
+++ b/src/instance.rs
@@ -1,12 +1,11 @@
 use crate::{AudioTween, PlaybackState};
-use bevy::asset::{Assets, Handle};
+use bevy::asset::{Asset, Assets, Handle};
 use kira::sound::static_sound::StaticSoundHandle;
 use kira::tween::Value;
 use kira::{CommandError, Volume};
 use thiserror::Error;
 
-#[derive(bevy::reflect::TypeUuid, bevy::reflect::TypePath)]
-#[uuid = "77f84bee-42d6-4d83-9aac-929a9360f696"]
+#[derive(Asset, bevy::reflect::TypePath)]
 /// Asset for direct audio control
 pub struct AudioInstance {
     pub(crate) handle: StaticSoundHandle,
diff --git a/src/lib.rs b/src/lib.rs
index 7aa9fa4..59575aa 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -48,6 +48,7 @@ pub use audio::{
 };
 pub use backend_settings::AudioSettings;
 use bevy::app::{PostUpdate, PreUpdate};
+use bevy::asset::AssetApp;
 pub use channel::AudioControl;
 pub use source::AudioSource;
 use spacial::cleanup_stopped_spacial_instances;
@@ -98,9 +99,7 @@ use crate::source::settings_loader::SettingsLoader;
 #[cfg(feature = "wav")]
 use crate::source::wav_loader::WavLoader;
 use crate::spacial::{run_spacial_audio, SpacialAudio};
-use bevy::prelude::{
-    resource_exists, AddAsset, App, IntoSystemConfigs, Plugin, Resource, SystemSet,
-};
+use bevy::prelude::{resource_exists, App, IntoSystemConfigs, Plugin, Resource, SystemSet};
 pub use channel::dynamic::DynamicAudioChannel;
 pub use channel::dynamic::DynamicAudioChannels;
 pub use channel::typed::AudioChannel;
@@ -141,8 +140,8 @@ pub struct AudioPlugin;
 impl Plugin for AudioPlugin {
     fn build(&self, app: &mut App) {
         app.init_non_send_resource::<AudioOutput>()
-            .add_asset::<AudioSource>()
-            .add_asset::<AudioInstance>();
+            .init_asset::<AudioSource>()
+            .init_asset::<AudioInstance>();
 
         #[cfg(feature = "mp3")]
         app.init_asset_loader::<Mp3Loader>();
diff --git a/src/source/flac_loader.rs b/src/source/flac_loader.rs
index f09446c..741e5aa 100644
--- a/src/source/flac_loader.rs
+++ b/src/source/flac_loader.rs
@@ -1,31 +1,48 @@
 use anyhow::Result;
-use bevy::asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy::asset::io::Reader;
+use bevy::asset::{AssetLoader, AsyncReadExt, LoadContext};
 use bevy::utils::BoxedFuture;
 use kira::sound::static_sound::{StaticSoundData, StaticSoundSettings};
+use kira::sound::FromFileError;
 use std::io::Cursor;
+use thiserror::Error;
 
 use crate::source::AudioSource;
 
+/// Possible errors that can be produced by [`FlacLoader`]
+#[non_exhaustive]
+#[derive(Debug, Error)]
+pub enum FlacLoaderError {
+    /// An [IO Error](std::io::Error)
+    #[error("Could not read the file: {0}")]
+    Io(#[from] std::io::Error),
+    /// An Error loading sound from a file. See [`FromFileError`]
+    #[error("Error while loading a sound: {0}")]
+    FileError(#[from] FromFileError),
+}
+
 #[derive(Default)]
 pub struct FlacLoader;
 
 impl AssetLoader for FlacLoader {
+    type Asset = AudioSource;
+    type Settings = ();
+    type Error = FlacLoaderError;
+
     fn load<'a>(
         &'a self,
-        bytes: &'a [u8],
-        load_context: &'a mut LoadContext,
-    ) -> BoxedFuture<'a, Result<()>> {
+        reader: &'a mut Reader,
+        _settings: &'a (),
+        _load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
         Box::pin(async move {
             let mut sound_bytes = vec![];
-            for byte in bytes {
-                sound_bytes.push(*byte);
-            }
+            reader.read_to_end(&mut sound_bytes).await?;
             let sound = StaticSoundData::from_cursor(
                 Cursor::new(sound_bytes),
                 StaticSoundSettings::default(),
             )?;
-            load_context.set_default_asset(LoadedAsset::new(AudioSource { sound }));
-            Ok(())
+            Ok(AudioSource { sound })
         })
     }
 
diff --git a/src/source/mod.rs b/src/source/mod.rs
index 5eeae64..4c4c8b4 100644
--- a/src/source/mod.rs
+++ b/src/source/mod.rs
@@ -11,12 +11,12 @@ pub mod settings_loader;
 #[cfg(feature = "wav")]
 pub mod wav_loader;
 
-use bevy::reflect::{TypePath, TypeUuid};
+use bevy::asset::Asset;
+use bevy::reflect::TypePath;
 use kira::sound::static_sound::StaticSoundData;
 
 /// A source of audio data
-#[derive(Clone, TypeUuid, TypePath)]
-#[uuid = "6a9fc4ca-b5b5-94d6-613c-522e2d9fe86d"]
+#[derive(Clone, Asset, TypePath)]
 pub struct AudioSource {
     /// The Kira sound making up this `AudioSource`
     pub sound: StaticSoundData,
diff --git a/src/source/mp3_loader.rs b/src/source/mp3_loader.rs
index e0bb82f..83eeb3e 100644
--- a/src/source/mp3_loader.rs
+++ b/src/source/mp3_loader.rs
@@ -1,31 +1,48 @@
 use anyhow::Result;
-use bevy::asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy::asset::io::Reader;
+use bevy::asset::{AssetLoader, AsyncReadExt, LoadContext};
 use bevy::utils::BoxedFuture;
 use kira::sound::static_sound::{StaticSoundData, StaticSoundSettings};
+use kira::sound::FromFileError;
 use std::io::Cursor;
+use thiserror::Error;
 
 use crate::source::AudioSource;
 
 #[derive(Default)]
 pub struct Mp3Loader;
 
+/// Possible errors that can be produced by [`OggLoader`]
+#[non_exhaustive]
+#[derive(Debug, Error)]
+pub enum Mp3LoaderError {
+    /// An [IO Error](std::io::Error)
+    #[error("Could not read the file: {0}")]
+    Io(#[from] std::io::Error),
+    /// An Error loading sound from a file. See [`FromFileError`]
+    #[error("Error while loading a sound: {0}")]
+    FileError(#[from] FromFileError),
+}
+
 impl AssetLoader for Mp3Loader {
+    type Asset = AudioSource;
+    type Settings = ();
+    type Error = Mp3LoaderError;
+
     fn load<'a>(
         &'a self,
-        bytes: &'a [u8],
-        load_context: &'a mut LoadContext,
-    ) -> BoxedFuture<'a, Result<()>> {
+        reader: &'a mut Reader,
+        _settings: &'a (),
+        _load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
         Box::pin(async move {
             let mut sound_bytes = vec![];
-            for byte in bytes {
-                sound_bytes.push(*byte);
-            }
+            reader.read_to_end(&mut sound_bytes).await?;
             let sound = StaticSoundData::from_cursor(
                 Cursor::new(sound_bytes),
                 StaticSoundSettings::default(),
             )?;
-            load_context.set_default_asset(LoadedAsset::new(AudioSource { sound }));
-            Ok(())
+            Ok(AudioSource { sound })
         })
     }
 
diff --git a/src/source/ogg_loader.rs b/src/source/ogg_loader.rs
index 3a842da..b9e43bc 100644
--- a/src/source/ogg_loader.rs
+++ b/src/source/ogg_loader.rs
@@ -1,31 +1,48 @@
 use anyhow::Result;
-use bevy::asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy::asset::io::Reader;
+use bevy::asset::{AssetLoader, AsyncReadExt, LoadContext};
 use bevy::utils::BoxedFuture;
 use kira::sound::static_sound::{StaticSoundData, StaticSoundSettings};
+use kira::sound::FromFileError;
 use std::io::Cursor;
+use thiserror::Error;
 
 use crate::source::AudioSource;
 
+/// Possible errors that can be produced by [`OggLoader`]
+#[non_exhaustive]
+#[derive(Debug, Error)]
+pub enum OggLoaderError {
+    /// An [IO Error](std::io::Error)
+    #[error("Could not read the file: {0}")]
+    Io(#[from] std::io::Error),
+    /// An Error loading sound from a file. See [`FromFileError`]
+    #[error("Error while loading a sound: {0}")]
+    FileError(#[from] FromFileError),
+}
+
 #[derive(Default)]
 pub struct OggLoader;
 
 impl AssetLoader for OggLoader {
+    type Asset = AudioSource;
+    type Settings = ();
+    type Error = OggLoaderError;
+
     fn load<'a>(
         &'a self,
-        bytes: &'a [u8],
-        load_context: &'a mut LoadContext,
-    ) -> BoxedFuture<'a, Result<()>> {
+        reader: &'a mut Reader,
+        _settings: &'a (),
+        _load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
         Box::pin(async move {
             let mut sound_bytes = vec![];
-            for byte in bytes {
-                sound_bytes.push(*byte);
-            }
+            reader.read_to_end(&mut sound_bytes).await?;
             let sound = StaticSoundData::from_cursor(
                 Cursor::new(sound_bytes),
                 StaticSoundSettings::default(),
             )?;
-            load_context.set_default_asset(LoadedAsset::new(AudioSource { sound }));
-            Ok(())
+            Ok(AudioSource { sound })
         })
     }
 
diff --git a/src/source/settings_loader.rs b/src/source/settings_loader.rs
index 3bab66a..fa11970 100644
--- a/src/source/settings_loader.rs
+++ b/src/source/settings_loader.rs
@@ -1,13 +1,15 @@
 use std::time::Duration;
 use std::{io::Cursor, path::PathBuf};
 
-use bevy::asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy::asset::io::Reader;
+use bevy::asset::{AssetLoader, AsyncReadExt, LoadContext, ReadAssetBytesError};
 use bevy::utils::BoxedFuture;
 use kira::sound::static_sound::{StaticSoundData, StaticSoundSettings};
-use kira::sound::{EndPosition, PlaybackPosition, PlaybackRate, Region};
+use kira::sound::{EndPosition, FromFileError, PlaybackPosition, PlaybackRate, Region};
 use kira::tween::Tween;
 use kira::Volume;
 use serde::Deserialize;
+use thiserror::Error;
 
 use crate::AudioSource;
 
@@ -102,22 +104,47 @@ impl From<SoundSettings> for StaticSoundSettings {
     }
 }
 
+/// Possible errors that can be produced by [`OggLoader`]
+#[non_exhaustive]
+#[derive(Debug, Error)]
+pub enum SettingsLoaderError {
+    /// An [IO Error](std::io::Error)
+    #[error("Could not read the file: {0}")]
+    Io(#[from] std::io::Error),
+    /// An Error loading sound from a file. See [`FromFileError`]
+    #[error("Error while loading a sound: {0}")]
+    FileError(#[from] FromFileError),
+    /// Failed to read audio asset
+    #[error("Error while loading audio asset: {0}")]
+    ReadAssetError(#[from] ReadAssetBytesError),
+    /// A [RON Error](serde_ron::error::SpannedError)
+    #[error("Could not parse RON: {0}")]
+    RonError(#[from] ron::error::SpannedError),
+}
+
 impl AssetLoader for SettingsLoader {
+    type Asset = AudioSource;
+    type Settings = ();
+    type Error = SettingsLoaderError;
+
     fn load<'a>(
         &'a self,
-        bytes: &'a [u8],
+        reader: &'a mut Reader,
+        _settings: &'a (),
         load_context: &'a mut LoadContext,
-    ) -> BoxedFuture<'a, Result<(), anyhow::Error>> {
+    ) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
         Box::pin(async move {
-            let sound_settings: SoundSettings = ron::de::from_bytes(bytes)?;
-            let sound_bytes = load_context.read_asset_bytes(&sound_settings.file).await?;
+            let mut bytes = Vec::new();
+            reader.read_to_end(&mut bytes).await?;
+            let sound_settings: SoundSettings = ron::de::from_bytes(&bytes)?;
+            let sound_bytes = load_context
+                .read_asset_bytes(sound_settings.file.clone())
+                .await?;
 
             let sound =
                 StaticSoundData::from_cursor(Cursor::new(sound_bytes), sound_settings.into())?;
 
-            load_context.set_default_asset(LoadedAsset::new(AudioSource { sound }));
-
-            Ok(())
+            Ok(AudioSource { sound })
         })
     }
 
diff --git a/src/source/wav_loader.rs b/src/source/wav_loader.rs
index 8d1cd2a..fa64387 100644
--- a/src/source/wav_loader.rs
+++ b/src/source/wav_loader.rs
@@ -1,34 +1,50 @@
 use anyhow::Result;
-use bevy::asset::{AssetLoader, LoadContext, LoadedAsset};
+use bevy::asset::io::Reader;
+use bevy::asset::{AssetLoader, AsyncReadExt, LoadContext};
 use bevy::utils::BoxedFuture;
 use kira::sound::static_sound::{StaticSoundData, StaticSoundSettings};
+use kira::sound::FromFileError;
 use std::io::Cursor;
+use thiserror::Error;
 
 use crate::source::AudioSource;
 
 #[derive(Default)]
 pub struct WavLoader;
 
+/// Possible errors that can be produced by [`OggLoader`]
+#[non_exhaustive]
+#[derive(Debug, Error)]
+pub enum WavLoaderError {
+    /// An [IO Error](std::io::Error)
+    #[error("Could not read the file: {0}")]
+    Io(#[from] std::io::Error),
+    /// An Error loading sound from a file. See [`FromFileError`]
+    #[error("Error while loading a sound: {0}")]
+    FileError(#[from] FromFileError),
+}
+
 impl AssetLoader for WavLoader {
+    type Asset = AudioSource;
+    type Settings = ();
+    type Error = WavLoaderError;
+
     fn load<'a>(
         &'a self,
-        bytes: &'a [u8],
-        load_context: &'a mut LoadContext,
-    ) -> BoxedFuture<'a, Result<()>> {
+        reader: &'a mut Reader,
+        _settings: &'a (),
+        _load_context: &'a mut LoadContext,
+    ) -> BoxedFuture<'a, Result<Self::Asset, Self::Error>> {
         Box::pin(async move {
             let mut sound_bytes = vec![];
-            for byte in bytes {
-                sound_bytes.push(*byte);
-            }
+            reader.read_to_end(&mut sound_bytes).await?;
             let sound = StaticSoundData::from_cursor(
                 Cursor::new(sound_bytes),
                 StaticSoundSettings::default(),
             )?;
-            load_context.set_default_asset(LoadedAsset::new(AudioSource { sound }));
-            Ok(())
+            Ok(AudioSource { sound })
         })
     }
-
     fn extensions(&self) -> &[&str] {
         &["wav"]
     }

From 06e1020ac55654811eaf43d6f3601ed11e3b592d Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Sat, 4 Nov 2023 21:14:04 +0100
Subject: [PATCH 2/2] Update to bevy 0.12

---
 CHANGELOG.md                  | 1 +
 Cargo.toml                    | 6 +++---
 examples/multiple_channels.rs | 2 +-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe3c25e..dc8b967 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,6 @@
 # Changelog
 
+## v0.18.0 - 04.11.2023
 - Update to Bevy `0.12`
 
 ## v0.17.0
diff --git a/Cargo.toml b/Cargo.toml
index 49f7abc..964cd7f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_kira_audio"
-version = "0.17.0"
+version = "0.18.0"
 authors = ["Niklas Eicker <hello@nikl.me>"]
 edition = "2021"
 license = "MIT OR Apache-2.0"
@@ -22,7 +22,7 @@ wav = ["kira/wav"]
 settings_loader = ["dep:ron", "dep:serde", "kira/serde"]
 
 [dependencies]
-bevy = { git = "https://github.com/bevyengine/bevy", default-features = false, features = ["bevy_asset"] }
+bevy = { version = "0.12", default-features = false, features = ["bevy_asset"] }
 anyhow = "1.0"
 uuid = { version = "1", features = ["fast-rng"] }
 kira = { version = "0.8", default-features = false, features = ["cpal"] }
@@ -32,7 +32,7 @@ parking_lot = "0.12"
 thiserror = "1.0"
 
 [dev-dependencies.bevy]
-git = "https://github.com/bevyengine/bevy"
+version = "0.12"
 default-features = false
 features = [
     "bevy_asset",
diff --git a/examples/multiple_channels.rs b/examples/multiple_channels.rs
index 97695ea..fff7b2d 100644
--- a/examples/multiple_channels.rs
+++ b/examples/multiple_channels.rs
@@ -327,7 +327,7 @@ fn build_button_row<T: Component + Default + Clone>(
                                 value: format!("Channel {}", 4 - channel_index),
                                 style: TextStyle {
                                     font_size: 20.0,
-                                    color: Color::rgb(0.2, 0.2, 0.2),
+                                    color: Color::rgb(0.9, 0.9, 0.9),
                                     font: font.clone(),
                                 },
                             }],