Struct Sound 

pub struct Sound<'buf> { /* private fields */ }

Regular sound that can be played in the audio environment.

Sound is the type to use to play sounds.

It provides:

• Control (play, pause, stop)
• Ability to modify output parameters in real-time (pitch, volume, …)
• 3D spatial features (position, attenuation, …).

Sound is perfect for playing short sounds that can fit in memory and require no latency, like foot steps or gun shots. For longer sounds, like background musics or long speeches, rather see Music (which is based on streaming).

In order to work, a sound must be given a buffer of audio data to play. Audio data (samples) is stored in SoundBuffer, and attached to a sound with the set_buffer function. The buffer object attached to a sound must remain alive as long as the sound uses it. Note that multiple sounds can use the same sound buffer at the same time.

Implementations

impl<'buf> Sound<'buf>

Creation

pub fn new() -> Self

Create a new Sound

Panics

Panics on allocation failure

Examples found in repository

examples/custom-sound-recorder.rs (line 88)

fn main() -> Result<(), Box<dyn Error>> {
    example_ensure_right_working_dir();

    assert!(
        capture::is_available(),
        "Sorry, audio capture is not supported by your system"
    );
    let default_device = capture::default_device();
    let devices = capture::available_devices();
    let mut rw = RenderWindow::new(
        (800, 600),
        "Custom sound recorder",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let (mut rec, recv) = MyRecorder::new();
    let mut samp_buf = Vec::new();
    let mut driver = SoundRecorderDriver::new(&mut rec);
    let mut started = false;
    let mut snd_buf = SoundBuffer::new()?;
    let mut samp_accum = Vec::new();
    let mut sound = Some(Sound::new());
    let mut selected_dev_idx = 0;
    let mut mode = Mode::Main;
    let mut input_buf = String::new();
    let mut desired_sample_rate = 44_100;
    let mut desired_channel_count = 2;

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match mode {
                    Mode::Main => match code {
                        Key::R => {
                            if started {
                                driver.stop();
                                sound = None;
                                snd_buf.load_from_samples(
                                    &samp_accum[..],
                                    desired_channel_count,
                                    desired_sample_rate,
                                )?;
                                samp_accum.clear();
                                started = false;
                            } else {
                                driver.set_device(devices[selected_dev_idx].to_str()?)?;
                                driver.set_channel_count(desired_channel_count);
                                driver.start(desired_sample_rate)?;
                                started = true;
                            }
                        }
                        Key::P => {
                            if !started {
                                let sound = sound.insert(Sound::with_buffer(&snd_buf));
                                sound.play();
                            }
                        }
                        Key::D => mode = Mode::SetDevice,
                        Key::S => {
                            input_buf = desired_sample_rate.to_string();
                            mode = Mode::SetSampleRate;
                        }
                        Key::C => {
                            input_buf = desired_channel_count.to_string();
                            mode = Mode::SetChannelCount;
                        }
                        Key::E => {
                            input_buf = "export.wav".to_string();
                            mode = Mode::Export;
                        }
                        _ => {}
                    },
                    Mode::SetDevice => match code {
                        Key::Up => {
                            selected_dev_idx -= selected_dev_idx.saturating_sub(1);
                        }
                        Key::Down => {
                            if selected_dev_idx + 1 < devices.len() {
                                selected_dev_idx += 1;
                            }
                        }
                        Key::Enter | Key::Escape => {
                            mode = Mode::Main;
                        }
                        _ => {}
                    },
                    Mode::SetSampleRate => {
                        if code == Key::Enter {
                            desired_sample_rate = input_buf.parse()?;
                            mode = Mode::Main;
                        }
                    }
                    Mode::SetChannelCount => {
                        if code == Key::Enter {
                            desired_channel_count = input_buf.parse()?;
                            mode = Mode::Main;
                        }
                    }
                    Mode::Export => {
                        if code == Key::Enter {
                            snd_buf.save_to_file(&input_buf)?;
                            mode = Mode::Main;
                        }
                    }
                },
                Event::TextEntered { unicode } => match mode {
                    Mode::SetSampleRate | Mode::SetChannelCount => {
                        if unicode.is_ascii_digit() {
                            input_buf.push(unicode);
                        } else if unicode == 0x8 as char {
                            input_buf.pop();
                        }
                    }
                    Mode::Export => {
                        if !unicode.is_ascii_control() {
                            input_buf.push(unicode);
                        } else if unicode == 0x8 as char {
                            input_buf.pop();
                        }
                    }
                    Mode::Main | Mode::SetDevice => {}
                },
                _ => {}
            }
        }
        if let Ok(samples) = recv.try_recv() {
            samp_accum.extend_from_slice(&samples);
            samp_buf = samples;
        }
        rw.clear(Color::rgb(10, 60, 40));
        let mut writer = TextWriter::new(&font, 20, 0.0, 0.0);
        macro_rules! w {
            ($($arg:tt)*) => {
                writer.write(&format!($($arg)*), &mut rw);
            }
        }
        match mode {
            Mode::Main => {
                w!("D - set device, S - set sample rate, C - set channel count, E - export");
                let s = if started {
                    "Press R to stop recording"
                } else {
                    "Press R to start recording. Press P to play the recording."
                };
                w!("{s}");
                w!(
                    "{} @ {} Hz\n{} samples, {} channels, {} bytes recorded",
                    driver.device(),
                    driver.sample_rate(),
                    samp_buf.len(),
                    driver.channel_count(),
                    samp_accum.len() * 2,
                );
                let mut rect = RectangleShape::new();
                for (i, &sample) in samp_buf.iter().enumerate() {
                    let ratio = samp_buf.len() as f32 / rw.size().x as f32;
                    rect.set_position((i as f32 / ratio, 300.0));
                    rect.set_size((2.0, sample as f32 / 48.0));
                    rw.draw(&rect);
                }
            }
            Mode::SetDevice => {
                for (i, dev) in devices.iter().enumerate() {
                    let default_str = if dev == &*default_device {
                        " (default)"
                    } else {
                        ""
                    };
                    let color = if selected_dev_idx == i {
                        Color::YELLOW
                    } else {
                        Color::WHITE
                    };
                    writer.text.set_fill_color(color);
                    w!("{}: {}{default_str}", i + 1, dev.to_str()?);
                }
            }
            Mode::SetSampleRate => {
                w!("Enter desired sample rate");
                w!("{input_buf}");
            }
            Mode::SetChannelCount => {
                w!("Enter desired channel count");
                w!("{input_buf}");
            }
            Mode::Export => {
                w!("Enter filename to export as");
                w!("{input_buf}");
            }
        }
        rw.display();
    }
    Ok(())
}

