.gitea/workflows/release.yml

@@ -1,39 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,99 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-## 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
-
-- Only `update_source_properties` and `update_listener` need to run after transform propagation.
-
-## Version 0.3.0 - 2023-04-03
-
-### Features
-
-- [**breaking**] Renamed `SynthizerSystems` to `SynthizerSets`.
-
-### Miscellaneous Tasks
-
-- Restructure system schedule to more idiomatic Bevy 0.10 style.
-
-## Version 0.2.0 - 2023-03-06
-
-### Features
-
-- `Sound` components can now get audio from either buffers or generators.
-
-### Miscellaneous Tasks
-
-- Update to Bevy 0.10.
-
-## Version 0.1.0 - 2022-12-17
-
-### Miscellaneous Tasks
-
-- Initial release.
-
-<!-- generated by git-cliff -->

Cargo.toml

@@ -1,24 +1,16 @@
 [package]
 name = "bevy_synthizer"
-version = "0.9.0"
+version = "0.1.0"
 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"
 edition = "2021"
-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]
-bevy = { version = "0.15", default-features = false, features = ["bevy_asset"] }
+anyhow = "1"
-synthizer = "0.5.6"
+bevy = { version = "0.8", default-features = false, features = ["bevy_asset"] }
-thiserror = "1"
+synthizer = { git = "https://github.com/synthizer/synthizer-rs" }
 
 [dev-dependencies]
-bevy = { version = "0.15", default-features = true }
+bevy = { version = "0.8", default-features = true }
-
-[package.metadata.release]
-publish = false
-push = false
-pre-release-hook = ["git-cliff", "-o", "CHANGELOG.md", "--tag", "{{version}}"]
-pre-release-commit-message = "Release"

cliff.toml

@@ -1,60 +0,0 @@
-# configuration file for git-cliff (0.1.0)
-
-[changelog]
-# changelog header
-header = """
-# Changelog\n
-All notable changes to this project will be documented in this file.\n
-"""
-# template for the changelog body
-# https://tera.netlify.app/docs/#introduction
-body = """
-{% if version %}\
-    ## Version {{ version | trim_start_matches(pat="v") }} - {{ timestamp | date(format="%Y-%m-%d") }}
-{% else %}\
-    ## Unreleased
-{% endif %}\
-{% for group, commits in commits | group_by(attribute="group") %}
-    ### {{ group | upper_first }}
-    {% for commit in commits %}
-        - {% if commit.breaking %}[**breaking**] {% endif %}{{ commit.message | upper_first }}\
-    {% endfor %}
-{% endfor %}\n
-"""
-# remove the leading and trailing whitespace from the template
-trim = true
-# changelog footer
-footer = """
-<!-- generated by git-cliff -->
-"""
-
-[git]
-# parse the commits based on https://www.conventionalcommits.org
-conventional_commits = true
-# filter out the commits that are not conventional
-filter_unconventional = true
-# regex for parsing and grouping commits
-commit_parsers = [
-    { message = "^feat", group = "Features"},
-    { message = "^fix", group = "Bug Fixes"},
-    { message = "^doc", group = "Documentation"},
-    { message = "^perf", group = "Performance"},
-    { message = "^refactor", group = "Refactor"},
-    { message = "^style", group = "Styling"},
-    { message = "^test", group = "Testing"},
-    { message = "^chore\\(release\\): prepare for", skip = true},
-    { message = "^chore", group = "Miscellaneous Tasks"},
-    { body = ".*security", group = "Security"},
-]
-# filter out the commits that are not matched by commit parsers
-filter_commits = false
-# glob pattern for matching git tags
-tag_pattern = "v[0-9]*"
-# regex for skipping tags
-skip_tags = ""
-# regex for ignoring tags
-ignore_tags = ""
-# sort the tags chronologically
-date_order = false
-# sort the commits inside sections by oldest/newest order
-sort_commits = "oldest"

