Compare commits

..

No commits in common. "main" and "c945c8b1ba4bda8f601da07dcdfea6935ac17319" have entirely different histories.

10 changed files with 360 additions and 990 deletions

View File

@ -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 }}

View File

@ -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

View File

@ -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

View File

@ -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 -->

View File

@ -1,24 +1,16 @@
[package] [package]
name = "bevy_synthizer" name = "bevy_synthizer"
version = "0.9.0" version = "0.1.0"
authors = ["Nolan Darilek <nolan@thewordnerd.info>"] 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" license = "MIT OR Apache-2.0"
edition = "2021" 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 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies] [dependencies]
bevy = { version = "0.15", default-features = false, features = ["bevy_asset"] } anyhow = "1"
synthizer = "0.5.6" bevy = { version = "0.7", default-features = false }
thiserror = "1" synthizer = "0.4"
[dev-dependencies] [dev-dependencies]
bevy = { version = "0.15", default-features = true } bevy = { version = "0.7", 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"

View File

@ -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"

View File

@ -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();
}

77
examples/game.rs Normal file
View File

@ -0,0 +1,77 @@
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()
.insert(Listener)
.insert(Transform::default())
.insert(RotationTimer::default());
let handle = handles.sounds[0].clone();
let buffer = asset_server.get_handle(handle);
commands
.spawn()
.insert(Transform::from_translation(Vec3::new(45., 0., 0.)))
.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()
})
.add_plugin(SynthizerPlugin)
.add_system(bevy::input::system::exit_on_esc_system)
.init_resource::<AssetHandles>()
.add_startup_system(setup)
.add_system(load_and_create)
.add_system(rotate_listener)
.run();
}

View File

@ -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();
}

View File