pub fn with_buffer(buffer: &'buf SoundBuffer) -> Self

Create a new Sound with a buffer

Examples found in repository

examples/sound.rs (line 22)

fn play_sound() -> SfResult<()> {
    let buffer = SoundBuffer::from_file("canary.wav")?;

    // Display sound informations
    println!("canary.wav :");
    println!(" {} seconds", buffer.duration().as_seconds());
    println!(" {} samples / sec", buffer.sample_rate());
    println!(" {} channels", buffer.channel_count());

    let mut sound = Sound::with_buffer(&buffer);
    sound.play();

    while sound.status() == SoundStatus::PLAYING {
        // Display the playing position
        print!("\rPlaying... {:.2}", sound.playing_offset().as_seconds());
        let _ = std::io::stdout().flush();
        // Leave some CPU time for other processes
        sleep(Time::milliseconds(100));
    }
    println!();
    Ok(())
}

examples/resource-holder.rs (line 69)

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut tex_holder = ResourceHolder::<Texture, _>::default();
    tex_holder.load("frank", "frank.jpeg")?;
    let mut sb_holder = ResourceHolder::<SoundBuffer, _>::default();
    sb_holder.load("canary", "canary.wav")?;
    let mut rw = RenderWindow::new(
        (800, 600),
        "Resource holder test",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let mut sound = Sound::with_buffer(sb_holder.get("canary"));
    sound.play();
    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => rw.close(),
                _ => {}
            }
        }
        rw.clear(Color::BLACK);
        rw.draw(&Sprite::with_texture(tex_holder.get("frank")));
        rw.display();
    }
    Ok(())
}

examples/sound-capture.rs (line 109)

fn main() -> Result<(), Box<dyn Error>> {
    // Check that the device can capture audio
    assert!(
        capture::is_available(),
        "Sorry, audio capture is not supported by your system"
    );
    let default_device = capture::default_device();
    let devices = capture::available_devices();
    println!("{} recording devices available:", devices.len());
    for (i, device) in devices.iter().enumerate() {
        let def_str = if device == &*default_device {
            " (default)"
        } else {
            ""
        };
        println!("Device {i}: {device}{def_str}");
    }

    // Choose the sample rate
    println!(
        "Please input device and sample rate, then press enter\n\
              Example:\n\
              1 22050 # record at 22050 Hz on device 1\n\
              Default (on empty input) is device 0 and 44100 Hz (CD quality)"
    );
    let stdin = std::io::stdin();
    let mut reader = stdin.lock();
    let mut line = String::new();
    reader.read_line(&mut line)?;
    let input = line.trim_end();
    let mut tokens = input.split_whitespace();
    let device_idx = if let Some(token) = tokens.next() {
        match token.parse::<usize>() {
            Ok(value) => value,
            Err(e) => return Err(format!("Input is not valid: {e}").into()),
        }
    } else {
        0
    };
    let sample_rate = if let Some(token) = tokens.next() {
        match token.parse::<u32>() {
            Ok(value) => value,
            Err(e) => return Err(format!("Input is not valid: {e}").into()),
        }
    } else {
        44_100
    };

    // Here we'll use an integrated custom recorder,
    // which saves the captured data into a SoundBuffer
    let mut recorder = SoundBufferRecorder::new();
    match devices.get(device_idx) {
        Some(device) => {
            recorder.set_device(device.to_str()?)?;
        }
        None => {
            eprintln!("No device with index {device_idx}");
        }
    }

    // Audio capture is done in a separate thread,
    // so we can block the main thread while it is capturing
    recorder.start(sample_rate)?;
    println!(
        "Recording on device {} @ {} Hz...\nPress enter to stop",
        recorder.device().to_str().unwrap_or("<invalid utf-8>"),
        recorder.sample_rate()
    );
    reader.read_line(&mut String::new())?;
    recorder.stop();

    // Get the buffer containing the captured data
    let buffer = recorder.buffer();

    // Display captured sound information
    println!("Sound information :");
    println!(" {} seconds", buffer.duration().as_seconds());
    println!(" {} samples / sec", buffer.sample_rate());
    println!(" {} channels", buffer.channel_count());

    // Choose what to do with the recorded sound data
    print!("What do you want to do with captured sound (p = play, s = save) ? ");
    let _ = std::io::stdout().flush();
    let mut resp = String::new();
    reader.read_line(&mut resp)?;

    if resp.trim() == "s" {
        // Choose a filename
        println!("Choose the file to create: ");
        let mut filename = String::new();
        reader.read_line(&mut filename)?;

        // Save the buffer
        if buffer.save_to_file(filename.trim()).is_err() {
            eprintln!("Error saving buffer to {}!", filename.trim());
        }
    } else {
        let mut sound = Sound::with_buffer(buffer);

        sound.play();

        while sound.status() == SoundStatus::PLAYING {
            // Display the playing position
            print!(
                "\rPlaying... {:.2} sec",
                sound.playing_offset().as_seconds()
            );
            let _ = std::io::stdout().flush();
            // Leave some CPU time for other processes
            sleep(Time::milliseconds(100));
        }
    }

    // Finished
    println!("\nDone!");
    Ok(())
}

examples/custom-sound-recorder.rs (line 121)

