Struct jumpy::prelude::kira::sound::streaming::StreamingSoundHandle

pub struct StreamingSoundHandle<Error> {
    pub(super) shared: Arc<Shared>,
    pub(super) command_writers: CommandWriters,
    pub(super) error_consumer: Consumer<Error, Arc<SharedRb<Error, Vec<MaybeUninit<Error>>>>>,
}

Controls a streaming sound.

Fields

shared: Arc<Shared>

command_writers: CommandWriters

error_consumer: Consumer<Error, Arc<SharedRb<Error, Vec<MaybeUninit<Error>>>>>

Implementations

impl<Error> StreamingSoundHandle<Error>

pub fn state(&self) -> PlaybackState

Returns the current playback state of the sound.

pub fn position(&self) -> f64

Returns the current playback position of the sound (in seconds).

pub fn set_volume(&mut self, volume: impl Into<Value<Volume>>, tween: Tween)

Sets the volume of the sound.

Examples

Set the volume of the sound as a factor immediately:

use kira::tween::Tween;

sound.set_volume(0.5, Tween::default());

Smoothly transition the volume to a target value in decibels:

use kira::tween::Tween;
use std::time::Duration;

sound.set_volume(kira::Volume::Decibels(-6.0), Tween {
	duration: Duration::from_secs(3),
	..Default::default()
});

Link the volume to a modulator, smoothly transitioning from the current value:

use kira::{
	manager::{AudioManager, AudioManagerSettings, backend::DefaultBackend},
	sound::streaming::{StreamingSoundData, StreamingSoundSettings},
	modulator::tweener::TweenerBuilder,
	tween::Tween,
};
use std::time::Duration;

let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())?;
let tweener = manager.add_modulator(TweenerBuilder {
	initial_value: 0.5,
})?;
let mut sound = manager.play(StreamingSoundData::from_file("sound.ogg")?)?;
sound.set_volume(&tweener, Tween {
	duration: Duration::from_secs(3),
	..Default::default()
});

pub fn set_playback_rate( &mut self, playback_rate: impl Into<Value<PlaybackRate>>, tween: Tween, )

Sets the playback rate of the sound.

Changing the playback rate will change both the speed and pitch of the sound.

Examples

Set the playback rate of the sound as a factor immediately:

use kira::tween::Tween;

sound.set_playback_rate(0.5, Tween::default());

Smoothly transition the playback rate to a target value in semitones:

use kira::{
	tween::Tween,
	sound::PlaybackRate,
};
use std::time::Duration;

sound.set_playback_rate(PlaybackRate::Semitones(-2.0), Tween {
	duration: Duration::from_secs(3),
	..Default::default()
});

Link the playback rate to a modulator, smoothly transitioning from the current value:

use kira::{
	manager::{AudioManager, AudioManagerSettings, backend::DefaultBackend},
	sound::streaming::{StreamingSoundData, StreamingSoundSettings},
	modulator::tweener::TweenerBuilder,
	tween::Tween,
};
use std::time::Duration;

let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())?;
let tweener = manager.add_modulator(TweenerBuilder {
	initial_value: 0.5,
})?;
let mut sound = manager.play(StreamingSoundData::from_file("sound.ogg")?)?;
sound.set_playback_rate(&tweener, Tween {
	duration: Duration::from_secs(3),
	..Default::default()
});

pub fn set_panning(&mut self, panning: impl Into<Value<f64>>, tween: Tween)

Sets the panning of the sound, where 0.0 is hard left, 0.5 is center, and 1.0 is hard right.

Examples

Smoothly transition the panning to a target value:

use kira::tween::Tween;
use std::time::Duration;

sound.set_panning(0.25, Tween {
	duration: Duration::from_secs(3),
	..Default::default()
});

Link the panning to a modulator, smoothly transitioning from the current value:

use kira::{
	manager::{AudioManager, AudioManagerSettings, backend::DefaultBackend},
	sound::streaming::{StreamingSoundData, StreamingSoundSettings},
	modulator::tweener::TweenerBuilder,
	tween::Tween,
};
use std::time::Duration;

let mut manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())?;
let tweener = manager.add_modulator(TweenerBuilder {
	initial_value: 0.25,
})?;
let mut sound = manager.play(StreamingSoundData::from_file("sound.ogg")?)?;
sound.set_panning(&tweener, Tween {
	duration: Duration::from_secs(3),
	..Default::default()
});

pub fn set_loop_region(&mut self, loop_region: impl IntoOptionalRegion)

Sets the portion of the sound that will play in a loop.

Examples

Set the sound to loop the portion from 3 seconds in to the end:

sound.set_loop_region(3.0..);

Set the sound to loop the portion from 2 to 4 seconds:

sound.set_loop_region(2.0..4.0);

Set a sound that was previously looping to stop looping:

sound.set_loop_region(None);

pub fn pause(&mut self, tween: Tween)

Fades out the sound to silence with the given tween and then pauses playback.

pub fn resume(&mut self, tween: Tween)

Resumes playback and fades in the sound from silence with the given tween.

pub fn resume_at(&mut self, start_time: StartTime, tween: Tween)

Resumes playback at the given start time and fades in the sound from silence with the given tween.

pub fn stop(&mut self, tween: Tween)

Fades out the sound to silence with the given tween and then stops playback.

Once the sound is stopped, it cannot be restarted.

pub fn seek_to(&mut self, position: f64)

Sets the playback position to the specified time in seconds.

pub fn seek_by(&mut self, amount: f64)

Moves the playback position by the specified amount of time in seconds.

pub fn pop_error(&mut self) -> Option<Error>

Returns an error that occurred while decoding audio, if any.

Trait Implementations

impl<Error> Debug for StreamingSoundHandle<Error>

where Error: Debug,

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

Formats the value using the given formatter.