Struct AxisBinding 

pub struct AxisBinding { /* private fields */ }

One control that reads back a number, and the knobs it reads through.

A pad lane, a trigger, a joystick axis and a button composite read in -1..=1. A PointerDelta lane and a WheelDelta lane read how far they moved through scale, which nothing clamps.

Implementations

impl AxisBinding

pub const DEFAULT_DEADZONE: f32 = 0.15

Distance a pad or joystick control moves before it reads at all.

pub fn pad(axis: PadAxis) -> Self

One lane of the standard gamepad layout.

Examples found in repository

examples/breakout-game.rs (line 243)

    fn bindings(&self) -> Vec<AxisBinding> {
        match self {
            Move::Paddle => vec![
                AxisBinding::from(ButtonAxis {
                    negative: Key::A,
                    positive: Key::D,
                }),
                AxisBinding::from(ButtonAxis {
                    negative: Key::Left,
                    positive: Key::Right,
                }),
                AxisBinding::from(ButtonAxis {
                    negative: Pad::DPadLeft,
                    positive: Pad::DPadRight,
                }),
                AxisBinding::pad(PadAxis::LeftX),
            ],
        }
    }

examples/input-lab.rs (line 93)

    fn bindings(&self) -> Vec<AxisBinding> {
        match self {
            Self::LeftX => vec![
                AxisBinding::pad(PadAxis::LeftX),
                ButtonAxis {
                    negative: Key::A,
                    positive: Key::D,
                }
                .into(),
            ],
            Self::LeftY => vec![
                AxisBinding::pad(PadAxis::LeftY),
                ButtonAxis {
                    negative: Key::S,
                    positive: Key::W,
                }
                .into(),
            ],
            Self::RightX => vec![
                AxisBinding::pad(PadAxis::RightX),
                ButtonAxis {
                    negative: Key::J,
                    positive: Key::L,
                }
                .into(),
            ],
            Self::RightY => vec![
                AxisBinding::pad(PadAxis::RightY),
                ButtonAxis {
                    negative: Key::K,
                    positive: Key::I,
                }
                .into(),
            ],
            Self::LeftTrigger => vec![
                AxisBinding::pad(PadAxis::LeftTrigger),
                ButtonAxis {
                    negative: Key::Minus,
                    positive: Key::BracketLeft,
                }
                .into(),
            ],
            Self::RightTrigger => vec![
                AxisBinding::pad(PadAxis::RightTrigger),
                ButtonAxis {
                    negative: Key::Equal,
                    positive: Key::BracketRight,
                }
                .into(),
            ],
            Self::PointerSideways => vec![AxisBinding::pointer_delta(PointerDelta::Sideways)],
            Self::PointerUp => vec![AxisBinding::pointer_delta(PointerDelta::Up)],
            Self::WheelUp => vec![AxisBinding::wheel(WheelDelta::Up)],
            Self::WheelSideways => vec![AxisBinding::wheel(WheelDelta::Sideways)],
        }
    }

pub fn joystick(control: JoystickControl) -> Self

One axis of a device with no standard layout, by the number its platform reports for it; capture one rather than writing one.

pub fn pointer_delta(lane: PointerDelta) -> Self

Pixels one lane of the pointer moved this frame, read through scale alone: nothing clamps what it reads.

Examples found in repository

examples/animation.rs (line 582)

    fn bindings(&self) -> Vec<AxisBinding> {
        match self {
            Axis::CameraYaw => {
                vec![AxisBinding::pointer_delta(PointerDelta::Sideways).scale(CAMERA_YAW_SCALE)]
            }
            Axis::CameraPitch => {
                vec![AxisBinding::pointer_delta(PointerDelta::Up).scale(CAMERA_PITCH_SCALE)]
            }
        }
    }

examples/input-lab.rs (line 140)

    fn bindings(&self) -> Vec<AxisBinding> {
        match self {
            Self::LeftX => vec![
                AxisBinding::pad(PadAxis::LeftX),
                ButtonAxis {
                    negative: Key::A,
                    positive: Key::D,
                }
                .into(),
            ],
            Self::LeftY => vec![
                AxisBinding::pad(PadAxis::LeftY),
                ButtonAxis {
                    negative: Key::S,
                    positive: Key::W,
                }
                .into(),
            ],
            Self::RightX => vec![
                AxisBinding::pad(PadAxis::RightX),
                ButtonAxis {
                    negative: Key::J,
                    positive: Key::L,
                }
                .into(),
            ],
            Self::RightY => vec![
                AxisBinding::pad(PadAxis::RightY),
                ButtonAxis {
                    negative: Key::K,
                    positive: Key::I,
                }
                .into(),
            ],
            Self::LeftTrigger => vec![
                AxisBinding::pad(PadAxis::LeftTrigger),
                ButtonAxis {
                    negative: Key::Minus,
                    positive: Key::BracketLeft,
                }
                .into(),
            ],
            Self::RightTrigger => vec![
                AxisBinding::pad(PadAxis::RightTrigger),
                ButtonAxis {
                    negative: Key::Equal,
                    positive: Key::BracketRight,
                }
                .into(),
            ],
            Self::PointerSideways => vec![AxisBinding::pointer_delta(PointerDelta::Sideways)],
            Self::PointerUp => vec![AxisBinding::pointer_delta(PointerDelta::Up)],
            Self::WheelUp => vec![AxisBinding::wheel(WheelDelta::Up)],
            Self::WheelSideways => vec![AxisBinding::wheel(WheelDelta::Sideways)],
        }
    }