fn main() -> Result<(), Box<dyn Error>> {
    example_ensure_right_working_dir();

    assert!(
        capture::is_available(),
        "Sorry, audio capture is not supported by your system"
    );
    let default_device = capture::default_device();
    let devices = capture::available_devices();
    let mut rw = RenderWindow::new(
        (800, 600),
        "Custom sound recorder",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let (mut rec, recv) = MyRecorder::new();
    let mut samp_buf = Vec::new();
    let mut driver = SoundRecorderDriver::new(&mut rec);
    let mut started = false;
    let mut snd_buf = SoundBuffer::new()?;
    let mut samp_accum = Vec::new();
    let mut sound = Some(Sound::new());
    let mut selected_dev_idx = 0;
    let mut mode = Mode::Main;
    let mut input_buf = String::new();
    let mut desired_sample_rate = 44_100;
    let mut desired_channel_count = 2;

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match mode {
                    Mode::Main => match code {
                        Key::R => {
                            if started {
                                driver.stop();
                                sound = None;
                                snd_buf.load_from_samples(
                                    &samp_accum[..],
                                    desired_channel_count,
                                    desired_sample_rate,
                                )?;
                                samp_accum.clear();
                                started = false;
                            } else {
                                driver.set_device(devices[selected_dev_idx].to_str()?)?;
                                driver.set_channel_count(desired_channel_count);
                                driver.start(desired_sample_rate)?;
                                started = true;
                            }
                        }
                        Key::P => {
                            if !started {
                                let sound = sound.insert(Sound::with_buffer(&snd_buf));
                                sound.play();
                            }
                        }
                        Key::D => mode = Mode::SetDevice,
                        Key::S => {
                            input_buf = desired_sample_rate.to_string();
                            mode = Mode::SetSampleRate;
                        }
                        Key::C => {
                            input_buf = desired_channel_count.to_string();
                            mode = Mode::SetChannelCount;
                        }
                        Key::E => {
                            input_buf = "export.wav".to_string();
                            mode = Mode::Export;
                        }
                        _ => {}
                    },
                    Mode::SetDevice => match code {
                        Key::Up => {
                            selected_dev_idx -= selected_dev_idx.saturating_sub(1);
                        }
                        Key::Down => {
                            if selected_dev_idx + 1 < devices.len() {
                                selected_dev_idx += 1;
                            }
                        }
                        Key::Enter | Key::Escape => {
                            mode = Mode::Main;
                        }
                        _ => {}
                    },
                    Mode::SetSampleRate => {
                        if code == Key::Enter {
                            desired_sample_rate = input_buf.parse()?;
                            mode = Mode::Main;
                        }
                    }
                    Mode::SetChannelCount => {
                        if code == Key::Enter {
                            desired_channel_count = input_buf.parse()?;
                            mode = Mode::Main;
                        }
                    }
                    Mode::Export => {
                        if code == Key::Enter {
                            snd_buf.save_to_file(&input_buf)?;
                            mode = Mode::Main;
                        }
                    }
                },
                Event::TextEntered { unicode } => match mode {
                    Mode::SetSampleRate | Mode::SetChannelCount => {
                        if unicode.is_ascii_digit() {
                            input_buf.push(unicode);
                        } else if unicode == 0x8 as char {
                            input_buf.pop();
                        }
                    }
                    Mode::Export => {
                        if !unicode.is_ascii_control() {
                            input_buf.push(unicode);
                        } else if unicode == 0x8 as char {
                            input_buf.pop();
                        }
                    }
                    Mode::Main | Mode::SetDevice => {}
                },
                _ => {}
            }
        }
        if let Ok(samples) = recv.try_recv() {
            samp_accum.extend_from_slice(&samples);
            samp_buf = samples;
        }
        rw.clear(Color::rgb(10, 60, 40));
        let mut writer = TextWriter::new(&font, 20, 0.0, 0.0);
        macro_rules! w {
            ($($arg:tt)*) => {
                writer.write(&format!($($arg)*), &mut rw);
            }
        }
        match mode {
            Mode::Main => {
                w!("D - set device, S - set sample rate, C - set channel count, E - export");
                let s = if started {
                    "Press R to stop recording"
                } else {
                    "Press R to start recording. Press P to play the recording."
                };
                w!("{s}");
                w!(
                    "{} @ {} Hz\n{} samples, {} channels, {} bytes recorded",
                    driver.device(),
                    driver.sample_rate(),
                    samp_buf.len(),
                    driver.channel_count(),
                    samp_accum.len() * 2,
                );
                let mut rect = RectangleShape::new();
                for (i, &sample) in samp_buf.iter().enumerate() {
                    let ratio = samp_buf.len() as f32 / rw.size().x as f32;
                    rect.set_position((i as f32 / ratio, 300.0));
                    rect.set_size((2.0, sample as f32 / 48.0));
                    rw.draw(&rect);
                }
            }
            Mode::SetDevice => {
                for (i, dev) in devices.iter().enumerate() {
                    let default_str = if dev == &*default_device {
                        " (default)"
                    } else {
                        ""
                    };
                    let color = if selected_dev_idx == i {
                        Color::YELLOW
                    } else {
                        Color::WHITE
                    };
                    writer.text.set_fill_color(color);
                    w!("{}: {}{default_str}", i + 1, dev.to_str()?);
                }
            }
            Mode::SetSampleRate => {
                w!("Enter desired sample rate");
                w!("{input_buf}");
            }
            Mode::SetChannelCount => {
                w!("Enter desired channel count");
                w!("{input_buf}");
            }
            Mode::Export => {
                w!("Enter filename to export as");
                w!("{input_buf}");
            }
        }
        rw.display();
    }
    Ok(())
}

