Struct soloud::Soloud

pub struct Soloud { /* fields omitted */ }

Implementations

impl Soloud

pub fn default_uninit() -> MaybeUninit<Self>

pub fn init(&mut self) -> Result<(), SoloudError>

pub fn default() -> Result<Self, SoloudError>

pub fn init_ex(
    &mut self,
    aFlags: SoloudFlags,
    aSamplerate: u32,
    aBufferSize: u32,
    aChannels: u32
) -> Result<(), SoloudError>

pub fn version(&self) -> u32

pub fn backend_id(&self) -> u32

pub fn backend_string(&self) -> String

pub fn backend_channels(&self) -> u32

pub fn backend_samplerate(&self) -> u32

pub fn backend_buffer_size(&self) -> u32

pub fn set_speaker_position(
    &mut self,
    aChannel: u32,
    aX: f32,
    aY: f32,
    aZ: f32
) -> Result<(), SoloudError>

pub fn speaker_position(
    &self,
    aChannel: u32
) -> Result<(f32, f32, f32), SoloudError>

pub fn play_ex<AS: AudioExt>(
    &self,
    aSound: &AS,
    aVolume: f32,
    aPan: f32,
    aPaused: bool,
    aBus: u32
) -> u32

pub fn play_clocked<AS: AudioExt>(&self, aSoundTime: f64, aSound: &AS) -> u32

pub fn play_clocked_ex<AS: AudioExt>(
    &self,
    aSoundTime: f64,
    aSound: &AS,
    aVolume: f32,
    aPan: f32,
    aBus: u32
) -> u32

pub fn play_3d<AS: AudioExt>(
    &self,
    aSound: &AS,
    aPosX: f32,
    aPosY: f32,
    aPosZ: f32
) -> u32

pub fn play_3d_ex<AS: AudioExt>(
    &self,
    aSound: &AS,
    aPosX: f32,
    aPosY: f32,
    aPosZ: f32,
    aVelX: f32,
    aVelY: f32,
    aVelZ: f32,
    aVolume: f32,
    aPaused: bool,
    aBus: u32
) -> u32

pub fn play_3d_clocked<AS: AudioExt>(
    &self,
    aSoundTime: f64,
    aSound: &AS,
    aPosX: f32,
    aPosY: f32,
    aPosZ: f32
) -> u32

pub fn play_3d_clocked_ex<AS: AudioExt>(
    &self,
    aSoundTime: f64,
    aSound: &AS,
    aPosX: f32,
    aPosY: f32,
    aPosZ: f32,
    aVelX: f32,
    aVelY: f32,
    aVelZ: f32,
    aVolume: f32,
    aBus: u32
) -> u32

pub fn play_background<AS: AudioExt>(&self, aSound: &AS) -> u32

pub fn play_background_ex<AS: AudioExt>(
    &self,
    aSound: &AS,
    aVolume: f32,
    aPaused: bool,
    aBus: u32
) -> u32

pub fn seek(
    &self,
    aVoiceHandle: Handle,
    aSeconds: f64
) -> Result<(), SoloudError>

pub fn stop(&self, aVoiceHandle: Handle)

pub fn stopAll(&self)

pub fn deinit(&mut self)

pub fn play<T: AudioExt>(&self, sound: &T) -> Handle

pub fn active_voice_count(&self) -> u32

pub fn voice_count(&self) -> u32

pub fn set_global_volume(&mut self, val: f32)

pub fn stop_audio_source<AS: AudioExt>(&self, aSound: &AS)

pub fn count_audio_source<AS: AudioExt>(&self, aSound: &AS) -> i32

pub fn stream_time(&self, aVoiceHandle: Handle) -> f64

pub fn stream_position(&self, aVoiceHandle: Handle) -> f64

pub fn pause(&self, aVoiceHandle: Handle) -> bool

pub fn volume(&self, aVoiceHandle: Handle) -> f32

pub fn overall_volume(&self, aVoiceHandle: Handle) -> f32

pub fn pan(&self, aVoiceHandle: Handle) -> f32

pub fn samplerate(&self, aVoiceHandle: Handle) -> f32

pub fn protect_voice(&self, aVoiceHandle: Handle) -> bool