@ -2,43 +2,40 @@
use std::collections::HashMap; use std::collections::HashMap;
use bevy::{ use bevy::{
asset::{io::Reader, AssetLoader, LoadContext}, asset::{AssetLoader, LoadContext, LoadedAsset},
prelude::*, prelude::*,
reflect::TypeUuid,
transform::TransformSystem, transform::TransformSystem,
utils::BoxedFuture,
}; };
pub use synthizer as syz; pub use synthizer as syz;
use thiserror::Error;
#[derive(Asset, Clone, Debug, Deref, DerefMut, PartialEq, Eq, TypePath)] #[derive(Clone, Deref, DerefMut, PartialEq, TypeUuid)]
#[uuid = "6b6b533a-bb1f-11ec-bda2-00155d8fdde9"]
pub struct Buffer(syz::Buffer); pub struct Buffer(syz::Buffer);
#[derive(Clone, Copy, Debug, Default)] #[derive(Clone, Copy, Debug, Default)]
struct BufferAssetLoader; 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 { 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] { fn extensions(&self) -> &[&str] {
@ -46,59 +43,58 @@ impl AssetLoader for BufferAssetLoader {
} }
} }
#[derive(Resource, Clone, Debug, Deref, DerefMut)]
pub struct Context(syz::Context);
#[derive(Component, Clone, Debug, Reflect)] #[derive(Component, Clone, Debug, Reflect)]
#[reflect(Component)] #[reflect(Component)]
pub struct Source { pub struct Sound {
pub buffer: Handle<Buffer>,
pub gain: f64, pub gain: f64,
pub pitch: f64,
pub looping: bool,
pub paused: bool, pub paused: bool,
pub restart: bool,
#[reflect(ignore)] #[reflect(ignore)]
pub handle: Option<syz::Source>, pub source: Option<syz::Source>,
#[reflect(ignore)]
pub generator: Option<syz::BufferGenerator>,
} }
impl Default for Source { impl Default for Sound {
fn default() -> Self { fn default() -> Self {
Self { Self {
buffer: Default::default(),
gain: 1., gain: 1.,
pitch: 1.,
looping: false,
paused: false, paused: false,
handle: None, restart: false,
source: None,
generator: None,
} }
} }
} }
#[derive(Component, Clone, Copy, Debug, Deref, DerefMut)] #[derive(Component, Clone, Copy, Debug, Deref, DerefMut)]
pub struct PannerStrategy(pub syz::PannerStrategy); pub struct DistanceModel(syz::DistanceModel);
impl Default for PannerStrategy {
fn default() -> Self {
Self(syz::PannerStrategy::Delegate)
}
}
#[derive(Component, Clone, Copy, Debug, Deref, DerefMut)]
pub struct DistanceModel(pub syz::DistanceModel);
#[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)] #[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)]
#[reflect(Component)] #[reflect(Component)]
pub struct DistanceRef(pub f64); pub struct DistanceRef(f64);
#[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)] #[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)]
#[reflect(Component)] #[reflect(Component)]
pub struct DistanceMax(pub f64); pub struct DistanceMax(f64);
#[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)] #[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)]
#[reflect(Component)] #[reflect(Component)]
pub struct Rolloff(pub f64); pub struct Rolloff(f64);
#[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)] #[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)]
#[reflect(Component)] #[reflect(Component)]
pub struct ClosenessBoost(pub f64); pub struct ClosenessBoost(f64);
#[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)] #[derive(Component, Clone, Copy, Debug, Default, Deref, DerefMut, Reflect)]
#[reflect(Component)] #[reflect(Component)]
pub struct ClosenessBoostDistance(pub f64); pub struct ClosenessBoostDistance(f64);
#[derive(Component, Clone, Copy, Debug, Default, Reflect)] #[derive(Component, Clone, Copy, Debug, Default, Reflect)]
#[reflect(Component)] #[reflect(Component)]
@ -116,295 +112,77 @@ impl ScalarPan {
Self(-1.) Self(-1.)
} }
pub fn center() -> Self {
Self(0.)
}
pub fn right() -> Self { pub fn right() -> Self {
Self(1.) Self(1.)
} }
} }
#[derive(Component, Clone, Debug, PartialEq, Eq)]
pub enum Audio {
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 gain: f64,
pub pitch: f64,
pub looping: bool,
pub playback_position: f64,
pub paused: bool,
pub generator: Option<syz::Generator>,
}
impl Default for Sound {
fn default() -> Self {
Self {
audio: default(),
gain: 1.,
pitch: 1.,
looping: false,
playback_position: default(),
paused: false,
generator: None,
}
}
}
#[derive(Event, Debug)]
pub enum SynthizerEvent {
Finished(Entity),
Looped(Entity),
}
#[derive(Component, Clone, Copy, Debug, Default, Reflect)] #[derive(Component, Clone, Copy, Debug, Default, Reflect)]
#[reflect(Component)] #[reflect(Component)]
pub struct Listener; pub struct Listener;
fn update_listener( pub fn update_listener(
context: ResMut<Context>, context: ResMut<syz::Context>,
listener: Query<Option<&GlobalTransform>, With<Listener>>, listener: Query<(Option<&Transform>, Option<&GlobalTransform>), With<Listener>>,
) { ) {
if let Ok(transform) = listener.get_single() { if let Ok((transform, global_transform)) = listener.get_single() {
let transform: Transform = transform let transform: Option<Transform> = global_transform
.map(|v| { .map(|v| {
let transform: Transform = (*v).into(); let transform: Transform = (*v).into();
transform transform
}) })
.unwrap_or_default(); .or_else(|| transform.cloned());
if let Some(transform) = transform {
let look = transform.local_x(); let look = transform.local_x();
let up = transform.local_z(); let up = transform.local_z();
context if let Err(e) = context.position().set((
.position()
.set((
transform.translation.x as f64, transform.translation.x as f64,
transform.translation.y as f64, transform.translation.y as f64,
transform.translation.z as f64, transform.translation.z as f64,
)) )) {
.expect("Failed to set listener position"); error!("Error setting listener position: {:?}", e);
context }
.orientation() if let Err(e) = context.orientation().set((
.set((
look.x as f64, look.x as f64,
look.y as f64, look.y as f64,
look.z as f64, look.z as f64,
up.x as f64, up.x as f64,
up.y as f64, up.y as f64,
up.z as f64, up.z as f64,
)) )) {
.expect("Failed to set listener orientation"); error!("Error setting listener orientation: {:?}", e);
} }
}
fn add_source_handle(
context: Res<Context>,
mut query: Query<(
&mut Source,
Option<&PannerStrategy>,
Option<&GlobalTransform>,
Option<&AngularPan>,
Option<&ScalarPan>,
)>,
) {
for (mut source, panner_strategy, transform, angular_pan, scalar_pan) in &mut query {
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 { } else {
syz::DirectSource::new(&context) context.position().set((0., 0., 0.)).ok();
.expect("Failed to create source") context.orientation().set((0., 0., 1., 0., 1., 0.)).ok();
.into()
};
source.handle = Some(handle);
} }
}
fn add_generator(
context: Res<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() {
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;
}
parent = parents.get(**p).ok();
}
target.map(|v| sources.get_mut(v).unwrap())
} else { } else {
None context.position().set((0., 0., 0.)).ok();
}; context.orientation().set((0., 0., 1., 0., 1., 0.)).ok();
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())
.expect("Unable to add generator");
sound.generator = Some(generator);
}
}
} }
} }
fn add_sound_without_source( #[derive(Default, Deref, DerefMut)]
mut commands: Commands, struct LastBuffer(HashMap<Entity, Handle<Buffer>>);
query: Query<Entity, (Added<Sound>, Without<Source>)>,
parents: Query<(&Parent, Option<&Source>)>,
) {
for entity in &query {
let mut has_source = false;
let mut target = entity;
while let Ok((parent, source)) = parents.get(target) {
if source.is_some() {
has_source = true;
break;
}
target = **parent;
}
if !has_source {
commands.entity(entity).insert(Source::default());
}
}
}
#[derive(Resource, Default, Deref, DerefMut)] fn swap_buffers(mut last_buffer: ResMut<LastBuffer>, mut query: Query<(Entity, &mut Sound)>) {
struct LastAudio(HashMap<Entity, Audio>); for (entity, mut sound) in query.iter_mut() {
let buffer = sound.buffer.clone();
fn swap_buffers( if let Some(l) = last_buffer.get(&entity) {
mut last_audio: ResMut<LastAudio>, if buffer != *l {
mut query: Query<(Entity, &mut Sound), Changed<Sound>>, sound.source = None;
) {
for (entity, mut sound) in &mut query {
if let Some(l) = last_audio.get(&entity) {
if sound.generator.is_some() && sound.audio != *l {
sound.generator = None; sound.generator = None;
sound.playback_position = 0.;
} }
} }
last_audio.insert(entity, sound.audio.clone()); last_buffer.insert(entity, buffer);
} }
} }
fn change_panner_strategy( pub fn update_sound_properties(
changed: Query<(Entity, Ref<PannerStrategy>)>, context: Res<syz::Context>,
mut removed: RemovedComponents<PannerStrategy>, buffers: Res<Assets<Buffer>>,
mut sources: Query<&mut Source>,
) {
let mut check = vec![];
for (entity, change) in &changed {
if !change.is_added() && change.is_changed() {
check.push(entity);
}
}
for entity in removed.read() {
check.push(entity);
}
for entity in check.iter() {
let Ok(mut source) = sources.get_mut(*entity) else {
continue;
};
if source.handle.is_some() {
source.handle = None;
}
}
}
fn update_source_properties(
context: Res<Context>,
mut query: Query<( mut query: Query<(
&mut Source, &mut Sound,
Option<&DistanceModel>, Option<&DistanceModel>,
Option<&DistanceRef>, Option<&DistanceRef>,
Option<&DistanceMax>, Option<&DistanceMax>,
@ -413,12 +191,12 @@ fn update_source_properties(
Option<&ClosenessBoostDistance>, Option<&ClosenessBoostDistance>,
Option<&AngularPan>, Option<&AngularPan>,
Option<&ScalarPan>, Option<&ScalarPan>,
Option<&Transform>,
Option<&GlobalTransform>, Option<&GlobalTransform>,
Option<&mut Sound>,
)>, )>,
) { ) {
for ( for (
mut source, mut sound,
distance_model, distance_model,
distance_ref, distance_ref,
distance_max, distance_max,
@ -428,19 +206,77 @@ fn update_source_properties(
angular_pan, angular_pan,
scalar_pan, scalar_pan,
transform, transform,
sound, global_transform,
) in &mut query ) in query.iter_mut()
{ {
let Source { gain, .. } = *source; let Sound {
assert!(gain >= 0.); gain,
let Some(handle) = source.handle.as_mut() else { pitch,
continue; looping,
}; ..
handle.gain().set(gain).expect("Failed to set gain"); } = *sound;
if sound.restart {
if let Some(generator) = sound.generator.as_mut() {
generator
.playback_position()
.set(0.)
.expect("Failed to restart");
}
sound.restart = false;
}
if sound.generator.is_none() {
let generator =
syz::BufferGenerator::new(&context).expect("Failed to create generator");
sound.generator = Some(generator);
}
let translation = global_transform
.map(|v| v.translation)
.or_else(|| transform.map(|v| v.translation));
if sound.source.is_none() {
if let Some(b) = buffers.get(sound.buffer.clone()) {
if let Some(generator) = sound.generator.as_mut() {
generator.buffer().set(&**b).expect("Unable to set buffer");
if let Some(translation) = translation {
let source = syz::Source3D::new(
&context,
syz::PannerStrategy::Delegate,
(
translation.x as f64,
translation.y as f64,
translation.z as f64,
),
)
.expect("Failed to create source");
source
.add_generator(generator)
.expect("Unable to add generator");
sound.source = Some(source.into());
} else {
let source =
syz::DirectSource::new(&context).expect("Failed to create source");
source
.add_generator(generator)
.expect("Failed to add generator");
sound.source = Some(source.into());
}
}
}
}
if let Some(generator) = sound.generator.as_mut() {
generator
.pitch_bend()
.set(pitch)
.expect("Failed to set pitch");
generator
.looping()
.set(looping)
.expect("Failed to set looping");
}
if let Some(source) = sound.source.as_mut() {
source.gain().set(gain).expect("Failed to set gain");
let mut clear_source = false; let mut clear_source = false;
if let Some(source) = handle.cast_to::<syz::Source3D>().expect("Failed to cast") { if let Some(translation) = translation {
if let Some(transform) = transform { if let Some(source) = source.cast_to::<syz::Source3D>().unwrap() {
let translation = transform.translation();
source source
.position() .position()
.set(( .set((
@ -452,7 +288,7 @@ fn update_source_properties(
let distance_model = distance_model let distance_model = distance_model
.cloned() .cloned()
.map(|v| *v) .map(|v| *v)
.unwrap_or_else(|| context.default_distance_model().get().unwrap()); .unwrap_or_else(|| context.default_distance_modle().get().unwrap());
source source
.distance_model() .distance_model()
.set(distance_model) .set(distance_model)
@ -460,7 +296,6 @@ fn update_source_properties(
let distance_ref = distance_ref let distance_ref = distance_ref
.map(|v| **v) .map(|v| **v)
.unwrap_or_else(|| context.default_distance_ref().get().unwrap()); .unwrap_or_else(|| context.default_distance_ref().get().unwrap());
assert!(distance_ref >= 0.);
source source
.distance_ref() .distance_ref()
.set(distance_ref) .set(distance_ref)
@ -468,7 +303,6 @@ fn update_source_properties(
let distance_max = distance_max let distance_max = distance_max
.map(|v| **v) .map(|v| **v)
.unwrap_or_else(|| context.default_distance_max().get().unwrap()); .unwrap_or_else(|| context.default_distance_max().get().unwrap());
assert!(distance_max >= 0.);
source source
.distance_max() .distance_max()
.set(distance_max) .set(distance_max)
@ -476,8 +310,6 @@ fn update_source_properties(
let rolloff = rolloff let rolloff = rolloff
.map(|v| **v) .map(|v| **v)
.unwrap_or_else(|| context.default_rolloff().get().unwrap()); .unwrap_or_else(|| context.default_rolloff().get().unwrap());
assert!(rolloff >= 0.);
assert!(rolloff >= 0.);
source source
.rolloff() .rolloff()
.set(rolloff) .set(rolloff)
@ -485,15 +317,14 @@ fn update_source_properties(
let closeness_boost = closeness_boost let closeness_boost = closeness_boost
.map(|v| **v) .map(|v| **v)
.unwrap_or_else(|| context.default_closeness_boost().get().unwrap()); .unwrap_or_else(|| context.default_closeness_boost().get().unwrap());
assert!(closeness_boost >= 0.);
source source
.closeness_boost() .closeness_boost()
.set(closeness_boost) .set(closeness_boost)
.expect("Failed to 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 source
.closeness_boost_distance() .closeness_boost_distance()
.set(closeness_boost_distance) .set(closeness_boost_distance)
@ -501,17 +332,12 @@ fn update_source_properties(
} else { } else {
clear_source = true; 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) = source.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 source
.azimuth() .azimuth()
.set(angular_pan.azimuth) .set(angular_pan.azimuth)
.expect("Failed to set azimuth"); .expect("Failed to set azimuth");
assert!(angular_pan.elevation >= -90. && angular_pan.elevation <= 90.);
source source
.elevation() .elevation()
.set(angular_pan.elevation) .set(angular_pan.elevation)
@ -519,12 +345,8 @@ fn update_source_properties(
} else { } else {
clear_source = true; 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) = source.cast_to::<syz::ScalarPannedSource>().unwrap() {
.expect("Failed to cast")
{
if let Some(scalar_pan) = scalar_pan {
assert!(**scalar_pan >= -1. && **scalar_pan <= 1.);
source source
.panning_scalar() .panning_scalar()
.set(**scalar_pan) .set(**scalar_pan)
@ -532,87 +354,17 @@ fn update_source_properties(
} else { } else {
clear_source = true; 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 { if clear_source {
source.handle = None; sound.source = None;
if let Some(mut sound) = sound {
sound.generator = None;
sound.playback_position = 0.;
} }
} }
} }
} }
fn update_sound_properties(mut query: Query<&mut Sound>) { pub fn update_playback_state(query: Query<&Sound>) {
for mut sound in &mut query { for sound in query.iter() {
let Sound { if let Some(generator) = &sound.generator {
gain,
pitch,
looping,
..
} = *sound;
assert!(gain >= 0.);
assert!(pitch > 0. && pitch <= 2.);
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()
.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");
}
}
}
fn update_source_playback_state(query: Query<&Source>) {
for source in &query {
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 {
let Some(generator) = &sound.generator else {
continue;
};
if sound.paused { if sound.paused {
generator.pause().expect("Failed to pause"); generator.pause().expect("Failed to pause");
} else { } else {
@ -620,29 +372,37 @@ fn update_sound_playback_state(query: Query<&Sound>) {
} }
} }
} }
}
fn remove_sound(mut last_buffer: ResMut<LastAudio>, mut removed: RemovedComponents<Sound>) { fn remove_sound(mut last_buffer: ResMut<LastBuffer>, removed: RemovedComponents<Sound>) {
for entity in removed.read() { for entity in removed.iter() {
last_buffer.remove(&entity); last_buffer.remove(&entity);
} }
} }
#[derive(Resource, Debug)] #[derive(Clone, Copy, Default, Debug)]
pub struct SynthizerDefaults { pub struct SynthizerConfig {
pub panner_strategy: syz::PannerStrategy, pub default_panner_strategy: Option<syz::PannerStrategy>,
pub distance_model: syz::DistanceModel, pub default_distance_model: Option<syz::DistanceModel>,
pub distance_ref: f64, pub default_distance_ref: Option<f64>,
pub distance_max: f64, pub default_distance_max: Option<f64>,
pub rolloff: f64, pub default_rolloff: Option<f64>,
pub closeness_boost: f64, pub default_closeness_boost: Option<f64>,
pub closeness_boost_distance: f64, pub default_closeness_boost_distance: Option<f64>,
} }
fn sync_config( #[derive(Debug)]
context: Res<Context>, struct Defaults {
config: Res<SynthizerPlugin>, panner_strategy: syz::PannerStrategy,
defaults: Res<SynthizerDefaults>, distance_model: syz::DistanceModel,
) { distance_ref: f64,
distance_max: f64,
rolloff: f64,
closeness_boost: f64,
closeness_boost_distance: f64,
}
fn sync_config(context: Res<syz::Context>, config: Res<SynthizerConfig>, defaults: Res<Defaults>) {
if config.is_changed() { if config.is_changed() {
context context
.default_panner_strategy() .default_panner_strategy()
@ -653,7 +413,7 @@ fn sync_config(
) )
.expect("Failed to set panner strategy"); .expect("Failed to set panner strategy");
context context
.default_distance_model() .default_distance_modle()
.set( .set(
config config
.default_distance_model .default_distance_model
@ -691,142 +451,49 @@ fn sync_config(
} }
} }
fn events( pub struct SynthizerPlugin;
context: Res<Context>,
sounds: Query<(Entity, &Sound)>,
mut output: EventWriter<SynthizerEvent>,
) {
context.get_events().for_each(|event| {
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));
}
_ => {}
}
break;
}
}
});
}
#[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
pub enum SynthizerSets {
PreUpdate,
UpdateHandles,
UpdateProperties,
UpdateState,
Last,
}
#[derive(Resource)]
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 { impl Plugin for SynthizerPlugin {
fn build(&self, app: &mut App) { 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"); let context = syz::Context::new().expect("Failed to create Synthizer context");
let defaults = SynthizerDefaults { if !app.world.contains_resource::<SynthizerConfig>() {
app.insert_resource(SynthizerConfig::default());
}
let defaults = Defaults {
panner_strategy: context.default_panner_strategy().get().unwrap(), panner_strategy: context.default_panner_strategy().get().unwrap(),
distance_model: context.default_distance_model().get().unwrap(), distance_model: context.default_distance_modle().get().unwrap(),
distance_ref: context.default_distance_ref().get().unwrap(), distance_ref: context.default_distance_ref().get().unwrap(),
distance_max: context.default_distance_max().get().unwrap(), distance_max: context.default_distance_max().get().unwrap(),
rolloff: context.default_rolloff().get().unwrap(), rolloff: context.default_rolloff().get().unwrap(),
closeness_boost: context.default_closeness_boost().get().unwrap(), closeness_boost: context.default_closeness_boost().get().unwrap(),
closeness_boost_distance: context.default_closeness_boost_distance().get().unwrap(), closeness_boost_distance: context.default_closeness_boost_distance().get().unwrap(),
}; };
context.enable_events().expect("Failed to enable events"); app.add_asset::<Buffer>()
let context = Context(context);
app.init_asset::<Buffer>()
.init_asset_loader::<BufferAssetLoader>() .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>() .register_type::<Listener>()
.insert_resource(guard) .insert_resource(guard)
.insert_resource(context) .insert_resource(context)
.init_resource::<LastAudio>() .init_resource::<LastBuffer>()
.insert_resource(defaults) .insert_resource(defaults)
.add_event::<SynthizerEvent>() .add_system_to_stage(CoreStage::PreUpdate, sync_config)
.add_systems( .add_system_to_stage(
PreUpdate, CoreStage::PostUpdate,
(sync_config, swap_buffers, change_panner_strategy) swap_buffers.before(update_sound_properties),
.in_set(SynthizerSets::PreUpdate),
) )
.add_systems( .add_system_to_stage(
PostUpdate, CoreStage::PostUpdate,
(add_sound_without_source, add_source_handle, add_generator) update_listener
.in_set(SynthizerSets::UpdateHandles), .after(TransformSystem::TransformPropagate)
.before(update_playback_state),
) )
.configure_sets( .add_system_to_stage(
PostUpdate, CoreStage::PostUpdate,
SynthizerSets::UpdateHandles.before(SynthizerSets::UpdateProperties), update_sound_properties
.after(TransformSystem::TransformPropagate)
.before(update_playback_state),
) )
.add_systems( .add_system_to_stage(CoreStage::PostUpdate, update_playback_state)
PostUpdate, .add_system_to_stage(CoreStage::PostUpdate, remove_sound);
update_sound_properties.in_set(SynthizerSets::UpdateProperties),
)
.add_systems(
PostUpdate,
(update_listener, update_source_properties)
.in_set(SynthizerSets::UpdateProperties)
.after(TransformSystem::TransformPropagate),
)
.configure_sets(
PostUpdate,
SynthizerSets::UpdateProperties.before(SynthizerSets::UpdateState),
)
.add_systems(
PostUpdate,
(update_source_playback_state, update_sound_playback_state)
.in_set(SynthizerSets::UpdateState),
)
.configure_sets(
PostUpdate,
SynthizerSets::UpdateState.before(SynthizerSets::Last),
)
.add_systems(
PostUpdate,
(remove_sound, events).in_set(SynthizerSets::Last),
);
} }
} }