examples/pong.rs (line 61)

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut rng = SmallRng::seed_from_u64(1);

    // Optional antialiasing
    let mut aa_level = 0;

    if let Some(arg) = env::args().nth(1) {
        match arg.parse::<u32>() {
            Ok(arg_as_num) => aa_level = arg_as_num,
            Err(e) => println!("Didn't set AA level: {e}"),
        }
    }

    // Define some constants
    let game_width = 800;
    let game_height = 600;
    let paddle_size = Vector2f::new(25., 100.);
    let ball_radius = 10.;

    // Create the window of the application
    let context_settings = ContextSettings {
        antialiasing_level: aa_level,
        ..Default::default()
    };
    let mut window = RenderWindow::new(
        [game_width, game_height],
        "SFML Pong",
        Style::CLOSE,
        &context_settings,
    )?;
    let context_settings = window.settings();
    if context_settings.antialiasing_level > 0 {
        println!("Using {}xAA", context_settings.antialiasing_level);
    }
    window.set_vertical_sync_enabled(true);

    // Load the sounds used in the game
    let ball_soundbuffer = SoundBuffer::from_file("ball.wav")?;
    let mut ball_sound = Sound::with_buffer(&ball_soundbuffer);

    // Create the left paddle
    let mut left_paddle = RectangleShape::new();
    left_paddle.set_size(paddle_size - Vector2f::new(3., 3.));
    left_paddle.set_outline_thickness(3.);
    left_paddle.set_outline_color(Color::BLACK);
    left_paddle.set_fill_color(Color::rgb(100, 100, 200));
    left_paddle.set_origin(paddle_size / 2.);

    // Create the right paddle
    let mut right_paddle = RectangleShape::new();
    right_paddle.set_size(paddle_size - Vector2f::new(3., 3.));
    right_paddle.set_outline_thickness(3.);
    right_paddle.set_outline_color(Color::BLACK);
    right_paddle.set_fill_color(Color::rgb(200, 100, 100));
    right_paddle.set_origin(paddle_size / 2.);

    // Create the ball
    let mut ball = CircleShape::default();
    ball.set_radius(ball_radius - 3.);
    ball.set_outline_thickness(3.);
    ball.set_outline_color(Color::BLACK);
    ball.set_fill_color(Color::WHITE);
    ball.set_origin(ball_radius / 2.);

    // Load the text font
    let font = Font::from_file("sansation.ttf")?;

    // Initialize the pause message
    let mut pause_message = Text::default();
    pause_message.set_font(&font);
    pause_message.set_character_size(40);
    pause_message.set_position((170., 150.));
    pause_message.set_fill_color(Color::WHITE);
    pause_message.set_string("Welcome to SFML pong!\nPress space to start the game");

    // Define the paddles properties
    let mut ai_timer = Clock::start()?;
    let paddle_speed = 400.;
    let mut right_paddle_speed = 0.;
    let mut ball_speed = 400.;
    let mut ball_angle = 0.;

    let mut clock = Clock::start()?;
    let mut is_playing = false;
    let mut up = false;
    let mut down = false;

    'mainloop: loop {
        while let Some(event) = window.poll_event() {
            match event {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => break 'mainloop,
                Event::KeyPressed {
                    code: Key::Space, ..
                } if !is_playing => {
                    // (re)start the game
                    is_playing = true;
                    ball_speed = 400.0;
                    ball_sound.set_pitch(1.0);
                    clock.restart();
                    // Reset the position of the paddles and ball
                    left_paddle.set_position((10. + paddle_size.x / 2., game_height as f32 / 2.));
                    right_paddle.set_position((
                        game_width as f32 - 10. - paddle_size.x / 2.,
                        game_height as f32 / 2.,
                    ));
                    ball.set_position((game_width as f32 / 2., game_height as f32 / 2.));
                    // Reset the ball angle
                    loop {
                        // Make sure the ball initial angle is not too much vertical
                        ball_angle = rng.random_range(0.0..360.) * 2. * PI / 360.;

                        if ball_angle.cos().abs() >= 0.7 {
                            break;
                        }
                    }
                }
                Event::KeyPressed { code: Key::Up, .. }
                | Event::KeyPressed {
                    scan: Scancode::W, ..
                } => up = true,
                Event::KeyReleased { code: Key::Up, .. }
                | Event::KeyReleased {
                    scan: Scancode::W, ..
                } => up = false,
                Event::KeyPressed {
                    code: Key::Down, ..
                }
                | Event::KeyPressed {
                    scan: Scancode::S, ..
                } => down = true,
                Event::KeyReleased {
                    code: Key::Down, ..
                }
                | Event::KeyReleased {
                    scan: Scancode::S, ..
                } => down = false,
                _ => {}
            }
        }
        if is_playing {
            let delta_time = clock.restart().as_seconds();

            // Move the player's paddle
            if up && (left_paddle.position().y - paddle_size.y / 2. > 5.) {
                left_paddle.move_((0., -paddle_speed * delta_time));
            }
            if down && (left_paddle.position().y + paddle_size.y / 2. < game_height as f32 - 5.) {
                left_paddle.move_((0., paddle_speed * delta_time));
            }

            // Move the computer's paddle
            if ((right_paddle_speed < 0.) && (right_paddle.position().y - paddle_size.y / 2. > 5.))
                || ((right_paddle_speed > 0.)
                    && (right_paddle.position().y + paddle_size.y / 2. < game_height as f32 - 5.))
            {
                right_paddle.move_((0., right_paddle_speed * delta_time));
            }

            // Update the computer's paddle direction according to the ball position
            if ai_timer.elapsed_time() > AI_REACT_DELAY {
                ai_timer.restart();
                if ball.position().y + ball_radius > right_paddle.position().y + paddle_size.y / 2.
                {
                    right_paddle_speed = paddle_speed;
                } else if ball.position().y - ball_radius
                    < right_paddle.position().y - paddle_size.y / 2.
                {
                    right_paddle_speed = -paddle_speed;
                } else {
                    right_paddle_speed = 0.;
                }
            }

            // Move the ball
            let factor = ball_speed * delta_time;
            ball.move_((ball_angle.cos() * factor, ball_angle.sin() * factor));

            // Check collisions between the ball and the screen
            if ball.position().x - ball_radius < 0. {
                is_playing = false;
                pause_message.set_string("You lost !\nPress space to restart or\nescape to exit");
            }
            if ball.position().x + ball_radius > game_width as f32 {
                is_playing = false;
                pause_message.set_string("You won !\nPress space to restart or\nescape to exit");
            }
            if ball.position().y - ball_radius < 0. {
                on_bounce(&mut ball_sound, &mut ball_speed);
                ball_angle = -ball_angle;
                let p = ball.position().x;
                ball.set_position((p, ball_radius + 0.1));
            }
            if ball.position().y + ball_radius > game_height as f32 {
                on_bounce(&mut ball_sound, &mut ball_speed);
                ball_angle = -ball_angle;
                let p = ball.position().x;
                ball.set_position((p, game_height as f32 - ball_radius - 0.1));
            }

            // Check the collisions between the ball and the paddles
            // Left Paddle
            let (ball_pos, paddle_pos) = (ball.position(), left_paddle.position());
            if ball_pos.x - ball_radius < paddle_pos.x + paddle_size.x / 2.
                && ball_pos.y + ball_radius >= paddle_pos.y - paddle_size.y / 2.
                && ball_pos.y - ball_radius <= paddle_pos.y + paddle_size.y / 2.
            {
                if ball_pos.y > paddle_pos.y {
                    ball_angle = PI - ball_angle + rng.random_range(0.0..20.) * PI / 180.;
                } else {
                    ball_angle = PI - ball_angle - rng.random_range(0.0..20.) * PI / 180.;
                }

                on_bounce(&mut ball_sound, &mut ball_speed);
                ball.set_position((
                    paddle_pos.x + ball_radius + paddle_size.x / 2. + 0.1,
                    ball_pos.y,
                ));
            }

            // Right Paddle
            let (ball_pos, paddle_pos) = (ball.position(), right_paddle.position());
            if ball_pos.x + ball_radius > paddle_pos.x - paddle_size.x / 2.
                && ball_pos.y + ball_radius >= paddle_pos.y - paddle_size.y / 2.
                && ball_pos.y - ball_radius <= paddle_pos.y + paddle_size.y / 2.
            {
                if ball_pos.y > paddle_pos.y {
                    ball_angle = PI - ball_angle + rng.random_range(0.0..20.) * PI / 180.;
                } else {
                    ball_angle = PI - ball_angle - rng.random_range(0.0..20.) * PI / 180.;
                }

                on_bounce(&mut ball_sound, &mut ball_speed);
                ball.set_position((
                    paddle_pos.x - ball_radius - paddle_size.x / 2. - 0.1,
                    ball_pos.y,
                ));
            }
        }
        // Clear the window
        window.clear(Color::rgb(50, 200, 50));

        if is_playing {
            // Draw the paddles and the ball
            window.draw(&left_paddle);
            window.draw(&right_paddle);
            window.draw(&ball);
        } else {
            // Draw the pause message
            window.draw(&pause_message);
        }

        // Display things on screen
        window.display()
    }
    Ok(())
}

