Release

.drone.yml

@@ -1,47 +0,0 @@
-kind: pipeline
-type: docker
-name: default
-
-environment:
-  DEPENDENCIES: cmake pkg-config libx11-dev libasound2-dev libudev-dev libxcb-xfixes0-dev libwayland-dev libxkbcommon-dev libvulkan-dev libpulse-dev
-
-steps:
-  - name: test
-    image: rust:bullseye
-    pull: always
-    commands:
-      - apt-get update -qq
-      - apt-get install -qqy $DEPENDENCIES
-      - rustup component add clippy rustfmt
-      - cargo fmt --check
-      - cargo test
-      - cargo clippy
-  - name: release
-    image: rust:bullseye
-    pull: always
-    commands:
-      - apt-get update -qq
-      - apt-get install -qqy $DEPENDENCIES
-      - cargo publish
-    when:
-      ref:
-        - refs/tags/v*
-    environment:
-      CARGO_REGISTRY_TOKEN:
-        from_secret: cargo_registry_token
-  - name: discord notification
-    image: appleboy/drone-discord
-    when:
-      status: [success, failure]
-    settings:
-      webhook_id:
-        from_secret: discord_webhook_id
-      webhook_token:
-        from_secret: discord_webhook_token
-      tts: true
-      message: >
-        {{#success build.status}}
-          {{repo.name}} build {{build.number}} succeeded: <{{build.link}}>
-        {{else}}
-          {{repo.name}} build {{build.number}} failed: <{{build.link}}>
-        {{/success}}

.gitea/workflows/release.yml

@@ -0,0 +1,39 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+*"
+  workflow_dispatch:
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/pre-commit
+          key: pre-commit|${{ env.PY }}|${{ hashFiles('.pre-commit-config.yaml') }}
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+          components: rustfmt, clippy
+      - name: install Linux build dependencies
+        run: sudo apt-get update; sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev libwayland-dev libclang-dev cmake
+        if: runner.os == 'linux'
+      - uses: actions/setup-python@v3
+      - uses: pre-commit/action@v3.0.1
+      - name: Publish
+        run: cargo publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.gitea/workflows/test.yml

@@ -0,0 +1,37 @@
+name: Test
+
+on:
+  pull_request:
+  push:
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        # os: [windows-latest, ubuntu-latest, macos-latest]
+        os: [ubuntu-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cache/pre-commit
+          key: pre-commit|${{ env.PY }}|${{ hashFiles('.pre-commit-config.yaml') }}
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+          components: rustfmt, clippy
+      - name: install Linux build dependencies
+        run: sudo apt-get update; sudo apt-get install -y --no-install-recommends libasound2-dev libudev-dev libwayland-dev libclang-dev cmake
+        if: runner.os == 'linux'
+      - uses: actions/setup-python@v3
+      - uses: pre-commit/action@v3.0.1

.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+fail_fast: true
+repos:
+  - repo: https://github.com/doublify/pre-commit-rust
+    rev: v1.0
+    hooks:
+      - id: fmt
+        args: [--, --check]
+      - id: cargo-check
+        args: [--bins, --examples]
+      - id: clippy

CHANGELOG.md

@@ -2,6 +2,74 @@
 
 All notable changes to this project will be documented in this file.
 
+## Version 0.9.1 - 2025-01-07
+
+### Miscellaneous Tasks
+
+- Don't set position if values are NaN.
+
+## Version 0.9.0 - 2024-12-06
+
+### Miscellaneous Tasks
+
+- Upgrade to Bevy 0.15.
+
+## Version 0.8.0 - 2024-12-02
+
+### Bug Fixes
+
+- Clear generator when source is cleared, and improve handling for changing source types.
+
+### Features
+
+- Add `Sound.playback_position` to support initializing new buffers at non-zero playback position.
+
+### Miscellaneous Tasks
+
+- Clean up code.
+
+## Version 0.7.0 - 2024-07-07
+
+### Miscellaneous Tasks
+
+- Add pre-commit.
+- Switch to Gitea Actions.
+- Upgrade to Bevy 0.14.
+
+## Version 0.6.0 - 2024-03-14
+
+### Miscellaneous Tasks
+
+- Upgrade Bevy to v0.13.
+
+## Version 0.5.0 - 2024-02-09
+
+### Bug Fixes
+
+- Clean up `LastAudio` when `Sound` is removed, not `Source`.
+
+### Features
+
+- [**breaking**] Renamed `SynthizerSets::First` to `SynthizerSets::PreUpdate` and moved remaining systems into `PostUpdate`.
+- [**breaking**] Removed `Sound.restart`. Clear `Sound.generator` for equivalent functionality.
+
+### Miscellaneous Tasks
+
+- Clean up code.
+- Bump dependencies.
+
+## Version 0.4.0 - 2023-07-16
+
+### Miscellaneous Tasks
+
+- Update to Bevy 0.11.
+
+## Version 0.3.2 - 2023-05-04
+
+### Bug Fixes
+
+- Instantiate sources for sounds without a source in `PreUpdate`.
+
 ## Version 0.3.1 - 2023-04-04
 
 ### Miscellaneous Tasks

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_synthizer"
-version = "0.3.1"
+version = "0.9.1"
 authors = ["Nolan Darilek <nolan@thewordnerd.info>"]
 description = "A Bevy plugin for Synthizer, a library for 3D audio and synthesis with a focus on games and VR applications"
 license = "MIT OR Apache-2.0"
@@ -10,12 +10,12 @@ repository = "https://labs.lightsout.games/projects/bevy_synthizer"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-anyhow = "1"
-bevy = { version = "0.10", default-features = false, features = ["bevy_asset"] }
+bevy = { version = "0.15", default-features = false, features = ["bevy_asset"] }
 synthizer = "0.5.6"
+thiserror = "1"
 
 [dev-dependencies]
-bevy = { version = "0.10", default-features = true }
+bevy = { version = "0.15", default-features = true }
 
 [package.metadata.release]
 publish = false

examples/buffer.rs

@@ -1,6 +1,6 @@
 use std::f32;
 
-use bevy::{asset::LoadState, prelude::*};
+use bevy::{asset::LoadedFolder, prelude::*};
 use bevy_synthizer::*;
 
 #[derive(Component, Deref, DerefMut)]
@@ -12,67 +12,58 @@ impl Default for RotationTimer {
     }
 }
 
-#[derive(Resource, Default)]
-struct AssetHandles {
-    sounds: Vec<HandleUntyped>,
-    loaded: bool,
-}
+#[derive(Resource, Default, Deref, DerefMut)]
+struct AssetHandles(Handle<LoadedFolder>);
 
 fn setup(asset_server: Res<AssetServer>, mut handles: ResMut<AssetHandles>) {
-    handles.sounds = asset_server.load_folder(".").expect("Failed to load sfx");
+    **handles = asset_server.load_folder(".");
 }
 
 fn load_and_create(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
-    mut handles: ResMut<AssetHandles>,
+    handles: Res<AssetHandles>,
+    listeners: Query<&Listener>,
 ) {
-    if handles.loaded {
+    if !asset_server.is_loaded_with_dependencies(&**handles) {
         return;
     }
-    handles.loaded = asset_server
-        .get_group_load_state(handles.sounds.iter().map(|handle| handle.id()))
-        == LoadState::Loaded;
-    if handles.loaded {
-        commands.spawn((
-            TransformBundle::default(),
-            Listener,
-            RotationTimer::default(),
-        ));
-        let handle = handles.sounds[0].clone();
-        let buffer = asset_server.get_handle(handle);
-        commands.spawn((
-            TransformBundle::from(Transform::from_translation(Vec3::new(10., 0., 0.))),
-            Source::default(),
-            Sound {
-                audio: buffer.into(),
-                looping: true,
-                ..default()
-            },
-        ));
+    if !listeners.is_empty() {
+        return;
     }
+    commands.spawn((Transform::default(), Listener, RotationTimer::default()));
+    let handle = asset_server.load("footstep.wav");
+    commands.spawn((
+        Transform::from_translation(Vec3::new(10., 0., 0.)),
+        Source::default(),
+        Sound {
+            audio: handle.into(),
+            looping: true,
+            ..default()
+        },
+    ));
 }
 
 fn rotate_listener(time: Res<Time>, mut query: Query<(&mut RotationTimer, &mut Transform)>) {
     for (mut timer, mut transform) in query.iter_mut() {
         timer.tick(time.delta());
-        let angle = f32::consts::PI * 2. * timer.percent();
+        let angle = f32::consts::PI * 2. * timer.fraction();
         transform.rotation = Quat::from_rotation_z(angle);
     }
 }
 
 fn main() {
     App::new()
-        .add_plugins(DefaultPlugins)
-        .add_plugin(SynthizerPlugin {
-            default_panner_strategy: Some(bevy_synthizer::syz::PannerStrategy::Hrtf),
-            default_distance_model: Some(bevy_synthizer::syz::DistanceModel::Inverse),
-            ..default()
-        })
-        .add_system(bevy::window::close_on_esc)
+        .add_plugins((
+            DefaultPlugins,
+            SynthizerPlugin {
+                default_panner_strategy: Some(bevy_synthizer::syz::PannerStrategy::Hrtf),
+                default_distance_model: Some(bevy_synthizer::syz::DistanceModel::Inverse),
+                ..default()
+            },
+        ))
         .init_resource::<AssetHandles>()
-        .add_startup_system(setup)
-        .add_system(load_and_create)
-        .add_system(rotate_listener)
+        .add_systems(Startup, setup)
+        .add_systems(Update, (load_and_create, rotate_listener))
         .run();
 }

examples/generator.rs

@@ -13,16 +13,12 @@ impl Default for RotationTimer {
 }
 
 fn setup(mut commands: Commands, context: Res<Context>) {
-    commands.spawn((
-        TransformBundle::default(),
-        Listener,
-        RotationTimer::default(),
-    ));
+    commands.spawn((Transform::default(), Listener, RotationTimer::default()));
     let generator: syz::Generator = syz::FastSineBankGenerator::new_sine(&context, 440.)
         .expect("Failed to create generator")
         .into();
     commands.spawn((
-        TransformBundle::from(Transform::from_translation(Vec3::new(10., 0., 0.))),
+        Transform::from_translation(Vec3::new(10., 0., 0.)),
         Source::default(),
         Sound {
             audio: generator.into(),
@@ -35,21 +31,22 @@ fn setup(mut commands: Commands, context: Res<Context>) {
 fn rotate_listener(time: Res<Time>, mut query: Query<(&mut RotationTimer, &mut Transform)>) {
     for (mut timer, mut transform) in query.iter_mut() {
         timer.tick(time.delta());
-        let angle = f32::consts::PI * 2. * timer.percent();
+        let angle = f32::consts::PI * 2. * timer.fraction();
         transform.rotation = Quat::from_rotation_z(angle);
     }
 }
 
 fn main() {
     App::new()
-        .add_plugins(DefaultPlugins)
-        .add_plugin(SynthizerPlugin {
-            default_panner_strategy: Some(bevy_synthizer::syz::PannerStrategy::Hrtf),
-            default_distance_model: Some(bevy_synthizer::syz::DistanceModel::Inverse),
-            ..default()
-        })
-        .add_system(bevy::window::close_on_esc)
-        .add_startup_system(setup)
-        .add_system(rotate_listener)
+        .add_plugins((
+            DefaultPlugins,
+            SynthizerPlugin {
+                default_panner_strategy: Some(bevy_synthizer::syz::PannerStrategy::Hrtf),
+                default_distance_model: Some(bevy_synthizer::syz::DistanceModel::Inverse),
+                ..default()
+            },
+        ))
+        .add_systems(Startup, setup)
+        .add_systems(Update, rotate_listener)
         .run();
 }

src/lib.rs

@@ -2,40 +2,43 @@
 use std::collections::HashMap;
 
 use bevy::{
-    asset::{AssetLoader, LoadContext, LoadedAsset},
+    asset::{io::Reader, AssetLoader, LoadContext},
     prelude::*,
-    reflect::TypeUuid,
     transform::TransformSystem,
-    utils::BoxedFuture,
 };
 pub use synthizer as syz;
+use thiserror::Error;
 
-#[derive(Clone, Debug, Deref, DerefMut, PartialEq, Eq, TypeUuid)]
-#[uuid = "6b6b533a-bb1f-11ec-bda2-00155d8fdde9"]
+#[derive(Asset, Clone, Debug, Deref, DerefMut, PartialEq, Eq, TypePath)]
 pub struct Buffer(syz::Buffer);
 
 #[derive(Clone, Copy, Debug, Default)]
 struct BufferAssetLoader;
 
+#[non_exhaustive]
+#[derive(Debug, Error)]
+pub enum BufferAssetLoaderError {
+    #[error("Could not load asset: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("Synthizer error: {0}")]
+    SynthizerError(#[from] synthizer::Error),
+}
+
 impl AssetLoader for BufferAssetLoader {
-    fn load<'a>(
-        &'a self,
-        bytes: &'a [u8],
-        load_context: &'a mut LoadContext,
-    ) -> BoxedFuture<'a, Result<(), anyhow::Error>> {
-        Box::pin(async move {
-            let buffer: Option<Buffer> =
-                match load_context.path().extension().unwrap().to_str().unwrap() {
-                    "flac" | "mp3" | "wav" => {
-                        syz::Buffer::from_encoded_data(bytes).map(Buffer).ok()
-                    }
-                    _ => None,
-                };
-            if let Some(buffer) = buffer {
-                load_context.set_default_asset(LoadedAsset::new(buffer));
-            }
-            Ok(())
-        })
+    type Asset = Buffer;
+    type Settings = ();
+    type Error = BufferAssetLoaderError;
+
+    async fn load(
+        &self,
+        reader: &mut dyn Reader,
+        _settings: &(),
+        _load_context: &mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let mut bytes = Vec::new();
+        reader.read_to_end(&mut bytes).await?;
+        let buffer = syz::Buffer::from_encoded_data(&bytes).map(Buffer)?;
+        Ok(buffer)
     }
 
     fn extensions(&self) -> &[&str] {
@@ -152,8 +155,8 @@ pub struct Sound {
     pub gain: f64,
     pub pitch: f64,
     pub looping: bool,
+    pub playback_position: f64,
     pub paused: bool,
-    pub restart: bool,
     pub generator: Option<syz::Generator>,
 }
 
@@ -164,13 +167,14 @@ impl Default for Sound {
             gain: 1.,
             pitch: 1.,
             looping: false,
+            playback_position: default(),
             paused: false,
-            restart: false,
             generator: None,
         }
     }
 }
 
+#[derive(Event, Debug)]
 pub enum SynthizerEvent {
     Finished(Entity),
     Looped(Entity),
@@ -226,41 +230,42 @@ fn add_source_handle(
     )>,
 ) {
     for (mut source, panner_strategy, transform, angular_pan, scalar_pan) in &mut query {
-        if source.handle.is_none() {
-            let panner_strategy = panner_strategy.cloned().unwrap_or_default();
-            let handle: syz::Source = if let Some(transform) = transform {
-                let translation = transform.translation();
-                syz::Source3D::new(
-                    &context,
-                    *panner_strategy,
-                    (
-                        translation.x as f64,
-                        translation.y as f64,
-                        translation.z as f64,
-                    ),
-                )
-                .expect("Failed to create source")
-                .into()
-            } else if let Some(scalar_pan) = scalar_pan {
-                syz::ScalarPannedSource::new(&context, *panner_strategy, **scalar_pan)
-                    .expect("Failed to create source")
-                    .into()
-            } else if let Some(angular_pan) = angular_pan {
-                syz::AngularPannedSource::new(
-                    &context,
-                    *panner_strategy,
-                    angular_pan.azimuth,
-                    angular_pan.elevation,
-                )
-                .expect("Failed to create source")
-                .into()
-            } else {
-                syz::DirectSource::new(&context)
-                    .expect("Failed to create source")
-                    .into()
-            };
-            source.handle = Some(handle);
+        if source.handle.is_some() {
+            continue;
         }
+        let panner_strategy = panner_strategy.cloned().unwrap_or_default();
+        let handle: syz::Source = if let Some(transform) = transform {
+            let translation = transform.translation();
+            syz::Source3D::new(
+                &context,
+                *panner_strategy,
+                (
+                    translation.x as f64,
+                    translation.y as f64,
+                    translation.z as f64,
+                ),
+            )
+            .expect("Failed to create source")
+            .into()
+        } else if let Some(scalar_pan) = scalar_pan {
+            syz::ScalarPannedSource::new(&context, *panner_strategy, **scalar_pan)
+                .expect("Failed to create source")
+                .into()
+        } else if let Some(angular_pan) = angular_pan {
+            syz::AngularPannedSource::new(
+                &context,
+                *panner_strategy,
+                angular_pan.azimuth,
+                angular_pan.elevation,
+            )
+            .expect("Failed to create source")
+            .into()
+        } else {
+            syz::DirectSource::new(&context)
+                .expect("Failed to create source")
+                .into()
+        };
+        source.handle = Some(handle);
     }
 }
 
@@ -272,55 +277,62 @@ fn add_generator(
     parents: Query<&Parent>,
 ) {
     for (entity, parent, mut sound) in &mut query {
-        if sound.generator.is_none() {
-            let mut source = if let Ok(s) = sources.get_mut(entity) {
-                Some(s)
-            } else if let Some(parent) = parent {
-                let mut parent: Option<&Parent> = Some(parent);
-                let mut target = None;
-                while let Some(p) = parent {
-                    if sources.get(**p).is_ok() {
-                        target = Some(**p);
-                        break;
-                    }
-                    parent = parents.get(**p).ok();
+        if sound.generator.is_some() {
+            continue;
+        }
+        let mut source = if let Ok(s) = sources.get_mut(entity) {
+            Some(s)
+        } else if parent.is_some() {
+            let mut parent = parent;
+            let mut target = None;
+            while let Some(p) = parent {
+                if sources.get(**p).is_ok() {
+                    target = Some(**p);
+                    break;
                 }
-                target.map(|v| sources.get_mut(v).unwrap())
-            } else {
-                None
-            };
-            if let Some(source) = source.as_mut() {
-                if let Some(handle) = source.handle.as_mut() {
-                    let generator: Option<syz::Generator> = match &sound.audio {
-                        Audio::Buffer(buffer) => {
-                            if let Some(b) = buffers.get(buffer) {
-                                let generator = syz::BufferGenerator::new(&context)
-                                    .expect("Failed to create generator");
-                                generator.buffer().set(&**b).expect("Unable to set buffer");
-                                Some(generator.into())
-                            } else {
-                                None
-                            }
+                parent = parents.get(**p).ok();
+            }
+            target.map(|v| sources.get_mut(v).unwrap())
+        } else {
+            None
+        };
+        if let Some(source) = source.as_mut() {
+            if let Some(handle) = source.handle.as_mut() {
+                let generator: Option<syz::Generator> = match &sound.audio {
+                    Audio::Buffer(buffer) => {
+                        if let Some(b) = buffers.get(buffer) {
+                            let generator = syz::BufferGenerator::new(&context)
+                                .expect("Failed to create generator");
+                            generator.buffer().set(&**b).expect("Unable to set buffer");
+                            assert!(sound.playback_position >= 0.);
+                            generator
+                                .playback_position()
+                                .set(sound.playback_position)
+                                .expect("Failed to set playback position");
+                            Some(generator.into())
+                        } else {
+                            None
                         }
-                        Audio::Generator(generator) => Some(generator.clone()),
-                    };
-                    if let Some(generator) = generator {
-                        assert!(sound.gain >= 0.);
-                        generator
-                            .gain()
-                            .set(sound.gain)
-                            .expect("Failed to set gain");
-                        assert!(sound.pitch > 0. && sound.pitch <= 2.);
-                        generator
-                            .pitch_bend()
-                            .set(sound.pitch)
-                            .expect("Failed to set pitch");
-                        handle
-                            .add_generator(generator.handle())
-                            .expect("Unable to add generator");
-                        sound.generator = Some(generator);
                     }
-                }
+                    Audio::Generator(generator) => Some(generator.clone()),
+                };
+                let Some(generator) = generator else {
+                    continue;
+                };
+                assert!(sound.gain >= 0.);
+                generator
+                    .gain()
+                    .set(sound.gain)
+                    .expect("Failed to set gain");
+                assert!(sound.pitch > 0. && sound.pitch <= 2.);
+                generator
+                    .pitch_bend()
+                    .set(sound.pitch)
+                    .expect("Failed to set pitch");
+                handle
+                    .add_generator(generator.handle())
+                    .expect("Unable to add generator");
+                sound.generator = Some(generator);
             }
         }
     }
@@ -356,8 +368,9 @@ fn swap_buffers(
 ) {
     for (entity, mut sound) in &mut query {
         if let Some(l) = last_audio.get(&entity) {
-            if sound.audio != *l {
+            if sound.generator.is_some() && sound.audio != *l {
                 sound.generator = None;
+                sound.playback_position = 0.;
             }
         }
         last_audio.insert(entity, sound.audio.clone());
@@ -375,14 +388,15 @@ fn change_panner_strategy(
             check.push(entity);
         }
     }
-    for entity in removed.iter() {
+    for entity in removed.read() {
         check.push(entity);
     }
     for entity in check.iter() {
-        if let Ok(mut source) = sources.get_mut(*entity) {
-            if source.handle.is_some() {
-                source.handle = None;
-            }
+        let Ok(mut source) = sources.get_mut(*entity) else {
+            continue;
+        };
+        if source.handle.is_some() {
+            source.handle = None;
         }
     }
 }
@@ -400,6 +414,7 @@ fn update_source_properties(
         Option<&AngularPan>,
         Option<&ScalarPan>,
         Option<&GlobalTransform>,
+        Option<&mut Sound>,
     )>,
 ) {
     for (
@@ -413,16 +428,20 @@ fn update_source_properties(
         angular_pan,
         scalar_pan,
         transform,
+        sound,
     ) in &mut query
     {
         let Source { gain, .. } = *source;
         assert!(gain >= 0.);
-        if let Some(handle) = source.handle.as_mut() {
-            handle.gain().set(gain).expect("Failed to set gain");
-            let mut clear_source = false;
+        let Some(handle) = source.handle.as_mut() else {
+            continue;
+        };
+        handle.gain().set(gain).expect("Failed to set gain");
+        let mut clear_source = false;
+        if let Some(source) = handle.cast_to::<syz::Source3D>().expect("Failed to cast") {
             if let Some(transform) = transform {
-                if let Some(source) = handle.cast_to::<syz::Source3D>().expect("Failed to cast") {
-                    let translation = transform.translation();
+                let translation = transform.translation();
+                if !translation.x.is_nan() && !translation.y.is_nan() && !translation.z.is_nan() {
                     source
                         .position()
                         .set((
@@ -431,92 +450,106 @@ fn update_source_properties(
                             translation.z as f64,
                         ))
                         .expect("Failed to set position");
-                    let distance_model = distance_model
-                        .cloned()
-                        .map(|v| *v)
-                        .unwrap_or_else(|| context.default_distance_model().get().unwrap());
-                    source
-                        .distance_model()
-                        .set(distance_model)
-                        .expect("Failed to set distance_model");
-                    let distance_ref = distance_ref
-                        .map(|v| **v)
-                        .unwrap_or_else(|| context.default_distance_ref().get().unwrap());
-                    assert!(distance_ref >= 0.);
-                    source
-                        .distance_ref()
-                        .set(distance_ref)
-                        .expect("Failed to set distance_ref");
-                    let distance_max = distance_max
-                        .map(|v| **v)
-                        .unwrap_or_else(|| context.default_distance_max().get().unwrap());
-                    assert!(distance_max >= 0.);
-                    source
-                        .distance_max()
-                        .set(distance_max)
-                        .expect("Failed to set distance_max");
-                    let rolloff = rolloff
-                        .map(|v| **v)
-                        .unwrap_or_else(|| context.default_rolloff().get().unwrap());
-                    assert!(rolloff >= 0.);
-                    source
-                        .rolloff()
-                        .set(rolloff)
-                        .expect("Failed to set rolloff");
-                    let closeness_boost = closeness_boost
-                        .map(|v| **v)
-                        .unwrap_or_else(|| context.default_closeness_boost().get().unwrap());
-                    assert!(closeness_boost >= 0.);
-                    source
-                        .closeness_boost()
-                        .set(closeness_boost)
-                        .expect("Failed to set closeness_boost");
-                    let closeness_boost_distance =
-                        closeness_boost_distance.map(|v| **v).unwrap_or_else(|| {
-                            context.default_closeness_boost_distance().get().unwrap()
-                        });
-                    assert!(closeness_boost_distance >= 0.);
-                    source
-                        .closeness_boost_distance()
-                        .set(closeness_boost_distance)
-                        .expect("Failed to set closeness_boost_distance");
-                } else {
-                    clear_source = true;
-                }
-            } else if let Some(angular_pan) = angular_pan {
-                if let Some(source) = handle
-                    .cast_to::<syz::AngularPannedSource>()
-                    .expect("Failed to cast")
-                {
-                    assert!(angular_pan.azimuth >= 0. && angular_pan.azimuth <= 360.);
-                    source
-                        .azimuth()
-                        .set(angular_pan.azimuth)
-                        .expect("Failed to set azimuth");
-                    assert!(angular_pan.elevation >= -90. && angular_pan.elevation <= 90.);
-                    source
-                        .elevation()
-                        .set(angular_pan.elevation)
-                        .expect("Failed to set elevation");
-                } else {
-                    clear_source = true;
-                }
-            } else if let Some(scalar_pan) = scalar_pan {
-                if let Some(source) = handle
-                    .cast_to::<syz::ScalarPannedSource>()
-                    .expect("Failed to cast")
-                {
-                    assert!(**scalar_pan >= -1. && **scalar_pan <= 1.);
-                    source
-                        .panning_scalar()
-                        .set(**scalar_pan)
-                        .expect("Failed to set scalar panning");
-                } else {
-                    clear_source = true;
                 }
+                let distance_model = distance_model
+                    .cloned()
+                    .map(|v| *v)
+                    .unwrap_or_else(|| context.default_distance_model().get().unwrap());
+                source
+                    .distance_model()
+                    .set(distance_model)
+                    .expect("Failed to set distance_model");
+                let distance_ref = distance_ref
+                    .map(|v| **v)
+                    .unwrap_or_else(|| context.default_distance_ref().get().unwrap());
+                assert!(distance_ref >= 0.);
+                source
+                    .distance_ref()
+                    .set(distance_ref)
+                    .expect("Failed to set distance_ref");
+                let distance_max = distance_max
+                    .map(|v| **v)
+                    .unwrap_or_else(|| context.default_distance_max().get().unwrap());
+                assert!(distance_max >= 0.);
+                source
+                    .distance_max()
+                    .set(distance_max)
+                    .expect("Failed to set distance_max");
+                let rolloff = rolloff
+                    .map(|v| **v)
+                    .unwrap_or_else(|| context.default_rolloff().get().unwrap());
+                assert!(rolloff >= 0.);
+                assert!(rolloff >= 0.);
+                source
+                    .rolloff()
+                    .set(rolloff)
+                    .expect("Failed to set rolloff");
+                let closeness_boost = closeness_boost
+                    .map(|v| **v)
+                    .unwrap_or_else(|| context.default_closeness_boost().get().unwrap());
+                assert!(closeness_boost >= 0.);
+                source
+                    .closeness_boost()
+                    .set(closeness_boost)
+                    .expect("Failed to set closeness_boost");
+                let closeness_boost_distance = closeness_boost_distance
+                    .map(|v| **v)
+                    .unwrap_or_else(|| context.default_closeness_boost_distance().get().unwrap());
+                assert!(closeness_boost_distance >= 0.);
+                source
+                    .closeness_boost_distance()
+                    .set(closeness_boost_distance)
+                    .expect("Failed to set closeness_boost_distance");
+            } else {
+                clear_source = true;
             }
-            if clear_source {
-                source.handle = None;
+        } else if let Some(source) = handle
+            .cast_to::<syz::AngularPannedSource>()
+            .expect("Failed to cast")
+        {
+            if let Some(angular_pan) = angular_pan {
+                assert!(angular_pan.azimuth >= 0. && angular_pan.azimuth <= 360.);
+                source
+                    .azimuth()
+                    .set(angular_pan.azimuth)
+                    .expect("Failed to set azimuth");
+                assert!(angular_pan.elevation >= -90. && angular_pan.elevation <= 90.);
+                source
+                    .elevation()
+                    .set(angular_pan.elevation)
+                    .expect("Failed to set elevation");
+            } else {
+                clear_source = true;
+            }
+        } else if let Some(source) = handle
+            .cast_to::<syz::ScalarPannedSource>()
+            .expect("Failed to cast")
+        {
+            if let Some(scalar_pan) = scalar_pan {
+                assert!(**scalar_pan >= -1. && **scalar_pan <= 1.);
+                source
+                    .panning_scalar()
+                    .set(**scalar_pan)
+                    .expect("Failed to set scalar panning");
+            } else {
+                clear_source = true;
+            }
+        } else if handle
+            .cast_to::<syz::DirectSource>()
+            .expect("Failed to cast")
+            .is_some()
+        {
+            if transform.is_some() || angular_pan.is_some() || scalar_pan.is_some() {
+                clear_source = true;
+            }
+        } else if source.handle.is_some() {
+            clear_source = true;
+        }
+        if clear_source {
+            source.handle = None;
+            if let Some(mut sound) = sound {
+                sound.generator = None;
+                sound.playback_position = 0.;
             }
         }
     }
@@ -532,65 +565,66 @@ fn update_sound_properties(mut query: Query<&mut Sound>) {
         } = *sound;
         assert!(gain >= 0.);
         assert!(pitch > 0. && pitch <= 2.);
-        if sound.restart {
-            if let Some(generator) = sound.generator.as_mut() {
-                if let Some(generator) = generator
-                    .cast_to::<syz::BufferGenerator>()
-                    .expect("Failed to cast")
-                {
-                    generator
-                        .playback_position()
-                        .set(0.)
-                        .expect("Failed to restart");
-                }
-            }
-            sound.restart = false;
+        let Some(generator) = &sound.generator else {
+            continue;
+        };
+        if let Some(generator) = generator
+            .cast_to::<syz::BufferGenerator>()
+            .expect("Failed to cast")
+        {
+            sound.playback_position = generator
+                .playback_position()
+                .get()
+                .expect("Failed to getplayback position");
         }
-        if let Some(generator) = sound.generator.as_mut() {
-            generator.gain().set(gain).expect("Failed to set gain");
+        let Some(generator) = sound.generator.as_mut() else {
+            continue;
+        };
+        generator.gain().set(gain).expect("Failed to set gain");
+        generator
+            .pitch_bend()
+            .set(pitch)
+            .expect("Failed to set pitch");
+        if let Some(generator) = generator
+            .cast_to::<syz::BufferGenerator>()
+            .expect("Failed to cast")
+        {
             generator
-                .pitch_bend()
-                .set(pitch)
-                .expect("Failed to set pitch");
-            if let Some(generator) = generator
-                .cast_to::<syz::BufferGenerator>()
-                .expect("Failed to cast")
-            {
-                generator
-                    .looping()
-                    .set(looping)
-                    .expect("Failed to set looping");
-            }
+                .looping()
+                .set(looping)
+                .expect("Failed to set looping");
         }
     }
 }
 
 fn update_source_playback_state(query: Query<&Source>) {
     for source in &query {
-        if let Some(handle) = &source.handle {
-            if source.paused {
-                handle.pause().expect("Failed to pause");
-            } else {
-                handle.play().expect("Failed to play");
-            }
+        let Some(handle) = &source.handle else {
+            continue;
+        };
+        if source.paused {
+            handle.pause().expect("Failed to pause");
+        } else {
+            handle.play().expect("Failed to play");
         }
     }
 }
 
 fn update_sound_playback_state(query: Query<&Sound>) {
     for sound in &query {
-        if let Some(generator) = &sound.generator {
-            if sound.paused {
-                generator.pause().expect("Failed to pause");
-            } else {
-                generator.play().expect("Failed to play");
-            }
+        let Some(generator) = &sound.generator else {
+            continue;
+        };
+        if sound.paused {
+            generator.pause().expect("Failed to pause");
+        } else {
+            generator.play().expect("Failed to play");
         }
     }
 }
 
-fn remove_sound(mut last_buffer: ResMut<LastAudio>, mut removed: RemovedComponents<Source>) {
-    for entity in removed.iter() {
+fn remove_sound(mut last_buffer: ResMut<LastAudio>, mut removed: RemovedComponents<Sound>) {
+    for entity in removed.read() {
         last_buffer.remove(&entity);
     }
 }
@@ -665,27 +699,24 @@ fn events(
     mut output: EventWriter<SynthizerEvent>,
 ) {
     context.get_events().for_each(|event| {
-        if let Ok(event) = event {
-            let mut matched = false;
-            for (entity, sound) in &sounds {
-                if let Some(generator) = &sound.generator {
-                    if *generator.handle() == event.source {
-                        matched = true;
-                        match event.r#type {
-                            syz::EventType::Finished => {
-                                output.send(SynthizerEvent::Finished(entity));
-                            }
-                            syz::EventType::Looped => {
-                                output.send(SynthizerEvent::Looped(entity));
-                            }
-                            _ => {}
-                        }
-                        break;
+        let Ok(event) = event else {
+            return;
+        };
+        for (entity, sound) in &sounds {
+            let Some(generator) = &sound.generator else {
+                continue;
+            };
+            if *generator.handle() == event.source {
+                match event.r#type {
+                    syz::EventType::Finished => {
+                        output.send(SynthizerEvent::Finished(entity));
                     }
+                    syz::EventType::Looped => {
+                        output.send(SynthizerEvent::Looped(entity));
+                    }
+                    _ => {}
                 }
-            }
-            if !matched {
-                println!("No match");
+                break;
             }
         }
     });
@@ -693,7 +724,7 @@ fn events(
 
 #[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
 pub enum SynthizerSets {
-    First,
+    PreUpdate,
     UpdateHandles,
     UpdateProperties,
     UpdateState,
@@ -718,10 +749,10 @@ pub struct SynthizerPlugin {
 
 impl Plugin for SynthizerPlugin {
     fn build(&self, app: &mut App) {
-        if !app.world.contains_resource::<SynthizerPlugin>() {
+        if !app.world().contains_resource::<SynthizerPlugin>() {
             app.insert_resource(*self);
         }
-        let config = *app.world.get_resource::<SynthizerPlugin>().unwrap();
+        let config = *app.world().get_resource::<SynthizerPlugin>().unwrap();
         let mut syz_config = syz::LibraryConfig::new();
         syz_config.log_level(config.log_level);
         if config.log_to_stderr {
@@ -743,7 +774,7 @@ impl Plugin for SynthizerPlugin {
         };
         context.enable_events().expect("Failed to enable events");
         let context = Context(context);
-        app.add_asset::<Buffer>()
+        app.init_asset::<Buffer>()
             .init_asset_loader::<BufferAssetLoader>()
             .register_type::<DistanceRef>()
             .register_type::<DistanceMax>()
@@ -759,39 +790,45 @@ impl Plugin for SynthizerPlugin {
             .insert_resource(defaults)
             .add_event::<SynthizerEvent>()
             .add_systems(
+                PreUpdate,
                 (sync_config, swap_buffers, change_panner_strategy)
-                    .in_set(SynthizerSets::First)
-                    .in_base_set(CoreSet::PreUpdate),
+                    .in_set(SynthizerSets::PreUpdate),
             )
-            .configure_set(SynthizerSets::First.before(SynthizerSets::UpdateHandles))
             .add_systems(
-                (add_source_handle, add_generator, add_sound_without_source)
-                    .in_base_set(CoreSet::PostUpdate)
+                PostUpdate,
+                (add_sound_without_source, add_source_handle, add_generator)
                     .in_set(SynthizerSets::UpdateHandles),
             )
-            .configure_set(SynthizerSets::UpdateHandles.before(SynthizerSets::UpdateProperties))
-            .add_system(
-                update_sound_properties
-                    .in_base_set(CoreSet::PostUpdate)
-                    .in_set(SynthizerSets::UpdateProperties),
+            .configure_sets(
+                PostUpdate,
+                SynthizerSets::UpdateHandles.before(SynthizerSets::UpdateProperties),
             )
             .add_systems(
+                PostUpdate,
+                update_sound_properties.in_set(SynthizerSets::UpdateProperties),
+            )
+            .add_systems(
+                PostUpdate,
                 (update_listener, update_source_properties)
-                    .in_base_set(CoreSet::PostUpdate)
                     .in_set(SynthizerSets::UpdateProperties)
                     .after(TransformSystem::TransformPropagate),
             )
-            .configure_set(SynthizerSets::UpdateProperties.before(SynthizerSets::UpdateState))
+            .configure_sets(
+                PostUpdate,
+                SynthizerSets::UpdateProperties.before(SynthizerSets::UpdateState),
+            )
             .add_systems(
+                PostUpdate,
                 (update_source_playback_state, update_sound_playback_state)
-                    .in_base_set(CoreSet::PostUpdate)
                     .in_set(SynthizerSets::UpdateState),
             )
-            .configure_set(SynthizerSets::UpdateState.before(SynthizerSets::Last))
+            .configure_sets(
+                PostUpdate,
+                SynthizerSets::UpdateState.before(SynthizerSets::Last),
+            )
             .add_systems(
-                (remove_sound, events)
-                    .in_set(SynthizerSets::Last)
-                    .in_base_set(CoreSet::PostUpdate),
+                PostUpdate,
+                (remove_sound, events).in_set(SynthizerSets::Last),
             );
     }
 }