Release

CHANGELOG.md

@@ -2,6 +2,32 @@
 
 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

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_synthizer"
-version = "0.7.0"
+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]
-bevy = { version = "0.14", 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.14", default-features = true }
+bevy = { version = "0.15", default-features = true }
 
 [package.metadata.release]
 publish = false

examples/buffer.rs

@@ -31,14 +31,10 @@ fn load_and_create(
     if !listeners.is_empty() {
         return;
     }
-    commands.spawn((
+    commands.spawn((Transform::default(), Listener, RotationTimer::default()));
-        TransformBundle::default(),
-        Listener,
-        RotationTimer::default(),
-    ));
     let handle = asset_server.load("footstep.wav");
     commands.spawn((
-        TransformBundle::from(Transform::from_translation(Vec3::new(10., 0., 0.))),
+        Transform::from_translation(Vec3::new(10., 0., 0.)),
         Source::default(),
         Sound {
             audio: handle.into(),

examples/generator.rs

@@ -13,16 +13,12 @@ impl Default for RotationTimer {
 }
 
 fn setup(mut commands: Commands, context: Res<Context>) {
-    commands.spawn((
+    commands.spawn((Transform::default(), Listener, RotationTimer::default()));
-        TransformBundle::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(),

src/lib.rs

@@ -2,9 +2,8 @@
 use std::collections::HashMap;
 
 use bevy::{
-    asset::{io::Reader, AssetLoader, AsyncReadExt, LoadContext},
+    asset::{io::Reader, AssetLoader, LoadContext},
     prelude::*,
-    reflect::TypePath,
     transform::TransformSystem,
 };
 pub use synthizer as syz;
@@ -30,11 +29,11 @@ impl AssetLoader for BufferAssetLoader {
     type Settings = ();
     type Error = BufferAssetLoaderError;
 
-    async fn load<'a>(
+    async fn load(
-        &'a self,
+        &self,
-        reader: &'a mut Reader<'_>,
+        reader: &mut dyn Reader,
-        _settings: &'a (),
+        _settings: &(),
-        _load_context: &'a mut LoadContext<'_>,
+        _load_context: &mut LoadContext<'_>,
     ) -> Result<Self::Asset, Self::Error> {
         let mut bytes = Vec::new();
         reader.read_to_end(&mut bytes).await?;
@@ -156,6 +155,7 @@ pub struct Sound {
     pub gain: f64,
     pub pitch: f64,
     pub looping: bool,
+    pub playback_position: f64,
     pub paused: bool,
     pub generator: Option<syz::Generator>,
 }
@@ -167,6 +167,7 @@ impl Default for Sound {
             gain: 1.,
             pitch: 1.,
             looping: false,
+            playback_position: default(),
             paused: false,
             generator: None,
         }
@@ -229,7 +230,9 @@ fn add_source_handle(
     )>,
 ) {
     for (mut source, panner_strategy, transform, angular_pan, scalar_pan) in &mut query {
-        if source.handle.is_none() {
+        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();
@@ -264,7 +267,6 @@ fn add_source_handle(
         };
         source.handle = Some(handle);
     }
-    }
 }
 
 fn add_generator(
@@ -275,7 +277,9 @@ fn add_generator(
     parents: Query<&Parent>,
 ) {
     for (entity, parent, mut sound) in &mut query {
-        if sound.generator.is_none() {
+        if sound.generator.is_some() {
+            continue;
+        }
         let mut source = if let Ok(s) = sources.get_mut(entity) {
             Some(s)
         } else if parent.is_some() {
@@ -300,6 +304,11 @@ fn add_generator(
                             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
@@ -307,7 +316,9 @@ fn add_generator(
                     }
                     Audio::Generator(generator) => Some(generator.clone()),
                 };
-                    if let Some(generator) = generator {
+                let Some(generator) = generator else {
+                    continue;
+                };
                 assert!(sound.gain >= 0.);
                 generator
                     .gain()
@@ -325,8 +336,6 @@ fn add_generator(
             }
         }
     }
-        }
-    }
 }
 
 fn add_sound_without_source(
@@ -361,6 +370,7 @@ fn swap_buffers(
         if let Some(l) = last_audio.get(&entity) {
             if sound.generator.is_some() && sound.audio != *l {
                 sound.generator = None;
+                sound.playback_position = 0.;
             }
         }
         last_audio.insert(entity, sound.audio.clone());
@@ -382,12 +392,13 @@ fn change_panner_strategy(
         check.push(entity);
     }
     for entity in check.iter() {
-        if let Ok(mut source) = sources.get_mut(*entity) {
+        let Ok(mut source) = sources.get_mut(*entity) else {
+            continue;
+        };
         if source.handle.is_some() {
             source.handle = None;
         }
     }
-    }
 }
 
 fn update_source_properties(
@@ -403,6 +414,7 @@ fn update_source_properties(
         Option<&AngularPan>,
         Option<&ScalarPan>,
         Option<&GlobalTransform>,
+        Option<&mut Sound>,
     )>,
 ) {
     for (
@@ -416,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() {
+        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(transform) = transform {
         if let Some(source) = handle.cast_to::<syz::Source3D>().expect("Failed to cast") {
+            if let Some(transform) = transform {
                 let translation = transform.translation();
+                if !translation.x.is_nan() && !translation.y.is_nan() && !translation.z.is_nan() {
                     source
                         .position()
                         .set((
@@ -434,6 +450,7 @@ fn update_source_properties(
                             translation.z as f64,
                         ))
                         .expect("Failed to set position");
+                }
                 let distance_model = distance_model
                     .cloned()
                     .map(|v| *v)
@@ -462,6 +479,7 @@ 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)
@@ -474,10 +492,9 @@ fn update_source_properties(
                     .closeness_boost()
                     .set(closeness_boost)
                     .expect("Failed to set closeness_boost");
-                    let closeness_boost_distance =
+                let closeness_boost_distance = closeness_boost_distance
-                        closeness_boost_distance.map(|v| **v).unwrap_or_else(|| {
+                    .map(|v| **v)
-                            context.default_closeness_boost_distance().get().unwrap()
+                    .unwrap_or_else(|| context.default_closeness_boost_distance().get().unwrap());
-                        });
                 assert!(closeness_boost_distance >= 0.);
                 source
                     .closeness_boost_distance()
@@ -486,11 +503,11 @@ fn update_source_properties(
             } else {
                 clear_source = true;
             }
-            } else if let Some(angular_pan) = angular_pan {
+        } else if let Some(source) = handle
-                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()
@@ -504,11 +521,11 @@ fn update_source_properties(
             } else {
                 clear_source = true;
             }
-            } else if let Some(scalar_pan) = scalar_pan {
+        } else if let Some(source) = handle
-                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()
@@ -517,9 +534,22 @@ 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.;
             }
         }
     }
@@ -535,7 +565,21 @@ fn update_sound_properties(mut query: Query<&mut Sound>) {
         } = *sound;
         assert!(gain >= 0.);
         assert!(pitch > 0. && pitch <= 2.);
-        if let Some(generator) = sound.generator.as_mut() {
+        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");
+        }
+        let Some(generator) = sound.generator.as_mut() else {
+            continue;
+        };
         generator.gain().set(gain).expect("Failed to set gain");
         generator
             .pitch_bend()
@@ -551,31 +595,32 @@ fn update_sound_properties(mut query: Query<&mut Sound>) {
                 .expect("Failed to set looping");
         }
     }
-    }
 }
 
 fn update_source_playback_state(query: Query<&Source>) {
     for source in &query {
-        if let Some(handle) = &source.handle {
+        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 {
+        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<Sound>) {
@@ -654,9 +699,13 @@ fn events(
     mut output: EventWriter<SynthizerEvent>,
 ) {
     context.get_events().for_each(|event| {
-        if let Ok(event) = event {
+        let Ok(event) = event else {
+            return;
+        };
         for (entity, sound) in &sounds {
-                if let Some(generator) = &sound.generator {
+            let Some(generator) = &sound.generator else {
+                continue;
+            };
             if *generator.handle() == event.source {
                 match event.r#type {
                     syz::EventType::Finished => {
@@ -670,8 +719,6 @@ fn events(
                 break;
             }
         }
-            }
-        }
     });
 }