impl Sound<'_>

Playback

pub fn play(&mut self)

Start or resume playing a sound

This function starts the sound if it was stopped, resumes it if it was paused, and restarts it from beginning if it was it already playing. This function uses its own thread so that it doesn’t block the rest of the program while the sound is played.

Examples found in repository

examples/pong.rs (line 284)

fn on_bounce(ball_sound: &mut Sound, ball_speed: &mut f32) {
    ball_sound.play();
    ball_sound.set_pitch(ball_sound.pitch() + 0.004);
    *ball_speed += 16.0;
}

examples/sound.rs (line 23)

fn play_sound() -> SfResult<()> {
    let buffer = SoundBuffer::from_file("canary.wav")?;

    // Display sound informations
    println!("canary.wav :");
    println!(" {} seconds", buffer.duration().as_seconds());
    println!(" {} samples / sec", buffer.sample_rate());
    println!(" {} channels", buffer.channel_count());

    let mut sound = Sound::with_buffer(&buffer);
    sound.play();

    while sound.status() == SoundStatus::PLAYING {
        // Display the playing position
        print!("\rPlaying... {:.2}", sound.playing_offset().as_seconds());
        let _ = std::io::stdout().flush();
        // Leave some CPU time for other processes
        sleep(Time::milliseconds(100));
    }
    println!();
    Ok(())
}

examples/resource-holder.rs (line 70)

fn main() -> SfResult<()> {
    example_ensure_right_working_dir();

    let mut tex_holder = ResourceHolder::<Texture, _>::default();
    tex_holder.load("frank", "frank.jpeg")?;
    let mut sb_holder = ResourceHolder::<SoundBuffer, _>::default();
    sb_holder.load("canary", "canary.wav")?;
    let mut rw = RenderWindow::new(
        (800, 600),
        "Resource holder test",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let mut sound = Sound::with_buffer(sb_holder.get("canary"));
    sound.play();
    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed
                | Event::KeyPressed {
                    code: Key::Escape, ..
                } => rw.close(),
                _ => {}
            }
        }
        rw.clear(Color::BLACK);
        rw.draw(&Sprite::with_texture(tex_holder.get("frank")));
        rw.display();
    }
    Ok(())
}

examples/sound-capture.rs (line 111)

fn main() -> Result<(), Box<dyn Error>> {
    // Check that the device can capture audio
    assert!(
        capture::is_available(),
        "Sorry, audio capture is not supported by your system"
    );
    let default_device = capture::default_device();
    let devices = capture::available_devices();
    println!("{} recording devices available:", devices.len());
    for (i, device) in devices.iter().enumerate() {
        let def_str = if device == &*default_device {
            " (default)"
        } else {
            ""
        };
        println!("Device {i}: {device}{def_str}");
    }

    // Choose the sample rate
    println!(
        "Please input device and sample rate, then press enter\n\
              Example:\n\
              1 22050 # record at 22050 Hz on device 1\n\
              Default (on empty input) is device 0 and 44100 Hz (CD quality)"
    );
    let stdin = std::io::stdin();
    let mut reader = stdin.lock();
    let mut line = String::new();
    reader.read_line(&mut line)?;
    let input = line.trim_end();
    let mut tokens = input.split_whitespace();
    let device_idx = if let Some(token) = tokens.next() {
        match token.parse::<usize>() {
            Ok(value) => value,
            Err(e) => return Err(format!("Input is not valid: {e}").into()),
        }
    } else {
        0
    };
    let sample_rate = if let Some(token) = tokens.next() {
        match token.parse::<u32>() {
            Ok(value) => value,
            Err(e) => return Err(format!("Input is not valid: {e}").into()),
        }
    } else {
        44_100
    };

    // Here we'll use an integrated custom recorder,
    // which saves the captured data into a SoundBuffer
    let mut recorder = SoundBufferRecorder::new();
    match devices.get(device_idx) {
        Some(device) => {
            recorder.set_device(device.to_str()?)?;
        }
        None => {
            eprintln!("No device with index {device_idx}");
        }
    }

    // Audio capture is done in a separate thread,
    // so we can block the main thread while it is capturing
    recorder.start(sample_rate)?;
    println!(
        "Recording on device {} @ {} Hz...\nPress enter to stop",
        recorder.device().to_str().unwrap_or("<invalid utf-8>"),
        recorder.sample_rate()
    );
    reader.read_line(&mut String::new())?;
    recorder.stop();

    // Get the buffer containing the captured data
    let buffer = recorder.buffer();

    // Display captured sound information
    println!("Sound information :");
    println!(" {} seconds", buffer.duration().as_seconds());
    println!(" {} samples / sec", buffer.sample_rate());
    println!(" {} channels", buffer.channel_count());

    // Choose what to do with the recorded sound data
    print!("What do you want to do with captured sound (p = play, s = save) ? ");
    let _ = std::io::stdout().flush();
    let mut resp = String::new();
    reader.read_line(&mut resp)?;

    if resp.trim() == "s" {
        // Choose a filename
        println!("Choose the file to create: ");
        let mut filename = String::new();
        reader.read_line(&mut filename)?;

        // Save the buffer
        if buffer.save_to_file(filename.trim()).is_err() {
            eprintln!("Error saving buffer to {}!", filename.trim());
        }
    } else {
        let mut sound = Sound::with_buffer(buffer);

        sound.play();

        while sound.status() == SoundStatus::PLAYING {
            // Display the playing position
            print!(
                "\rPlaying... {:.2} sec",
                sound.playing_offset().as_seconds()
            );
            let _ = std::io::stdout().flush();
            // Leave some CPU time for other processes
            sleep(Time::milliseconds(100));
        }
    }

    // Finished
    println!("\nDone!");
    Ok(())
}

