Struct bevy::input::gamepad::GamepadRumbleIntensity

pub struct GamepadRumbleIntensity {
    pub strong_motor: f32,
    pub weak_motor: f32,
}

The intensity at which a gamepad’s force-feedback motors may rumble.

Fields

strong_motor: f32

The rumble intensity of the strong gamepad motor.

Ranges from 0.0 to 1.0.

By convention, this is usually a low-frequency motor on the left-hand side of the gamepad, though it may vary across platforms and hardware.

weak_motor: f32

The rumble intensity of the weak gamepad motor.

Ranges from 0.0 to 1.0.

By convention, this is usually a high-frequency motor on the right-hand side of the gamepad, though it may vary across platforms and hardware.

Implementations

impl GamepadRumbleIntensity

pub const MAX: GamepadRumbleIntensity = _

Rumble both gamepad motors at maximum intensity.

pub const WEAK_MAX: GamepadRumbleIntensity = _

Rumble the weak motor at maximum intensity.

pub const STRONG_MAX: GamepadRumbleIntensity = _

Rumble the strong motor at maximum intensity.

pub const fn weak_motor(intensity: f32) -> GamepadRumbleIntensity

Creates a new rumble intensity with weak motor intensity set to the given value.

Clamped within the 0.0 to 1.0 range.

Examples found in repository

examples/input/gamepad_rumble.rs (line 55)

fn gamepad_system(
    gamepads: Res<Gamepads>,
    button_inputs: Res<ButtonInput<GamepadButton>>,
    mut rumble_requests: EventWriter<GamepadRumbleRequest>,
) {
    for gamepad in gamepads.iter() {
        let button_pressed = |button| {
            button_inputs.just_pressed(GamepadButton {
                gamepad,
                button_type: button,
            })
        };

        if button_pressed(GamepadButtonType::North) {
            info!(
                "North face button: strong (low-frequency) with low intensity for rumble for 5 seconds. Press multiple times to increase intensity."
            );
            rumble_requests.send(GamepadRumbleRequest::Add {
                gamepad,
                intensity: GamepadRumbleIntensity::strong_motor(0.1),
                duration: Duration::from_secs(5),
            });
        }

        if button_pressed(GamepadButtonType::East) {
            info!("East face button: maximum rumble on both motors for 5 seconds");
            rumble_requests.send(GamepadRumbleRequest::Add {
                gamepad,
                duration: Duration::from_secs(5),
                intensity: GamepadRumbleIntensity::MAX,
            });
        }

        if button_pressed(GamepadButtonType::South) {
            info!("South face button: low-intensity rumble on the weak motor for 0.5 seconds");
            rumble_requests.send(GamepadRumbleRequest::Add {
                gamepad,
                duration: Duration::from_secs_f32(0.5),
                intensity: GamepadRumbleIntensity::weak_motor(0.25),
            });
        }

        if button_pressed(GamepadButtonType::West) {
            info!("West face button: custom rumble intensity for 5 second");
            rumble_requests.send(GamepadRumbleRequest::Add {
                gamepad,
                intensity: GamepadRumbleIntensity {
                    // intensity low-frequency motor, usually on the left-hand side
                    strong_motor: 0.5,
                    // intensity of high-frequency motor, usually on the right-hand side
                    weak_motor: 0.25,
                },
                duration: Duration::from_secs(5),
            });
        }

        if button_pressed(GamepadButtonType::Start) {
            info!("Start button: Interrupt the current rumble");
            rumble_requests.send(GamepadRumbleRequest::Stop { gamepad });
        }
    }
}

pub const fn strong_motor(intensity: f32) -> GamepadRumbleIntensity

Creates a new rumble intensity with strong motor intensity set to the given value.

Clamped within the 0.0 to 1.0 range.

Examples found in repository

examples/input/gamepad_rumble.rs (line 36)

fn gamepad_system(
    gamepads: Res<Gamepads>,
    button_inputs: Res<ButtonInput<GamepadButton>>,
    mut rumble_requests: EventWriter<GamepadRumbleRequest>,
) {
    for gamepad in gamepads.iter() {
        let button_pressed = |button| {
            button_inputs.just_pressed(GamepadButton {
                gamepad,
                button_type: button,
            })
        };

        if button_pressed(GamepadButtonType::North) {
            info!(
                "North face button: strong (low-frequency) with low intensity for rumble for 5 seconds. Press multiple times to increase intensity."
            );
            rumble_requests.send(GamepadRumbleRequest::Add {
                gamepad,
                intensity: GamepadRumbleIntensity::strong_motor(0.1),
                duration: Duration::from_secs(5),
            });
        }

        if button_pressed(GamepadButtonType::East) {
            info!("East face button: maximum rumble on both motors for 5 seconds");
            rumble_requests.send(GamepadRumbleRequest::Add {
                gamepad,
                duration: Duration::from_secs(5),
                intensity: GamepadRumbleIntensity::MAX,
            });
        }

        if button_pressed(GamepadButtonType::South) {
            info!("South face button: low-intensity rumble on the weak motor for 0.5 seconds");
            rumble_requests.send(GamepadRumbleRequest::Add {
                gamepad,
                duration: Duration::from_secs_f32(0.5),
                intensity: GamepadRumbleIntensity::weak_motor(0.25),
            });
        }

        if button_pressed(GamepadButtonType::West) {
            info!("West face button: custom rumble intensity for 5 second");
            rumble_requests.send(GamepadRumbleRequest::Add {
                gamepad,
                intensity: GamepadRumbleIntensity {
                    // intensity low-frequency motor, usually on the left-hand side
                    strong_motor: 0.5,
                    // intensity of high-frequency motor, usually on the right-hand side
                    weak_motor: 0.25,
                },
                duration: Duration::from_secs(5),
            });
        }

        if button_pressed(GamepadButtonType::Start) {
            info!("Start button: Interrupt the current rumble");
            rumble_requests.send(GamepadRumbleRequest::Stop { gamepad });
        }
    }
}

Trait Implementations

impl Clone for GamepadRumbleIntensity

fn clone(&self) -> GamepadRumbleIntensity

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GamepadRumbleIntensity

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

Formats the value using the given formatter.

impl PartialEq for GamepadRumbleIntensity

fn eq(&self, other: &GamepadRumbleIntensity) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for GamepadRumbleIntensity

impl StructuralPartialEq for GamepadRumbleIntensity