Struct Gamepad 

pub struct Gamepad<'a> { /* private fields */ }

Represents handle to game controller.

Using this struct you can access cached gamepad state, information about gamepad such as name or UUID and manage force feedback effects.

Implementations

impl Gamepad<'_>

pub fn name(&self) -> &str

Returns the mapping name if it exists otherwise returns the os provided name.

Examples found in repository

examples/gamepad.rs (line 38)

fn choose_gamepad() -> Option<GamepadId> {
    let input = gamepad::input();
    let gamepads: Vec<_> = input.gamepads().collect();

    use ui::prelude::*;
    let ui = Col::with_gap(
        10.0,
        gamepads
            .iter()
            .enumerate()
            .map(|(i, (_, pad))| flat::Button::primary_text(i, pad.name()))
            .collect::<Vec<_>>(),
    );

    draw_ui(ui, Vec2::splat(10.0));

    Some(
        gamepads
            .get(*all_elements_interacted_this_frame().first()?)?
            .0,
    )
}

pub fn map_name(&self) -> Option<&str>

if mapping_source() is SdlMappings returns the name of the mapping used by the gamepad. Otherwise returns None.

pub fn os_name(&self) -> &str

Returns the name of the gamepad supplied by the OS.

pub fn uuid(&self) -> [u8; 16]

Returns gamepad’s UUID.

It is recommended to process with the UUID crate. Use Uuid::from_bytes method to create a Uuid from the returned bytes.

pub fn vendor_id(&self) -> Option<u16>

Returns the vendor ID, as assigned by the USB-IF, when available.

pub fn product_id(&self) -> Option<u16>

Returns the product ID, as assigned by the vendor, when available.

pub fn state(&self) -> &GamepadState

Returns cached gamepad state.

pub fn is_connected(&self) -> bool

Returns true if gamepad is connected.

pub fn is_pressed(&self, btn: Button) -> bool

Examines cached gamepad state to check if given button is pressed. Panics if btn is Unknown.

If you know Code of the element that you want to examine, it’s recommended to use methods directly on State, because this version have to check which Code is mapped to element of gamepad.

Examples found in repository

examples/gamepad.rs (line 129)

fn draw_dpad(pad: Gamepad, center: Vec2) {
    const SIZE: f32 = 100.0;
    const THICKNESS: f32 = 65.0;
    const OUTLINE: f32 = 5.0;

    let half = THICKNESS / 2.0;
    let half_outline = OUTLINE / 2.0;
    let arm = SIZE - half;

    let buttons = [
        (
            gamepad::Button::DPadUp,
            vec2(center.x - half, center.y - SIZE),
            vec2(THICKNESS, arm + half_outline),
        ),
        (
            gamepad::Button::DPadDown,
            vec2(center.x - half, center.y + half - half_outline),
            vec2(THICKNESS, arm),
        ),
        (
            gamepad::Button::DPadLeft,
            vec2(center.x - SIZE, center.y - half),
            vec2(arm + half_outline, THICKNESS),
        ),
        (
            gamepad::Button::DPadRight,
            vec2(center.x + half - half_outline, center.y - half),
            vec2(arm, THICKNESS),
        ),
    ];

    let points = [
        vec2(center.x - half, center.y - SIZE),
        vec2(center.x + half, center.y - SIZE),
        vec2(center.x + half, center.y - half),
        vec2(center.x + SIZE, center.y - half),
        vec2(center.x + SIZE, center.y + half),
        vec2(center.x + half, center.y + half),
        vec2(center.x + half, center.y + SIZE),
        vec2(center.x - half, center.y + SIZE),
        vec2(center.x - half, center.y + half),
        vec2(center.x - SIZE, center.y + half),
        vec2(center.x - SIZE, center.y - half),
        vec2(center.x - half, center.y - half),
        vec2(center.x - half, center.y - SIZE),
    ];

    draw_connected_path(&points, OUTLINE, SECONDARY);

    for (button, pos, size) in buttons {
        if pad.is_pressed(button) {
            draw_rect(pos, size, PRIMARY);
        }
    }
}

fn draw_buttons(pad: Gamepad, center: Vec2) {
    const RADIUS: f32 = 30.0;
    const DIST: f32 = 70.0;
    const OUTLINE: f32 = 5.0;

    let buttons = [
        (gamepad::Button::North, vec2(center.x, center.y - DIST)),
        (gamepad::Button::South, vec2(center.x, center.y + DIST)),
        (gamepad::Button::West, vec2(center.x - DIST, center.y)),
        (gamepad::Button::East, vec2(center.x + DIST, center.y)),
    ];

    for (button, pos) in buttons {
        if pad.is_pressed(button) {
            draw_circle(pos, RADIUS + OUTLINE, PRIMARY);
        } else {
            draw_circle_outline(pos, RADIUS, SECONDARY, OUTLINE);
        }
    }
}

pub fn value(&self, axis: Axis) -> f32

Examines cached gamepad state to check axis’s value. Panics if axis is Unknown.

If you know Code of the element that you want to examine, it’s recommended to use methods directly on State, because this version have to check which Code is mapped to element of gamepad.

pub fn button_data(&self, btn: Button) -> Option<&ButtonData>

Returns button state and when it changed.

If you know Code of the element that you want to examine, it’s recommended to use methods directly on State, because this version have to check which Code is mapped to element of gamepad.

pub fn axis_data(&self, axis: Axis) -> Option<&AxisData>

Returns axis state and when it changed.

If you know Code of the element that you want to examine, it’s recommended to use methods directly on State, because this version have to check which Code is mapped to element of gamepad.

pub fn power_info(&self) -> PowerInfo

Returns device’s power supply state. See PowerInfo for details.

pub fn mapping_source(&self) -> MappingSource

Returns source of gamepad mapping. Can be used to filter gamepads which do not provide unified controller layout.

use gilrs::MappingSource;

for (_, gamepad) in gilrs.gamepads().filter(
    |gp| gp.1.mapping_source() != MappingSource::None)
{
    println!("{} is ready to use!", gamepad.name());
}

pub fn is_ff_supported(&self) -> bool

Returns true if force feedback is supported by device.

pub fn set_listener_position<Vec3>(&self, position: Vec3) -> Result<(), Error>

where Vec3: Into<[f32; 3]>,

Change gamepad position used by force feedback effects.

pub fn axis_or_btn_name(&self, ec: Code) -> Option<AxisOrBtn>

Returns AxisOrBtn mapped to Code.

pub fn button_code(&self, btn: Button) -> Option<Code>

Returns Code associated with btn.

pub fn axis_code(&self, axis: Axis) -> Option<Code>

Returns Code associated with axis.

pub fn deadzone(&self, axis: Code) -> Option<f32>

Returns area in which axis events should be ignored.

pub fn id(&self) -> GamepadId

Returns ID of gamepad.

Trait Implementations

impl<'a> Clone for Gamepad<'a>

fn clone(&self) -> Gamepad<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Gamepad<'a>

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

Formats the value using the given formatter.

impl GamepadExt for Gamepad<'_>

fn right_stick(&self) -> Vec2

fn left_stick(&self) -> Vec2

fn d_pad(&self) -> Vec2

impl LinuxGamepadExt for Gamepad<'_>

Available on Linux only.

fn devpath(&self) -> &Path

Returns the device node of gamepad.

impl<'a> Copy for Gamepad<'a>