Struct Axis2Binding 

pub struct Axis2Binding { /* private fields */ }

A pair of controls that read back a vector, and the knobs they read through.

A stick and a button composite read no longer than 1. The pointer and the wheel read how far they moved through scale, which nothing clamps.

Implementations

impl Axis2Binding

pub fn stick(stick: Stick) -> Self

Both lanes of one stick of the standard gamepad layout.

Examples found in repository

examples/sound-lab.rs (line 320)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Move::Walk => vec![
                Axis2Binding::from(ButtonAxis2 {
                    left: Key::A,
                    right: Key::D,
                    down: Key::S,
                    up: Key::W,
                }),
                Axis2Binding::stick(Stick::Left),
            ],
        }
    }

examples/sprite-adventure.rs (line 796)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Move::Walk => vec![
                Axis2Binding::from(ButtonAxis2 {
                    left: Key::A,
                    right: Key::D,
                    down: Key::S,
                    up: Key::W,
                }),
                Axis2Binding::from(ButtonAxis2 {
                    left: Key::Left,
                    right: Key::Right,
                    down: Key::Down,
                    up: Key::Up,
                }),
                Axis2Binding::stick(Stick::Left),
            ],
        }
    }

examples/input-lab.rs (line 162)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::LeftStick => vec![
                Axis2Binding::stick(Stick::Left),
                ButtonAxis2 {
                    left: Key::A,
                    right: Key::D,
                    down: Key::S,
                    up: Key::W,
                }
                .into(),
            ],
            Self::RightStick => vec![
                Axis2Binding::stick(Stick::Right),
                ButtonAxis2 {
                    left: Key::J,
                    right: Key::L,
                    down: Key::K,
                    up: Key::I,
                }
                .into(),
            ],
            Self::Pointer => vec![Axis2Binding::pointer()],
            Self::Wheel => vec![Axis2Binding::wheel()],
        }
    }

pub fn pointer() -> Self

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

Examples found in repository

examples/material-playground.rs (line 691)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::Look => vec![Axis2Binding::pointer().scale(LOOK_SENSITIVITY)],
        }
    }

examples/ui-fonts.rs (line 498)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::Look => vec![Axis2Binding::pointer().scale(TURN_SENSITIVITY)],
        }
    }

examples/stress-preview.rs (line 166)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::Pan => vec![
                Axis2Binding::from(ButtonAxis2 {
                    left: Key::A,
                    right: Key::D,
                    down: Key::S,
                    up: Key::W,
                }),
                Axis2Binding::from(ButtonAxis2 {
                    left: Key::Left,
                    right: Key::Right,
                    down: Key::Down,
                    up: Key::Up,
                }),
            ],
            Self::Look => vec![Axis2Binding::pointer().scale(LOOK_SENSITIVITY)],
        }
    }

examples/input-lab.rs (line 181)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::LeftStick => vec![
                Axis2Binding::stick(Stick::Left),
                ButtonAxis2 {
                    left: Key::A,
                    right: Key::D,
                    down: Key::S,
                    up: Key::W,
                }
                .into(),
            ],
            Self::RightStick => vec![
                Axis2Binding::stick(Stick::Right),
                ButtonAxis2 {
                    left: Key::J,
                    right: Key::L,
                    down: Key::K,
                    up: Key::I,
                }
                .into(),
            ],
            Self::Pointer => vec![Axis2Binding::pointer()],
            Self::Wheel => vec![Axis2Binding::wheel()],
        }
    }

pub fn wheel() -> Self

Notches the wheel turned this frame, both lanes as one vector: WheelDelta::Sideways is x and WheelDelta::Up is y. Read through scale alone, so nothing clamps what it reads.

Examples found in repository

examples/input-lab.rs (line 182)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::LeftStick => vec![
                Axis2Binding::stick(Stick::Left),
                ButtonAxis2 {
                    left: Key::A,
                    right: Key::D,
                    down: Key::S,
                    up: Key::W,
                }
                .into(),
            ],
            Self::RightStick => vec![
                Axis2Binding::stick(Stick::Right),
                ButtonAxis2 {
                    left: Key::J,
                    right: Key::L,
                    down: Key::K,
                    up: Key::I,
                }
                .into(),
            ],
            Self::Pointer => vec![Axis2Binding::pointer()],
            Self::Wheel => vec![Axis2Binding::wheel()],
        }
    }

impl Axis2Binding

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 691)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::Look => vec![Axis2Binding::pointer().scale(LOOK_SENSITIVITY)],
        }
    }

examples/ui-fonts.rs (line 498)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::Look => vec![Axis2Binding::pointer().scale(TURN_SENSITIVITY)],
        }
    }

examples/stress-preview.rs (line 166)

    fn bindings(&self) -> Vec<Axis2Binding> {
        match self {
            Self::Pan => vec![
                Axis2Binding::from(ButtonAxis2 {
                    left: Key::A,
                    right: Key::D,
                    down: Key::S,
                    up: Key::W,
                }),
                Axis2Binding::from(ButtonAxis2 {
                    left: Key::Left,
                    right: Key::Right,
                    down: Key::Down,
                    up: Key::Up,
                }),
            ],
            Self::Look => vec![Axis2Binding::pointer().scale(LOOK_SENSITIVITY)],
        }
    }

pub fn invert(self) -> Self

Flips the upward lane, for a control that reads the other way round.

Trait Implementations

impl Clone for Axis2Binding

fn clone(&self) -> Axis2Binding

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Axis2Binding

impl Debug for Axis2Binding

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

Formats the value using the given formatter.

impl Display for Axis2Binding

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

Formats the value using the given formatter.

impl<L, R, D, U> From<ButtonAxis2<L, R, D, U>> for Axis2Binding

where L: Into<ButtonBinding>, R: Into<ButtonBinding>, D: Into<ButtonBinding>, U: Into<ButtonBinding>,

fn from(quad: ButtonAxis2<L, R, D, U>) -> Self

Four buttons around a center, the way WASD is laid out; a diagonal reads as long as a straight direction, never longer. The vector is x right minus left, y up minus down; what that means in the world is the game’s call.

impl From<Stick> for Axis2Binding

fn from(stick: Stick) -> Self

Converts to this type from the input type.

impl PartialEq for Axis2Binding

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Axis2Binding