examples/custom-sound-recorder.rs (line 122)

fn main() -> Result<(), Box<dyn Error>> {
    example_ensure_right_working_dir();

    assert!(
        capture::is_available(),
        "Sorry, audio capture is not supported by your system"
    );
    let default_device = capture::default_device();
    let devices = capture::available_devices();
    let mut rw = RenderWindow::new(
        (800, 600),
        "Custom sound recorder",
        Style::CLOSE,
        &Default::default(),
    )?;
    rw.set_vertical_sync_enabled(true);
    let font = Font::from_file("sansation.ttf")?;
    let (mut rec, recv) = MyRecorder::new();
    let mut samp_buf = Vec::new();
    let mut driver = SoundRecorderDriver::new(&mut rec);
    let mut started = false;
    let mut snd_buf = SoundBuffer::new()?;
    let mut samp_accum = Vec::new();
    let mut sound = Some(Sound::new());
    let mut selected_dev_idx = 0;
    let mut mode = Mode::Main;
    let mut input_buf = String::new();
    let mut desired_sample_rate = 44_100;
    let mut desired_channel_count = 2;

    while rw.is_open() {
        while let Some(ev) = rw.poll_event() {
            match ev {
                Event::Closed => rw.close(),
                Event::KeyPressed { code, .. } => match mode {
                    Mode::Main => match code {
                        Key::R => {
                            if started {
                                driver.stop();
                                sound = None;
                                snd_buf.load_from_samples(
                                    &samp_accum[..],
                                    desired_channel_count,
                                    desired_sample_rate,
                                )?;
                                samp_accum.clear();
                                started = false;
                            } else {
                                driver.set_device(devices[selected_dev_idx].to_str()?)?;
                                driver.set_channel_count(desired_channel_count);
                                driver.start(desired_sample_rate)?;
                                started = true;
                            }
                        }
                        Key::P => {
                            if !started {
                                let sound = sound.insert(Sound::with_buffer(&snd_buf));
                                sound.play();
                            }
                        }
                        Key::D => mode = Mode::SetDevice,
                        Key::S => {
                            input_buf = desired_sample_rate.to_string();
                            mode = Mode::SetSampleRate;
                        }
                        Key::C => {
                            input_buf = desired_channel_count.to_string();
                            mode = Mode::SetChannelCount;
                        }
                        Key::E => {
                            input_buf = "export.wav".to_string();
                            mode = Mode::Export;
                        }
                        _ => {}
                    },
                    Mode::SetDevice => match code {
                        Key::Up => {
                            selected_dev_idx -= selected_dev_idx.saturating_sub(1);
                        }
                        Key::Down => {
                            if selected_dev_idx + 1 < devices.len() {
                                selected_dev_idx += 1;
                            }
                        }
                        Key::Enter | Key::Escape => {
                            mode = Mode::Main;
                        }
                        _ => {}
                    },
                    Mode::SetSampleRate => {
                        if code == Key::Enter {
                            desired_sample_rate = input_buf.parse()?;
                            mode = Mode::Main;
                        }
                    }
                    Mode::SetChannelCount => {
                        if code == Key::Enter {
                            desired_channel_count = input_buf.parse()?;
                            mode = Mode::Main;
                        }
                    }
                    Mode::Export => {
                        if code == Key::Enter {
                            snd_buf.save_to_file(&input_buf)?;
                            mode = Mode::Main;
                        }
                    }
                },
                Event::TextEntered { unicode } => match mode {
                    Mode::SetSampleRate | Mode::SetChannelCount => {
                        if unicode.is_ascii_digit() {
                            input_buf.push(unicode);
                        } else if unicode == 0x8 as char {
                            input_buf.pop();
                        }
                    }
                    Mode::Export => {
                        if !unicode.is_ascii_control() {
                            input_buf.push(unicode);
                        } else if unicode == 0x8 as char {
                            input_buf.pop();
                        }
                    }
                    Mode::Main | Mode::SetDevice => {}
                },
                _ => {}
            }
        }
        if let Ok(samples) = recv.try_recv() {
            samp_accum.extend_from_slice(&samples);
            samp_buf = samples;
        }
        rw.clear(Color::rgb(10, 60, 40));
        let mut writer = TextWriter::new(&font, 20, 0.0, 0.0);
        macro_rules! w {
            ($($arg:tt)*) => {
                writer.write(&format!($($arg)*), &mut rw);
            }
        }
        match mode {
            Mode::Main => {
                w!("D - set device, S - set sample rate, C - set channel count, E - export");
                let s = if started {
                    "Press R to stop recording"
                } else {
                    "Press R to start recording. Press P to play the recording."
                };
                w!("{s}");
                w!(
                    "{} @ {} Hz\n{} samples, {} channels, {} bytes recorded",
                    driver.device(),
                    driver.sample_rate(),
                    samp_buf.len(),
                    driver.channel_count(),
                    samp_accum.len() * 2,
                );
                let mut rect = RectangleShape::new();
                for (i, &sample) in samp_buf.iter().enumerate() {
                    let ratio = samp_buf.len() as f32 / rw.size().x as f32;
                    rect.set_position((i as f32 / ratio, 300.0));
                    rect.set_size((2.0, sample as f32 / 48.0));
                    rw.draw(&rect);
                }
            }
            Mode::SetDevice => {
                for (i, dev) in devices.iter().enumerate() {
                    let default_str = if dev == &*default_device {
                        " (default)"
                    } else {
                        ""
                    };
                    let color = if selected_dev_idx == i {
                        Color::YELLOW
                    } else {
                        Color::WHITE
                    };
                    writer.text.set_fill_color(color);
                    w!("{}: {}{default_str}", i + 1, dev.to_str()?);
                }
            }
            Mode::SetSampleRate => {
                w!("Enter desired sample rate");
                w!("{input_buf}");
            }
            Mode::SetChannelCount => {
                w!("Enter desired channel count");
                w!("{input_buf}");
            }
            Mode::Export => {
                w!("Enter filename to export as");
                w!("{input_buf}");
            }
        }
        rw.display();
    }
    Ok(())
}