examples/buffer.rs

@@ -1,69 +0,0 @@
-use std::f32;
-
-use bevy::{asset::LoadedFolder, prelude::*};
-use bevy_synthizer::*;
-
-#[derive(Component, Deref, DerefMut)]
-struct RotationTimer(Timer);
-
-impl Default for RotationTimer {
-    fn default() -> Self {
-        Self(Timer::from_seconds(30., TimerMode::Repeating))
-    }
-}
-
-#[derive(Resource, Default, Deref, DerefMut)]
-struct AssetHandles(Handle<LoadedFolder>);
-
-fn setup(asset_server: Res<AssetServer>, mut handles: ResMut<AssetHandles>) {
-    **handles = asset_server.load_folder(".");
-}
-
-fn load_and_create(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    handles: Res<AssetHandles>,
-    listeners: Query<&Listener>,
-) {
-    if !asset_server.is_loaded_with_dependencies(&**handles) {
-        return;
-    }
-    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.fraction();
-        transform.rotation = Quat::from_rotation_z(angle);
-    }
-}
-
-fn main() {
-    App::new()
-        .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_systems(Startup, setup)
-        .add_systems(Update, (load_and_create, rotate_listener))
-        .run();
-}

examples/game.rs

@@ -0,0 +1,79 @@
+use std::f32;
+
+use bevy::{asset::LoadState, prelude::*};
+use bevy_synthizer::*;
+
+#[derive(Component, Deref, DerefMut)]
+struct RotationTimer(Timer);
+
+impl Default for RotationTimer {
+    fn default() -> Self {
+        Self(Timer::from_seconds(30., true))
+    }
+}
+
+#[derive(Default)]
+struct AssetHandles {
+    sounds: Vec<HandleUntyped>,
+    loaded: bool,
+}
+
+fn setup(asset_server: Res<AssetServer>, mut handles: ResMut<AssetHandles>) {
+    handles.sounds = asset_server.load_folder(".").expect("Failed to load sfx");
+}
+
+fn load_and_create(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    mut handles: ResMut<AssetHandles>,
+) {
+    if handles.loaded {
+        return;
+    }
+    handles.loaded = asset_server
+        .get_group_load_state(handles.sounds.iter().map(|handle| handle.id))
+        == LoadState::Loaded;
+    if handles.loaded {
+        commands
+            .spawn_bundle(TransformBundle::default())
+            .insert(Listener)
+            .insert(RotationTimer::default());
+        let handle = handles.sounds[0].clone();
+        let buffer = asset_server.get_handle(handle);
+        commands
+            .spawn_bundle(TransformBundle::from(Transform::from_translation(
+                Vec3::new(10., 0., 0.),
+            )))
+            .insert(Source::default())
+            .insert(Sound {
+                buffer,
+                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();
+        transform.rotation = Quat::from_rotation_z(angle);
+    }
+}
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(SynthizerConfig {
+            default_panner_strategy: Some(bevy_synthizer::syz::PannerStrategy::Hrtf),
+            default_distance_model: Some(bevy_synthizer::syz::DistanceModel::Inverse),
+            ..default()
+        })
+        .add_plugin(SynthizerPlugin)
+        .add_system(bevy::window::close_on_esc)
+        .init_resource::<AssetHandles>()
+        .add_startup_system(setup)
+        .add_system(load_and_create)
+        .add_system(rotate_listener)
+        .run();
+}

examples/generator.rs

@@ -1,52 +0,0 @@
-use std::f32;
-
-use bevy::prelude::*;
-use bevy_synthizer::*;
-
-#[derive(Component, Deref, DerefMut)]
-struct RotationTimer(Timer);
-
-impl Default for RotationTimer {
-    fn default() -> Self {
-        Self(Timer::from_seconds(30., TimerMode::Repeating))
-    }
-}
-
-fn setup(mut commands: Commands, context: Res<Context>) {
-    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((
-        Transform::from_translation(Vec3::new(10., 0., 0.)),
-        Source::default(),
-        Sound {
-            audio: generator.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.fraction();
-        transform.rotation = Quat::from_rotation_z(angle);
-    }
-}
-
-fn main() {
-    App::new()
-        .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,43 +2,40 @@
 use std::collections::HashMap;
 
 use bevy::{
-    asset::{io::Reader, AssetLoader, LoadContext},
+    asset::{AssetLoader, LoadContext, LoadedAsset},
     prelude::*,
+    reflect::TypeUuid,
     transform::TransformSystem,
+    utils::BoxedFuture,
 };
 pub use synthizer as syz;
-use thiserror::Error;
 
-#[derive(Asset, Clone, Debug, Deref, DerefMut, PartialEq, Eq, TypePath)]
+#[derive(Clone, Debug, Deref, DerefMut, PartialEq, TypeUuid)]
+#[uuid = "6b6b533a-bb1f-11ec-bda2-00155d8fdde9"]
 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 {
-    type Asset = Buffer;
+    fn load<'a>(
-    type Settings = ();
+        &'a self,
-    type Error = BufferAssetLoaderError;
+        bytes: &'a [u8],
-
+        load_context: &'a mut LoadContext,
-    async fn load(
+    ) -> BoxedFuture<'a, Result<(), anyhow::Error>> {
-        &self,
+        Box::pin(async move {
-        reader: &mut dyn Reader,
+            let buffer: Option<Buffer> =
-        _settings: &(),
+                match load_context.path().extension().unwrap().to_str().unwrap() {
-        _load_context: &mut LoadContext<'_>,
+                    "flac" | "mp3" | "wav" => {
-    ) -> Result<Self::Asset, Self::Error> {
+                        syz::Buffer::from_encoded_data(bytes).map(Buffer).ok()
-        let mut bytes = Vec::new();
+                    }
-        reader.read_to_end(&mut bytes).await?;
+                    _ => None,
-        let buffer = syz::Buffer::from_encoded_data(&bytes).map(Buffer)?;
+                };
-        Ok(buffer)
+            if let Some(buffer) = buffer {
+                load_context.set_default_asset(LoadedAsset::new(buffer));
+            }
+            Ok(())
+        })
     }
 
     fn extensions(&self) -> &[&str] {
@@ -46,9 +43,6 @@ impl AssetLoader for BufferAssetLoader {
     }
 }
 
-#[derive(Resource, Clone, Debug, Deref, DerefMut)]
-pub struct Context(syz::Context);
-
 #[derive(Component, Clone, Debug, Reflect)]
 #[reflect(Component)]
 pub struct Source {
@@ -69,6 +63,7 @@ impl Default for Source {
 }
 
 #[derive(Component, Clone, Copy, Debug, Deref, DerefMut)]
+// #[reflect(Component)]
 pub struct PannerStrategy(pub syz::PannerStrategy);
 
 impl Default for PannerStrategy {
@@ -125,56 +120,33 @@ impl ScalarPan {
     }
 }
 
-#[derive(Component, Clone, Debug, PartialEq, Eq)]
+#[derive(Component, Clone, Debug, Reflect)]
-pub enum Audio {
+#[reflect(Component)]
-    Buffer(Handle<Buffer>),
-    Generator(syz::Generator),
-}
-
-impl Default for Audio {
-    fn default() -> Self {
-        Self::Buffer(default())
-    }
-}
-
-impl From<Handle<Buffer>> for Audio {
-    fn from(value: Handle<Buffer>) -> Self {
-        Audio::Buffer(value)
-    }
-}
-
-impl From<syz::Generator> for Audio {
-    fn from(value: syz::Generator) -> Self {
-        Self::Generator(value)
-    }
-}
-
-#[derive(Component, Clone, Debug)]
 pub struct Sound {
-    pub audio: Audio,
+    pub buffer: Handle<Buffer>,
     pub gain: f64,
     pub pitch: f64,
     pub looping: bool,
-    pub playback_position: f64,
     pub paused: bool,
-    pub generator: Option<syz::Generator>,
+    pub restart: bool,
+    #[reflect(ignore)]
+    pub generator: Option<syz::BufferGenerator>,
 }
 
 impl Default for Sound {
     fn default() -> Self {
         Self {
-            audio: default(),
+            buffer: default(),
             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),
@@ -185,7 +157,7 @@ pub enum SynthizerEvent {
 pub struct Listener;
 
 fn update_listener(
-    context: ResMut<Context>,
+    context: ResMut<syz::Context>,
     listener: Query<Option<&GlobalTransform>, With<Listener>>,
 ) {
     if let Ok(transform) = listener.get_single() {
@@ -220,7 +192,7 @@ fn update_listener(
 }
 
 fn add_source_handle(
-    context: Res<Context>,
+    context: Res<syz::Context>,
     mut query: Query<(
         &mut Source,
         Option<&PannerStrategy>,
@@ -230,9 +202,7 @@ fn add_source_handle(
     )>,
 ) {
     for (mut source, panner_strategy, transform, angular_pan, scalar_pan) in &mut query {
-        if source.handle.is_some() {
+        if source.handle.is_none() {
-            continue;
-        }
             let panner_strategy = panner_strategy.cloned().unwrap_or_default();
             let handle: syz::Source = if let Some(transform) = transform {
                 let translation = transform.translation();
@@ -267,23 +237,23 @@ fn add_source_handle(
             };
             source.handle = Some(handle);
         }
+    }
 }
 
 fn add_generator(
-    context: Res<Context>,
+    context: Res<syz::Context>,
     buffers: Res<Assets<Buffer>>,
     mut query: Query<(Entity, Option<&Parent>, &mut Sound)>,
     mut sources: Query<&mut Source>,
     parents: Query<&Parent>,
 ) {
     for (entity, parent, mut sound) in &mut query {
-        if sound.generator.is_some() {
+        if sound.generator.is_none() {
-            continue;
+            if let Some(b) = buffers.get(&sound.buffer) {
-        }
                 let mut source = if let Ok(s) = sources.get_mut(entity) {
                     Some(s)
-        } else if parent.is_some() {
+                } else if let Some(parent) = parent {
-            let mut parent = parent;
+                    let mut parent: Option<&Parent> = Some(parent);
                     let mut target = None;
                     while let Some(p) = parent {
                         if sources.get(**p).is_ok() {
@@ -298,111 +268,104 @@ fn add_generator(
                 };
                 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()),
-                };
-                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())
+                            .add_generator(&generator)
                             .expect("Unable to add generator");
                         sound.generator = Some(generator);
                     }
                 }
             }
+        }
+    }
 }
 
 fn add_sound_without_source(
     mut commands: Commands,
-    query: Query<Entity, (Added<Sound>, Without<Source>)>,
+    query: Query<
-    parents: Query<(&Parent, Option<&Source>)>,
+        (Entity, Option<&Parent>, Option<&GlobalTransform>),
+        (Added<Sound>, Without<Source>),
+    >,
+    parents: Query<&Parent>,
+    sources: Query<&Source>,
+    transforms: Query<&GlobalTransform>,
 ) {
-    for entity in &query {
+    for (entity, parent, transform) in &query {
-        let mut has_source = false;
+        let should_check_for_transform = transform.is_none();
-        let mut target = entity;
+        let mut has_transform = false;
-        while let Ok((parent, source)) = parents.get(target) {
+        let source = if let Some(parent) = parent {
-            if source.is_some() {
+            if should_check_for_transform {
-                has_source = true;
+                has_transform = transforms.get(**parent).is_ok();
+            }
+            let mut target = None;
+            let mut parent: Option<&Parent> = Some(parent);
+            while let Some(p) = parent {
+                if should_check_for_transform && !has_transform {
+                    has_transform = transforms.get(**p).is_ok();
+                }
+                if sources.get(**p).is_ok() {
+                    target = Some(**p);
                     break;
                 }
-            target = **parent;
+                parent = parents.get(**p).ok();
+            }
+            target.map(|v| sources.get(v).unwrap())
+        } else {
+            None
+        };
+        if source.is_none() {
+            let id = commands.entity(entity).insert(Source::default()).id();
+            if has_transform {
+                commands
+                    .entity(id)
+                    .insert_bundle(TransformBundle::default());
             }
-        if !has_source {
-            commands.entity(entity).insert(Source::default());
         }
     }
 }
 
-#[derive(Resource, Default, Deref, DerefMut)]
+#[derive(Default, Deref, DerefMut)]
-struct LastAudio(HashMap<Entity, Audio>);
+struct LastBuffer(HashMap<Entity, Handle<Buffer>>);
 
 fn swap_buffers(
-    mut last_audio: ResMut<LastAudio>,
+    mut last_buffer: ResMut<LastBuffer>,
     mut query: Query<(Entity, &mut Sound), Changed<Sound>>,
 ) {
     for (entity, mut sound) in &mut query {
-        if let Some(l) = last_audio.get(&entity) {
+        if let Some(l) = last_buffer.get(&entity) {
-            if sound.generator.is_some() && sound.audio != *l {
+            if sound.buffer != *l {
                 sound.generator = None;
-                sound.playback_position = 0.;
             }
         }
-        last_audio.insert(entity, sound.audio.clone());
+        last_buffer.insert(entity, sound.buffer.clone());
     }
 }
 
 fn change_panner_strategy(
-    changed: Query<(Entity, Ref<PannerStrategy>)>,
+    changed: Query<Entity, Changed<PannerStrategy>>,
-    mut removed: RemovedComponents<PannerStrategy>,
+    removed: RemovedComponents<PannerStrategy>,
     mut sources: Query<&mut Source>,
 ) {
     let mut check = vec![];
-    for (entity, change) in &changed {
+    for entity in &changed {
-        if !change.is_added() && change.is_changed() {
         check.push(entity);
     }
-    }
+    for entity in removed.iter() {
-    for entity in removed.read() {
         check.push(entity);
     }
     for entity in check.iter() {
-        let Ok(mut source) = sources.get_mut(*entity) else {
+        if let Ok(mut source) = sources.get_mut(*entity) {
-            continue;
-        };
             if source.handle.is_some() {
                 source.handle = None;
             }
         }
+    }
 }
 
 fn update_source_properties(
-    context: Res<Context>,
+    context: Res<syz::Context>,
     mut query: Query<(
         &mut Source,
         Option<&DistanceModel>,
@@ -414,7 +377,6 @@ fn update_source_properties(
         Option<&AngularPan>,
         Option<&ScalarPan>,
         Option<&GlobalTransform>,
-        Option<&mut Sound>,
     )>,
 ) {
     for (
@@ -428,18 +390,15 @@ fn update_source_properties(
         angular_pan,
         scalar_pan,
         transform,
-        sound,
     ) in &mut query
     {
         let Source { gain, .. } = *source;
         assert!(gain >= 0.);
-        let Some(handle) = source.handle.as_mut() else {
+        if let Some(handle) = source.handle.as_mut() {
-            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>().unwrap() {
                     let translation = transform.translation();
                     source
                         .position()
@@ -477,7 +436,6 @@ fn update_source_properties(
                         .map(|v| **v)
                         .unwrap_or_else(|| context.default_rolloff().get().unwrap());
                     assert!(rolloff >= 0.);
-                assert!(rolloff >= 0.);
                     source
                         .rolloff()
                         .set(rolloff)
@@ -490,9 +448,10 @@ fn update_source_properties(
                         .closeness_boost()
                         .set(closeness_boost)
                         .expect("Failed to set closeness_boost");
-                let closeness_boost_distance = closeness_boost_distance
+                    let closeness_boost_distance =
-                    .map(|v| **v)
+                        closeness_boost_distance.map(|v| **v).unwrap_or_else(|| {
-                    .unwrap_or_else(|| context.default_closeness_boost_distance().get().unwrap());
+                            context.default_closeness_boost_distance().get().unwrap()
+                        });
                     assert!(closeness_boost_distance >= 0.);
                     source
                         .closeness_boost_distance()
@@ -501,11 +460,8 @@ fn update_source_properties(
                 } else {
                     clear_source = true;
                 }
-        } else if let Some(source) = handle
+            } else if let Some(angular_pan) = angular_pan {
-            .cast_to::<syz::AngularPannedSource>()
+                if let Some(source) = handle.cast_to::<syz::AngularPannedSource>().unwrap() {
-            .expect("Failed to cast")
-        {
-            if let Some(angular_pan) = angular_pan {
                     assert!(angular_pan.azimuth >= 0. && angular_pan.azimuth <= 360.);
                     source
                         .azimuth()
@@ -519,11 +475,8 @@ fn update_source_properties(
                 } else {
                     clear_source = true;
                 }
-        } else if let Some(source) = handle
+            } else if let Some(scalar_pan) = scalar_pan {
-            .cast_to::<syz::ScalarPannedSource>()
+                if let Some(source) = handle.cast_to::<syz::ScalarPannedSource>().unwrap() {
-            .expect("Failed to cast")
-        {
-            if let Some(scalar_pan) = scalar_pan {
                     assert!(**scalar_pan >= -1. && **scalar_pan <= 1.);
                     source
                         .panning_scalar()
@@ -532,22 +485,9 @@ fn update_source_properties(
                 } 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.;
             }
         }
     }
@@ -562,31 +502,22 @@ fn update_sound_properties(mut query: Query<&mut Sound>) {
             ..
         } = *sound;
         assert!(gain >= 0.);
-        assert!(pitch > 0. && pitch <= 2.);
+        assert!(pitch >= 0.);
-        let Some(generator) = &sound.generator else {
+        if sound.restart {
-            continue;
+            if let Some(generator) = sound.generator.as_mut() {
-        };
+                generator
-        if let Some(generator) = generator
-            .cast_to::<syz::BufferGenerator>()
-            .expect("Failed to cast")
-        {
-            sound.playback_position = generator
                     .playback_position()
-                .get()
+                    .set(0.)
-                .expect("Failed to getplayback position");
+                    .expect("Failed to restart");
             }
-        let Some(generator) = sound.generator.as_mut() else {
+            sound.restart = false;
-            continue;
+        }
-        };
+        if let Some(generator) = sound.generator.as_mut() {
             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
                 .looping()
                 .set(looping)
@@ -597,37 +528,46 @@ fn update_sound_properties(mut query: Query<&mut Sound>) {
 
 fn update_source_playback_state(query: Query<&Source>) {
     for source in &query {
-        let Some(handle) = &source.handle else {
+        if let Some(handle) = &source.handle {
-            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 {
-        let Some(generator) = &sound.generator else {
+        if let Some(generator) = &sound.generator {
-            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<Sound>) {
+fn remove_sound(mut last_buffer: ResMut<LastBuffer>, removed: RemovedComponents<Source>) {
-    for entity in removed.read() {
+    for entity in removed.iter() {
         last_buffer.remove(&entity);
     }
 }
 
-#[derive(Resource, Debug)]
+#[derive(Clone, Copy, Default, Debug)]
+pub struct SynthizerConfig {
+    pub default_panner_strategy: Option<syz::PannerStrategy>,
+    pub default_distance_model: Option<syz::DistanceModel>,
+    pub default_distance_ref: Option<f64>,
+    pub default_distance_max: Option<f64>,
+    pub default_rolloff: Option<f64>,
+    pub default_closeness_boost: Option<f64>,
+    pub default_closeness_boost_distance: Option<f64>,
+}
+
+#[derive(Debug)]
 pub struct SynthizerDefaults {
     pub panner_strategy: syz::PannerStrategy,
     pub distance_model: syz::DistanceModel,
@@ -639,8 +579,8 @@ pub struct SynthizerDefaults {
 }
 
 fn sync_config(
-    context: Res<Context>,
+    context: Res<syz::Context>,
-    config: Res<SynthizerPlugin>,
+    config: Res<SynthizerConfig>,
     defaults: Res<SynthizerDefaults>,
 ) {
     if config.is_changed() {
@@ -692,18 +632,14 @@ fn sync_config(
 }
 
 fn events(
-    context: Res<Context>,
+    context: Res<syz::Context>,
     sounds: Query<(Entity, &Sound)>,
     mut output: EventWriter<SynthizerEvent>,
 ) {
     context.get_events().for_each(|event| {
-        let Ok(event) = event else {
+        if let Ok(event) = event {
-            return;
-        };
             for (entity, sound) in &sounds {
-            let Some(generator) = &sound.generator else {
+                if let Some(generator) = &sound.generator {
-                continue;
-            };
                     if *generator.handle() == event.source {
                         match event.r#type {
                             syz::EventType::Finished => {
@@ -717,50 +653,27 @@ fn events(
                         break;
                     }
                 }
+            }
+        }
     });
 }
 
-#[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
+#[derive(SystemLabel, Clone, Hash, Debug, PartialEq, Eq)]
-pub enum SynthizerSets {
+pub enum SynthizerSystems {
-    PreUpdate,
     UpdateHandles,
     UpdateProperties,
     UpdateState,
-    Last,
 }
 
-#[derive(Resource)]
+pub struct SynthizerPlugin;
-struct InitializationGuard(syz::InitializationGuard);
-
-#[derive(Resource, Clone, Copy, Default, Debug)]
-pub struct SynthizerPlugin {
-    pub default_panner_strategy: Option<syz::PannerStrategy>,
-    pub default_distance_model: Option<syz::DistanceModel>,
-    pub default_distance_ref: Option<f64>,
-    pub default_distance_max: Option<f64>,
-    pub default_rolloff: Option<f64>,
-    pub default_closeness_boost: Option<f64>,
-    pub default_closeness_boost_distance: Option<f64>,
-    pub log_level: syz::LogLevel,
-    pub log_to_stderr: bool,
-}
 
 impl Plugin for SynthizerPlugin {
     fn build(&self, app: &mut App) {
-        if !app.world().contains_resource::<SynthizerPlugin>() {
+        let guard = syz::initialize().expect("Failed to initialize Synthizer");
-            app.insert_resource(*self);
-        }
-        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 {
-            syz_config.log_to_stderr();
-        }
-        let guard = syz_config
-            .initialize()
-            .expect("Failed to initialize Synthizer");
-        let guard = InitializationGuard(guard);
         let context = syz::Context::new().expect("Failed to create Synthizer context");
+        if !app.world.contains_resource::<SynthizerConfig>() {
+            app.insert_resource(SynthizerConfig::default());
+        }
         let defaults = SynthizerDefaults {
             panner_strategy: context.default_panner_strategy().get().unwrap(),
             distance_model: context.default_distance_model().get().unwrap(),
@@ -771,62 +684,70 @@ impl Plugin for SynthizerPlugin {
             closeness_boost_distance: context.default_closeness_boost_distance().get().unwrap(),
         };
         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>()
-            .register_type::<Rolloff>()
-            .register_type::<ClosenessBoostDistance>()
-            .register_type::<AngularPan>()
-            .register_type::<ScalarPan>()
-            .register_type::<Source>()
             .register_type::<Listener>()
             .insert_resource(guard)
             .insert_resource(context)
-            .init_resource::<LastAudio>()
+            .init_resource::<LastBuffer>()
             .insert_resource(defaults)
             .add_event::<SynthizerEvent>()
-            .add_systems(
+            .add_system_to_stage(CoreStage::PreUpdate, sync_config)
-                PreUpdate,
+            .add_system_to_stage(
-                (sync_config, swap_buffers, change_panner_strategy)
+                CoreStage::PostUpdate,
-                    .in_set(SynthizerSets::PreUpdate),
+                swap_buffers.before(SynthizerSystems::UpdateHandles),
             )
-            .add_systems(
+            .add_system_to_stage(
-                PostUpdate,
+                CoreStage::PostUpdate,
-                (add_sound_without_source, add_source_handle, add_generator)
+                change_panner_strategy.before(SynthizerSystems::UpdateHandles),
-                    .in_set(SynthizerSets::UpdateHandles),
             )
-            .configure_sets(
+            .add_system_to_stage(
-                PostUpdate,
+                CoreStage::PostUpdate,
-                SynthizerSets::UpdateHandles.before(SynthizerSets::UpdateProperties),
+                add_source_handle
+                    .label(SynthizerSystems::UpdateHandles)
+                    .before(SynthizerSystems::UpdateProperties),
             )
-            .add_systems(
+            .add_system_to_stage(
-                PostUpdate,
+                CoreStage::PostUpdate,
-                update_sound_properties.in_set(SynthizerSets::UpdateProperties),
+                add_generator
+                    .label(SynthizerSystems::UpdateHandles)
+                    .before(SynthizerSystems::UpdateProperties),
             )
-            .add_systems(
+            .add_system_to_stage(
-                PostUpdate,
+                CoreStage::PostUpdate,
-                (update_listener, update_source_properties)
+                add_sound_without_source
-                    .in_set(SynthizerSets::UpdateProperties)
+                    .label(SynthizerSystems::UpdateHandles)
-                    .after(TransformSystem::TransformPropagate),
+                    .before(SynthizerSystems::UpdateProperties),
             )
-            .configure_sets(
+            .add_system_to_stage(
-                PostUpdate,
+                CoreStage::PostUpdate,
-                SynthizerSets::UpdateProperties.before(SynthizerSets::UpdateState),
+                update_listener
+                    .label(SynthizerSystems::UpdateProperties)
+                    .after(TransformSystem::TransformPropagate)
+                    .before(SynthizerSystems::UpdateState),
             )
-            .add_systems(
+            .add_system_to_stage(
-                PostUpdate,
+                CoreStage::PostUpdate,
-                (update_source_playback_state, update_sound_playback_state)
+                update_source_properties
-                    .in_set(SynthizerSets::UpdateState),
+                    .label(SynthizerSystems::UpdateProperties)
+                    .after(TransformSystem::TransformPropagate)
+                    .before(SynthizerSystems::UpdateState),
             )
-            .configure_sets(
+            .add_system_to_stage(
-                PostUpdate,
+                CoreStage::PostUpdate,
-                SynthizerSets::UpdateState.before(SynthizerSets::Last),
+                update_sound_properties
+                    .label(SynthizerSystems::UpdateProperties)
+                    .before(SynthizerSystems::UpdateState),
             )
-            .add_systems(
+            .add_system_to_stage(
-                PostUpdate,
+                CoreStage::PostUpdate,
-                (remove_sound, events).in_set(SynthizerSets::Last),
+                update_source_playback_state.label(SynthizerSystems::UpdateState),
-            );
+            )
+            .add_system_to_stage(
+                CoreStage::PostUpdate,
+                update_sound_playback_state.label(SynthizerSystems::UpdateState),
+            )
+            .add_system_to_stage(CoreStage::PostUpdate, remove_sound)
+            .add_system_to_stage(CoreStage::PreUpdate, events);
     }
 }