Struct AudioBus

pub struct AudioBus { /* private fields */ }

Audio bus is a top-level audio processing unit. It takes data from multiple audio sources and passes their samples through a chain of effects. Output signal is then can be either sent to an audio playback device or to some other audio bus and be processed again, but with different sound effects (this can be done via AudioBusGraph.

Implementations

impl AudioBus

pub const NAME: &'static str = "name"

pub const EFFECTS: &'static str = "effects"

pub const GAIN: &'static str = "gain"

impl AudioBus

pub fn new(name: String) -> AudioBus

Creates a new audio bus with the given name with no audio effects and unit gain. Produced audio bus must be added to an AudioBusGraph to take effect.

pub fn set_name<S>(&mut self, name: S)

where S: AsRef<str>,

Sets a new name of the audio bus. Be careful when changing the name at runtime, each sound source is linked to a bus by its name (implicit binding), so when changing the name you should also change the output bus name of a sound source, that uses the bus.

pub fn name(&self) -> &str

Returns current name of the audio bus. Could be useful if you need to find all sound sources that uses the bus.

pub fn parent(&self) -> Handle<AudioBus>

Returns a handle of the parent audio bus. Primary audio bus has no parent and will return (Handle::NONE).

pub fn children(&self) -> &[Handle<AudioBus>]

Returns a list of handle to children audio buses.

pub fn set_gain(&mut self, gain: f32)

Sets new gain of the audio bus.

pub fn gain(&self) -> f32

Returns current gain of the audio bus.

pub fn add_effect(&mut self, effect: Effect)

Adds new effect to the effects chain.

pub fn remove_effect(&mut self, index: usize)

Removes an effect by the given handle.

pub fn effect(&self, index: usize) -> Option<&Effect>

Returns a shared reference to an effect at the given handle.

pub fn effect_mut(&mut self, index: usize) -> Option<&mut Effect>

Returns mutable reference to effect at given handle.

pub fn effects(&self) -> impl Iterator<Item = &Effect>

Returns an iterator over effects used by this audio bus.

pub fn effects_mut(&mut self) -> impl Iterator<Item = &mut Effect>

Returns an iterator over effects used by this audio bus.

Trait Implementations

impl Clone for AudioBus

fn clone(&self) -> AudioBus

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AudioBus

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for AudioBus

fn default() -> AudioBus

Returns the “default value” for a type.

impl Reflect for AudioBus

where AudioBus: 'static, String: Reflect, Vec<Effect>: Reflect, f32: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<AudioBus>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&(dyn Any + 'static)))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Any + 'static)))

fn as_reflect(&self, func: &mut dyn FnMut(&(dyn Reflect + 'static)))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut (dyn Reflect + 'static)))

fn fields(&self, func: &mut dyn FnMut(&[&(dyn Reflect + 'static)]))

fn fields_mut( &mut self, func: &mut dyn FnMut(&mut [&mut (dyn Reflect + 'static)]), )

fn field( &self, name: &str, func: &mut dyn FnMut(Option<&(dyn Reflect + 'static)>), )

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut (dyn Reflect + 'static)>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl Visit for AudioBus

where String: Visit, Vec<Effect>: Visit, f32: Visit, Vec<Handle<AudioBus>>: Visit, Handle<AudioBus>: Visit,

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> Result<(), VisitError>

Read or write this value, depending on whether Visitor::is_reading() is true or false.