pub fn pause(&mut self)

Pause a sound

This function pauses the sound if it was playing, otherwise (sound already paused or stopped) it has no effect.

pub fn stop(&mut self)

Stop playing a sound

This function stops the sound if it was playing or paused, and does nothing if it was already stopped. It also resets the playing position (unlike pause).

impl<'buf> Sound<'buf>

Query properties

pub fn is_looping(&self) -> bool

Tell whether or not a sound is in loop mode

Return true if the sound is looping, false otherwise

pub fn status(&self) -> SoundStatus

Get the current status of a sound (stopped, paused, playing)

Return current status

Examples found in repository

examples/sound.rs (line 25)

fn play_sound() -> SfResult<()> {
    let buffer = SoundBuffer::from_file("canary.wav")?;

    // Display sound informations
    println!("canary.wav :");
    println!(" {} seconds", buffer.duration().as_seconds());
    println!(" {} samples / sec", buffer.sample_rate());
    println!(" {} channels", buffer.channel_count());

    let mut sound = Sound::with_buffer(&buffer);
    sound.play();

    while sound.status() == SoundStatus::PLAYING {
        // Display the playing position
        print!("\rPlaying... {:.2}", sound.playing_offset().as_seconds());
        let _ = std::io::stdout().flush();
        // Leave some CPU time for other processes
        sleep(Time::milliseconds(100));
    }
    println!();
    Ok(())
}

examples/sound-capture.rs (line 113)

fn main() -> Result<(), Box<dyn Error>> {
    // Check that the device can capture audio
    assert!(
        capture::is_available(),
        "Sorry, audio capture is not supported by your system"
    );
    let default_device = capture::default_device();
    let devices = capture::available_devices();
    println!("{} recording devices available:", devices.len());
    for (i, device) in devices.iter().enumerate() {
        let def_str = if device == &*default_device {
            " (default)"
        } else {
            ""
        };
        println!("Device {i}: {device}{def_str}");
    }

    // Choose the sample rate
    println!(
        "Please input device and sample rate, then press enter\n\
              Example:\n\
              1 22050 # record at 22050 Hz on device 1\n\
              Default (on empty input) is device 0 and 44100 Hz (CD quality)"
    );
    let stdin = std::io::stdin();
    let mut reader = stdin.lock();
    let mut line = String::new();
    reader.read_line(&mut line)?;
    let input = line.trim_end();
    let mut tokens = input.split_whitespace();
    let device_idx = if let Some(token) = tokens.next() {
        match token.parse::<usize>() {
            Ok(value) => value,
            Err(e) => return Err(format!("Input is not valid: {e}").into()),
        }
    } else {
        0
    };
    let sample_rate = if let Some(token) = tokens.next() {
        match token.parse::<u32>() {
            Ok(value) => value,
            Err(e) => return Err(format!("Input is not valid: {e}").into()),
        }
    } else {
        44_100
    };

    // Here we'll use an integrated custom recorder,
    // which saves the captured data into a SoundBuffer
    let mut recorder = SoundBufferRecorder::new();
    match devices.get(device_idx) {
        Some(device) => {
            recorder.set_device(device.to_str()?)?;
        }
        None => {
            eprintln!("No device with index {device_idx}");
        }
    }

    // Audio capture is done in a separate thread,
    // so we can block the main thread while it is capturing
    recorder.start(sample_rate)?;
    println!(
        "Recording on device {} @ {} Hz...\nPress enter to stop",
        recorder.device().to_str().unwrap_or("<invalid utf-8>"),
        recorder.sample_rate()
    );
    reader.read_line(&mut String::new())?;
    recorder.stop();

    // Get the buffer containing the captured data
    let buffer = recorder.buffer();

    // Display captured sound information
    println!("Sound information :");
    println!(" {} seconds", buffer.duration().as_seconds());
    println!(" {} samples / sec", buffer.sample_rate());
    println!(" {} channels", buffer.channel_count());

    // Choose what to do with the recorded sound data
    print!("What do you want to do with captured sound (p = play, s = save) ? ");
    let _ = std::io::stdout().flush();
    let mut resp = String::new();
    reader.read_line(&mut resp)?;

    if resp.trim() == "s" {
        // Choose a filename
        println!("Choose the file to create: ");
        let mut filename = String::new();
        reader.read_line(&mut filename)?;

        // Save the buffer
        if buffer.save_to_file(filename.trim()).is_err() {
            eprintln!("Error saving buffer to {}!", filename.trim());
        }
    } else {
        let mut sound = Sound::with_buffer(buffer);

        sound.play();

        while sound.status() == SoundStatus::PLAYING {
            // Display the playing position
            print!(
                "\rPlaying... {:.2} sec",
                sound.playing_offset().as_seconds()
            );
            let _ = std::io::stdout().flush();
            // Leave some CPU time for other processes
            sleep(Time::milliseconds(100));
        }
    }

    // Finished
    println!("\nDone!");
    Ok(())
}

pub fn playing_offset(&self) -> Time

Get the current playing position of a sound

Return the current playing position

Examples found in repository

examples/sound.rs (line 27)

