Struct leafwing_input_manager::input_streams::InputStreams

pub struct InputStreams<'a> {
    pub gamepad_buttons: &'a Input<GamepadButton>,
    pub gamepad_button_axes: &'a Axis<GamepadButton>,
    pub gamepad_axes: &'a Axis<GamepadAxis>,
    pub gamepads: &'a Gamepads,
    pub keycode: &'a Input<KeyCode>,
    pub mouse_button: &'a Input<MouseButton>,
    pub mouse_wheel: &'a Events<MouseWheel>,
    pub mouse_motion: &'a Events<MouseMotion>,
    pub associated_gamepad: Option<Gamepad>,
}

A collection of [Input] structs, which can be used to update an InputMap.

These are typically collected via a system from the World as resources.

Fields

gamepad_buttons: &'a Input<GamepadButton>

A [GamepadButton] [Input] stream

gamepad_button_axes: &'a Axis<GamepadButton>

A [GamepadButton] [Axis] stream

gamepad_axes: &'a Axis<GamepadAxis>

A [GamepadAxis] [Axis] stream

gamepads: &'a Gamepads

A list of registered gamepads

keycode: &'a Input<KeyCode>

A [KeyCode] [Input] stream

mouse_button: &'a Input<MouseButton>

A [MouseButton] [Input] stream

mouse_wheel: &'a Events<MouseWheel>

A [MouseWheel] event stream

mouse_motion: &'a Events<MouseMotion>

A [MouseMotion] event stream

associated_gamepad: Option<Gamepad>

The [Gamepad] that this struct will detect inputs from

Implementations

impl<'a> InputStreams<'a>

pub fn from_world(world: &'a World, gamepad: Option<Gamepad>) -> Self

Construct an InputStreams from a [World]

impl<'a> InputStreams<'a>

pub fn guess_gamepad(&self) -> Option<Gamepad>

Guess which registered [Gamepad] should be used.

If an associated gamepad is set, use that. Otherwise use the first registered gamepad, if any.

pub fn input_pressed(&self, input: &UserInput) -> bool

Is the input matched by the InputStreams?

pub fn any_pressed(&self, inputs: &PetitSet<UserInput, 16>) -> bool

Is at least one of the inputs pressed?

pub fn button_pressed(&self, button: InputKind) -> bool

Is the button pressed?

pub fn all_buttons_pressed(&self, buttons: &PetitSet<InputKind, 8>) -> bool

Are all of the buttons pressed?

pub fn input_value(&self, input: &UserInput) -> f32

Get the “value” of the input.

For binary inputs such as buttons, this will always be either 0.0 or 1.0. For analog inputs such as axes, this will be the axis value.

UserInput::Chord inputs are also considered binary and will return 0.0 or 1.0 based on whether the chord has been pressed.

Warning

If you need to ensure that this value is always in the range [-1., 1.], be sure to clamp the reutrned data.

pub fn input_axis_pair(&self, input: &UserInput) -> Option<DualAxisData>

Get the axis pair associated to the user input.

If input is not a DualAxis or VirtualDPad, returns None.

See ActionState::action_axis_pair() for usage.

Warning

If you need to ensure that this value is always in the range [-1., 1.], be sure to clamp the returned data.

Trait Implementations

impl<'a> Clone for InputStreams<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for InputStreams<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a MutableInputStreams<'a>> for InputStreams<'a>

fn from(mutable_streams: &'a MutableInputStreams<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<MutableInputStreams<'a>> for InputStreams<'a>

fn from(mutable_streams: MutableInputStreams<'a>) -> Self

Converts to this type from the input type.