Struct bevy_internal::input::gamepad::GamepadEventRaw

pub struct GamepadEventRaw {
    pub gamepad: Gamepad,
    pub event_type: GamepadEventType,
}

A raw event of a Gamepad.

This event is the translated version of the EventType from the GilRs crate. It is available to the end user and can be used for game logic.

Differences

The difference between the EventType from the GilRs crate and the GamepadEventRaw is that the latter has less events, because the button pressing logic is handled through the generic Input<T> instead of through events.

The difference between the GamepadEventRaw and the GamepadEvent can be seen in the documentation of the GamepadEvent.

Gamepad input mocking

The following example showcases how to mock gamepad input by manually sending GamepadEventRaws.

#[derive(Resource)]
struct MyResource(bool);

// This system sets the bool inside `MyResource` to `true` if the `South` button of the first gamepad is pressed.
fn change_resource_on_gamepad_button_press(
    mut my_resource: ResMut<MyResource>,
    gamepads: Res<Gamepads>,
    button_inputs: ResMut<Input<GamepadButton>>,
) {
    let gamepad = gamepads.iter().next().unwrap();
    let gamepad_button = GamepadButton::new(gamepad, GamepadButtonType::South);

    my_resource.0 = button_inputs.pressed(gamepad_button);
}

// Create our app.
let mut app = App::new();

// Add the input plugin and the system/resource we want to test.
app.add_plugin(InputPlugin)
    .insert_resource(MyResource(false))
    .add_system(change_resource_on_gamepad_button_press);

// Define our dummy gamepad input data.
let gamepad = Gamepad::new(0);
let button_type = GamepadButtonType::South;

// Send the gamepad connected event to mark our gamepad as connected.
// This updates the `Gamepads` resource accordingly.
let info = GamepadInfo { name: "Mock Gamepad".into() };
app.world.send_event(GamepadEventRaw::new(gamepad, GamepadEventType::Connected(info)));

// Send the gamepad input event to mark the `South` gamepad button as pressed.
// This updates the `Input<GamepadButton>` resource accordingly.
app.world.send_event(GamepadEventRaw::new(
    gamepad,
    GamepadEventType::ButtonChanged(button_type, 1.0)
));

// Advance the execution of the schedule by a single cycle.
app.update();

// At this point you can check if your game logic corresponded correctly to the gamepad input.
// In this example we are checking if the bool in `MyResource` was updated from `false` to `true`.
assert!(app.world.resource::<MyResource>().0);

// Send the gamepad input event to mark the `South` gamepad button as released.
// This updates the `Input<GamepadButton>` resource accordingly.
app.world.send_event(GamepadEventRaw::new(
    gamepad,
    GamepadEventType::ButtonChanged(button_type, 0.0)
));

// Advance the execution of the schedule by another cycle.
app.update();

// Check if the bool in `MyResource` was updated from `true` to `false`.
assert!(!app.world.resource::<MyResource>().0);

Fields

gamepad: Gamepad

The gamepad this event corresponds to.

event_type: GamepadEventType

The type of the event.

Implementations

impl GamepadEventRaw

pub fn new(gamepad: Gamepad, event_type: GamepadEventType) -> GamepadEventRaw

Creates a new GamepadEventRaw.

Trait Implementations

impl Clone for GamepadEventRaw

fn clone(&self) -> GamepadEventRaw

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GamepadEventRaw

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

Formats the value using the given formatter.

impl FromReflect for GamepadEventRawwhere
    Gamepad: FromReflect,
    GamepadEventType: FromReflect,

fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<GamepadEventRaw>

Constructs a concrete instance of Self from a reflected value.

impl GetTypeRegistration for GamepadEventRaw

fn get_type_registration() -> TypeRegistration

impl PartialEq<GamepadEventRaw> for GamepadEventRaw

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for GamepadEventRaw

fn type_name(&self) -> &str

Returns the type name of the underlying type.

fn get_type_info(&self) -> &'static TypeInfo

Returns the TypeInfo of the underlying type.

fn into_any(
    self: Box<GamepadEventRaw, Global>
) -> Box<dyn Any + 'static, Global>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(
    self: Box<GamepadEventRaw, Global>
) -> Box<dyn Reflect + 'static, Global>

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable reflected value.

fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

Clones the value as a Reflect trait object.

fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

Performs a type-checked assignment of a reflected value to this value.

fn apply(&mut self, value: &(dyn Reflect + 'static))

Applies a reflected value to this value.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<GamepadEventRaw, Global>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

impl Struct for GamepadEventRaw

fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field named name as a &dyn Reflect.

fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn Reflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl Typed for GamepadEventRaw

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl StructuralPartialEq for GamepadEventRaw