Struct leafwing_input_manager::input_streams::MutableInputStreams

pub struct MutableInputStreams<'a> {
    pub gamepad_buttons: &'a mut Input<GamepadButton>,
    pub gamepad_button_axes: &'a mut Axis<GamepadButton>,
    pub gamepad_axes: &'a mut Axis<GamepadAxis>,
    pub gamepads: &'a mut Gamepads,
    pub gamepad_events: &'a mut Events<GamepadEventRaw>,
    pub keycodes: &'a mut Input<KeyCode>,
    pub keyboard_events: &'a mut Events<KeyboardInput>,
    pub mouse_buttons: &'a mut Input<MouseButton>,
    pub mouse_button_events: &'a mut Events<MouseButtonInput>,
    pub mouse_wheel: &'a mut Events<MouseWheel>,
    pub mouse_motion: &'a mut Events<MouseMotion>,
    pub associated_gamepad: Option<Gamepad>,
}

A mutable collection of [Input] structs, which can be used for mocking user inputs.

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

Fields

gamepad_buttons: &'a mut Input<GamepadButton>

A [GamepadButton] [Input] stream

gamepad_button_axes: &'a mut Axis<GamepadButton>

A [GamepadButton] [Axis] stream

gamepad_axes: &'a mut Axis<GamepadAxis>

A [GamepadAxis] [Axis] stream

gamepads: &'a mut Gamepads

A list of registered [Gamepads]

gamepad_events: &'a mut Events<GamepadEventRaw>

Events used for mocking gamepad-related inputs

keycodes: &'a mut Input<KeyCode>

A [KeyCode] [Input] stream

keyboard_events: &'a mut Events<KeyboardInput>

Events used for mocking keyboard-related inputs

mouse_buttons: &'a mut Input<MouseButton>

A [MouseButton] [Input] stream

mouse_button_events: &'a mut Events<MouseButtonInput>

Events used for mocking [MouseButton] inputs

mouse_wheel: &'a mut Events<MouseWheel>

A [MouseWheel] event stream

mouse_motion: &'a mut Events<MouseMotion>

A [MouseMotion] event stream

associated_gamepad: Option<Gamepad>

The [Gamepad] that this struct will detect inputs from

Implementations

impl<'a> MutableInputStreams<'a>

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

Construct a MutableInputStreams from the [World]

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.

Trait Implementations

impl<'a> Debug for MutableInputStreams<'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.

impl MockInput for MutableInputStreams<'_>

fn send_input(&mut self, input: impl Into<UserInput>)

Send the specified user_input directly

fn send_input_as_gamepad(
    &mut self,
    input: impl Into<UserInput>,
    gamepad: Option<Gamepad>
)

Send the specified user_input directly, using the specified gamepad

fn release_input(&mut self, input: impl Into<UserInput>)

Releases the specified user_input directly

fn release_input_as_gamepad(
    &mut self,
    input: impl Into<UserInput>,
    gamepad: Option<Gamepad>
)

Releases the specified user_input directly, using the specified gamepad

fn pressed(&self, input: impl Into<UserInput>) -> bool

Is the provided user_input pressed?

fn pressed_for_gamepad(
    &self,
    input: impl Into<UserInput>,
    gamepad: Option<Gamepad>
) -> bool

Is the provided user_input pressed for the provided [Gamepad]?

fn reset_inputs(&mut self)

Clears all user input streams, resetting them to their default state

fn click_button<Marker: Component>(&mut self)

Presses all bevy::ui buttons with the matching Marker component

fn hover_button<Marker: Component>(&mut self)

Hovers over all bevy::ui buttons with the matching Marker component