fn play_sound() -> SfResult<()> {
    let buffer = SoundBuffer::from_file("canary.wav")?;

    // Display sound informations
    println!("canary.wav :");
    println!(" {} seconds", buffer.duration().as_seconds());
    println!(" {} samples / sec", buffer.sample_rate());
    println!(" {} channels", buffer.channel_count());

    let mut sound = Sound::with_buffer(&buffer);
    sound.play();

    while sound.status() == SoundStatus::PLAYING {
        // Display the playing position
        print!("\rPlaying... {:.2}", sound.playing_offset().as_seconds());
        let _ = std::io::stdout().flush();
        // Leave some CPU time for other processes
        sleep(Time::milliseconds(100));
    }
    println!();
    Ok(())
}

examples/sound-capture.rs (line 117)

fn main() -> Result<(), Box<dyn Error>> {
    // Check that the device can capture audio
    assert!(
        capture::is_available(),
        "Sorry, audio capture is not supported by your system"
    );
    let default_device = capture::default_device();
    let devices = capture::available_devices();
    println!("{} recording devices available:", devices.len());
    for (i, device) in devices.iter().enumerate() {
        let def_str = if device == &*default_device {
            " (default)"
        } else {
            ""
        };
        println!("Device {i}: {device}{def_str}");
    }

    // Choose the sample rate
    println!(
        "Please input device and sample rate, then press enter\n\
              Example:\n\
              1 22050 # record at 22050 Hz on device 1\n\
              Default (on empty input) is device 0 and 44100 Hz (CD quality)"
    );
    let stdin = std::io::stdin();
    let mut reader = stdin.lock();
    let mut line = String::new();
    reader.read_line(&mut line)?;
    let input = line.trim_end();
    let mut tokens = input.split_whitespace();
    let device_idx = if let Some(token) = tokens.next() {
        match token.parse::<usize>() {
            Ok(value) => value,
            Err(e) => return Err(format!("Input is not valid: {e}").into()),
        }
    } else {
        0
    };
    let sample_rate = if let Some(token) = tokens.next() {
        match token.parse::<u32>() {
            Ok(value) => value,
            Err(e) => return Err(format!("Input is not valid: {e}").into()),
        }
    } else {
        44_100
    };

    // Here we'll use an integrated custom recorder,
    // which saves the captured data into a SoundBuffer
    let mut recorder = SoundBufferRecorder::new();
    match devices.get(device_idx) {
        Some(device) => {
            recorder.set_device(device.to_str()?)?;
        }
        None => {
            eprintln!("No device with index {device_idx}");
        }
    }

    // Audio capture is done in a separate thread,
    // so we can block the main thread while it is capturing
    recorder.start(sample_rate)?;
    println!(
        "Recording on device {} @ {} Hz...\nPress enter to stop",
        recorder.device().to_str().unwrap_or("<invalid utf-8>"),
        recorder.sample_rate()
    );
    reader.read_line(&mut String::new())?;
    recorder.stop();

    // Get the buffer containing the captured data
    let buffer = recorder.buffer();

    // Display captured sound information
    println!("Sound information :");
    println!(" {} seconds", buffer.duration().as_seconds());
    println!(" {} samples / sec", buffer.sample_rate());
    println!(" {} channels", buffer.channel_count());

    // Choose what to do with the recorded sound data
    print!("What do you want to do with captured sound (p = play, s = save) ? ");
    let _ = std::io::stdout().flush();
    let mut resp = String::new();
    reader.read_line(&mut resp)?;

    if resp.trim() == "s" {
        // Choose a filename
        println!("Choose the file to create: ");
        let mut filename = String::new();
        reader.read_line(&mut filename)?;

        // Save the buffer
        if buffer.save_to_file(filename.trim()).is_err() {
            eprintln!("Error saving buffer to {}!", filename.trim());
        }
    } else {
        let mut sound = Sound::with_buffer(buffer);

        sound.play();

        while sound.status() == SoundStatus::PLAYING {
            // Display the playing position
            print!(
                "\rPlaying... {:.2} sec",
                sound.playing_offset().as_seconds()
            );
            let _ = std::io::stdout().flush();
            // Leave some CPU time for other processes
            sleep(Time::milliseconds(100));
        }
    }

    // Finished
    println!("\nDone!");
    Ok(())
}

pub fn buffer(&self) -> Option<&'buf SoundBuffer>

Get the audio buffer attached to a sound

Return an option to Sound buffer attached to the sound or None

impl<'buf> Sound<'buf>

Set properties

pub fn set_looping(&mut self, looping: bool)

Sets whether this sound should loop or not.

pub fn set_playing_offset(&mut self, time_offset: Time)

Change the current playing position of a sound

The playing position can be changed when the sound is either paused or playing.

Arguments

• timeOffset - New playing position

pub fn set_buffer(&mut self, buffer: &'buf SoundBuffer)

Set the source buffer containing the audio data to play

Arguments

• buffer - Sound buffer to attach to the sound

Trait Implementations

impl Clone for Sound<'_>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'buf> Debug for Sound<'buf>

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

Formats the value using the given formatter.

impl Default for Sound<'_>

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Sound<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl SoundSource for Sound<'_>

fn set_pitch(&mut self, pitch: f32)

Set the pitch of the sound.

fn set_volume(&mut self, volume: f32)

Set the volume of the sound.

fn set_position<P: Into<Vector3f>>(&mut self, position: P)

Set the 3D position of the sound in the audio scene.

fn set_relative_to_listener(&mut self, relative: bool)

Make the sound’s position relative to the listener or absolute.

fn set_min_distance(&mut self, distance: f32)

Set the minimum distance of the sound.

fn set_attenuation(&mut self, attenuation: f32)

Set the attenuation factor of the sound.

fn pitch(&self) -> f32

Get the pitch of the sound.

fn volume(&self) -> f32

Get the volume of the sound.

fn position(&self) -> Vector3f

Get the 3D position of the sound in the audio scene.

fn is_relative_to_listener(&self) -> bool

Tell whether the sound’s position is relative to the listener or is absolute.

fn min_distance(&self) -> f32

Get the minimum distance of the sound.

fn attenuation(&self) -> f32

Get the attenuation factor of the sound.

impl Send for Sound<'_>

impl Sync for Sound<'_>