pub fn is_valid_voice_handle(&self, aVoiceHandle: Handle) -> bool

pub fn relative_play_speed(&self, aVoiceHandle: Handle) -> f32

pub fn post_clip_scaler(&self) -> f32

pub fn main_resampler(&self) -> u32

pub fn global_volume(&self) -> f32

pub fn max_active_voice_count(&self) -> u32

pub fn looping(&self, aVoiceHandle: Handle) -> bool

pub fn auto_stop(&self, aVoiceHandle: Handle) -> bool

pub fn loop_point(&self, aVoiceHandle: Handle) -> f64

pub fn set_loop_point(&mut self, aVoiceHandle: Handle, aLoopPoint: f64)

pub fn set_looping(&mut self, aVoiceHandle: Handle, aLooping: bool)

pub fn set_auto_stop(&mut self, aVoiceHandle: Handle, aAutoStop: bool)

pub fn set_max_active_voice_count(
    &mut self,
    aVoiceCount: u32
) -> Result<(), SoloudError>

pub fn set_inaudible_behavior(
    &mut self,
    aVoiceHandle: Handle,
    aMustTick: bool,
    aKill: bool
)

pub fn set_post_clip_scaler(&mut self, aScaler: f32)

pub fn set_main_resampler(&mut self, aResampler: u32)

pub fn set_pause(&mut self, aVoiceHandle: Handle, aPause: bool)

pub fn set_pause_all(&mut self, aPause: bool)

pub fn set_relative_play_speed(
    &mut self,
    aVoiceHandle: Handle,
    aSpeed: f32
) -> Result<(), SoloudError>

pub fn set_protect_voice(&mut self, aVoiceHandle: Handle, aProtect: bool)

pub fn set_samplerate(&mut self, aVoiceHandle: Handle, aSamplerate: f32)

pub fn set_pan(&mut self, aVoiceHandle: Handle, aPan: f32)

pub fn set_pan_absolute(
    &mut self,
    aVoiceHandle: Handle,
    aLVolume: f32,
    aRVolume: f32
)

pub fn set_channel_volume(
    &mut self,
    aVoiceHandle: Handle,
    aChannel: u32,
    aVolume: f32
)

pub fn set_volume(&mut self, aVoiceHandle: Handle, aVolume: f32)

pub fn set_delay_samples(&mut self, aVoiceHandle: Handle, aSamples: u32)

pub fn fade_volume(&self, aVoiceHandle: Handle, aTo: f32, aTime: f64)

pub fn fade_pan(&self, aVoiceHandle: Handle, aTo: f32, aTime: f64)

pub fn fade_relative_play_speed(
    &self,
    aVoiceHandle: Handle,
    aTo: f32,
    aTime: f64
)

pub fn fade_global_volume(&self, aTo: f32, aTime: f64)

pub fn schedule_pause(&self, aVoiceHandle: Handle, aTime: f64)

pub fn schedule_stope(&self, aVoiceHandle: Handle, aTime: f64)

pub fn oscillate_volume(
    &self,
    aVoiceHandle: Handle,
    aFrom: f32,
    aTo: f32,
    aTime: f64
)

pub fn oscillate_pan(
    &self,
    aVoiceHandle: Handle,
    aFrom: f32,
    aTo: f32,
    aTime: f64
)

pub fn oscillate_relative_play_speed(
    &self,
    aVoiceHandle: Handle,
    aFrom: f32,
    aTo: f32,
    aTime: f64
)

pub fn oscillate_global_volume(&self, aFrom: f32, aTo: f32, aTime: f64)

pub fn set_visualize_enable(&self, aEnable: bool)

pub fn calc_FFT(&self) -> Vec<f32>

pub fn wave(&self) -> Vec<f32>

pub fn approximate_volume(&self, aChannel: u32) -> f32

pub fn loop_count(&self, aVoiceHandle: Handle) -> u32

pub fn info(&self, aVoiceHandle: Handle, aInfoKey: u32) -> f32

pub fn create_voice_group(&self) -> Handle

pub fn destroy_voice_group(
    &self,
    aVoiceGroupHandle: Handle
) -> Result<(), SoloudError>