pub fn wheel(lane: WheelDelta) -> Self

Notches lane of the wheel turned this frame, read through scale alone: nothing clamps what it reads.

Examples found in repository

examples/input-lab.rs (line 142)

    fn bindings(&self) -> Vec<AxisBinding> {
        match self {
            Self::LeftX => vec![
                AxisBinding::pad(PadAxis::LeftX),
                ButtonAxis {
                    negative: Key::A,
                    positive: Key::D,
                }
                .into(),
            ],
            Self::LeftY => vec![
                AxisBinding::pad(PadAxis::LeftY),
                ButtonAxis {
                    negative: Key::S,
                    positive: Key::W,
                }
                .into(),
            ],
            Self::RightX => vec![
                AxisBinding::pad(PadAxis::RightX),
                ButtonAxis {
                    negative: Key::J,
                    positive: Key::L,
                }
                .into(),
            ],
            Self::RightY => vec![
                AxisBinding::pad(PadAxis::RightY),
                ButtonAxis {
                    negative: Key::K,
                    positive: Key::I,
                }
                .into(),
            ],
            Self::LeftTrigger => vec![
                AxisBinding::pad(PadAxis::LeftTrigger),
                ButtonAxis {
                    negative: Key::Minus,
                    positive: Key::BracketLeft,
                }
                .into(),
            ],
            Self::RightTrigger => vec![
                AxisBinding::pad(PadAxis::RightTrigger),
                ButtonAxis {
                    negative: Key::Equal,
                    positive: Key::BracketRight,
                }
                .into(),
            ],
            Self::PointerSideways => vec![AxisBinding::pointer_delta(PointerDelta::Sideways)],
            Self::PointerUp => vec![AxisBinding::pointer_delta(PointerDelta::Up)],
            Self::WheelUp => vec![AxisBinding::wheel(WheelDelta::Up)],
            Self::WheelSideways => vec![AxisBinding::wheel(WheelDelta::Sideways)],
        }
    }

impl AxisBinding

pub fn deadzone(self, deadzone: f32) -> Self

Reads nothing until the control has moved deadzone of its way, then stretches what is left over the whole range; AxisBinding::DEFAULT_DEADZONE for a pad or joystick control, and nothing for the rest.

Clamped into 0.0..=0.95, a fraction of that way, so a control always keeps a range to read in.

pub fn scale(self, scale: f32) -> Self

Multiplies what the control reads, as a fraction of it; 1.0 until set.

A control with a range of its own keeps to it whatever this is set to. A pointer lane or a wheel lane has none, so it reads its own distance times this: pixels for a pointer lane, notches for a wheel lane.

Examples found in repository

examples/material-playground.rs (line 705)

    fn bindings(&self) -> Vec<AxisBinding> {
        match self {
            Self::Wheel => vec![AxisBinding::from(WheelDelta::Up).scale(4.0)],
        }
    }

examples/ui-fonts.rs (line 511)

    fn bindings(&self) -> Vec<AxisBinding> {
        match self {
            Self::Wheel => vec![AxisBinding::from(WheelDelta::Up).scale(4.0)],
        }
    }

examples/animation.rs (line 582)

    fn bindings(&self) -> Vec<AxisBinding> {
        match self {
            Axis::CameraYaw => {
                vec![AxisBinding::pointer_delta(PointerDelta::Sideways).scale(CAMERA_YAW_SCALE)]
            }
            Axis::CameraPitch => {
                vec![AxisBinding::pointer_delta(PointerDelta::Up).scale(CAMERA_PITCH_SCALE)]
            }
        }
    }

pub fn invert(self) -> Self

Flips which way the control counts, for a control that reads the other way round.

Trait Implementations

impl Clone for AxisBinding

fn clone(&self) -> AxisBinding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for AxisBinding

impl Debug for AxisBinding

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

Formats the value using the given formatter.

impl Display for AxisBinding

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

Formats the value using the given formatter.

impl<N: Into<ButtonBinding>, P: Into<ButtonBinding>> From<ButtonAxis<N, P>> for AxisBinding

fn from(pair: ButtonAxis<N, P>) -> Self

A pair, negative counting down and positive counting up; a diagonal never reads longer than a straight direction.

impl From<PadAxis> for AxisBinding

fn from(axis: PadAxis) -> Self

Converts to this type from the input type.

impl From<PointerDelta> for AxisBinding

fn from(lane: PointerDelta) -> Self

Converts to this type from the input type.

impl From<WheelDelta> for AxisBinding

fn from(lane: WheelDelta) -> Self

Converts to this type from the input type.

impl PartialEq for AxisBinding

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for AxisBinding