pub fn add_voice_to_group(
    &self,
    aVoiceGroupHandle: Handle,
    aVoiceHandle: Handle
) -> Result<(), SoloudError>

pub fn is_voice_group(&self, aVoiceGroupHandle: Handle) -> bool

pub fn is_voice_group_empty(&self, aVoiceGroupHandle: Handle) -> bool

pub fn update_3d_audio(&self)

pub fn set_3d_sound_speed(&self, aSpeed: f32) -> Result<(), SoloudError>

pub fn get_3d_sound_speed(&self) -> f32

pub fn set_3d_listener_params(
    &mut self,
    aPosX: f32,
    aPosY: f32,
    aPosZ: f32,
    aAtX: f32,
    aAtY: f32,
    aAtZ: f32,
    aUpX: f32,
    aUpY: f32,
    aUpZ: f32
)

pub fn set_3d_listener_params_ex(
    &mut self,
    aPosX: f32,
    aPosY: f32,
    aPosZ: f32,
    aAtX: f32,
    aAtY: f32,
    aAtZ: f32,
    aUpX: f32,
    aUpY: f32,
    aUpZ: f32,
    aVelocityX: f32,
    aVelocityY: f32,
    aVelocityZ: f32
)

pub fn set_3d_listener_position(&mut self, aPosX: f32, aPosY: f32, aPosZ: f32)

pub fn set_3d_listener_at(&mut self, aAtX: f32, aAtY: f32, aAtZ: f32)

pub fn set_3d_listener_up(&mut self, aUpX: f32, aUpY: f32, aUpZ: f32)

pub fn set_3d_listener_velocity(
    &mut self,
    aVelocityX: f32,
    aVelocityY: f32,
    aVelocityZ: f32
)

pub fn set_3d_source_params(
    &mut self,
    aVoiceHandle: Handle,
    aPosX: f32,
    aPosY: f32,
    aPosZ: f32
)

pub fn set_3d_source_params_ex(
    &mut self,
    aVoiceHandle: Handle,
    aPosX: f32,
    aPosY: f32,
    aPosZ: f32,
    aVelocityX: f32,
    aVelocityY: f32,
    aVelocityZ: f32
)

pub fn set_3d_source_position(
    &mut self,
    aVoiceHandle: Handle,
    aPosX: f32,
    aPosY: f32,
    aPosZ: f32
)

pub fn set_3d_source_velocity(
    &mut self,
    aVoiceHandle: Handle,
    aVelocityX: f32,
    aVelocityY: f32,
    aVelocityZ: f32
)

pub fn set_3d_source_minmax_distance(
    &mut self,
    aVoiceHandle: Handle,
    aMinDistance: f32,
    aMaxDistance: f32
)

pub fn set_3d_source_attenuation(
    &mut self,
    aVoiceHandle: Handle,
    aAttenuationModel: u32,
    aAttenuationRolloffFactor: f32
)

pub fn set_3d_source_doppler_factor(
    &mut self,
    aVoiceHandle: Handle,
    aDopplerFactor: f32
)

pub fn mix(&mut self, aBuffer: &mut [f32])

pub fn mix_signed_16(&mut self, aBuffer: &mut [i16])

pub fn set_filter_param(
    &mut self,
    aVoiceHandle: Handle,
    aFilterId: u32,
    aAttributeId: impl FilterAttr,
    aValue: f32
)

pub fn filter_param(
    &mut self,
    aVoiceHandle: Handle,
    aFilterId: u32,
    aAttributeId: impl FilterAttr
) -> f32

pub fn fade_filter_param(
    &mut self,
    aVoiceHandle: Handle,
    aFilterId: u32,
    aAttributeId: impl FilterAttr,
    aTo: f32,
    aTime: f64
)

pub fn oscillate_filter_param(
    &mut self,
    aVoiceHandle: Handle,
    aFilterId: u32,
    aAttributeId: impl FilterAttr,
    aFrom: f32,
    aTo: f32,
    aTime: f64
)

pub fn set_global_filter(&mut self, aFilterId: u32, aFilter: impl FilterExt)

Trait Implementations

impl Clone for Soloud

fn clone(&self) -> Soloud

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Send for Soloud

impl Sync for Soloud