Trait Buttonlike 

pub trait Buttonlike:
    UserInput
    + DynClone
    + DynEq
    + DynHash
    + Reflect
    + Serialize {
    // Required method
    fn get_pressed(
        &self,
        input_store: &CentralInputStore,
        gamepad: Entity,
    ) -> Option<bool>;

    // Provided methods
    fn pressed(&self, input_store: &CentralInputStore, gamepad: Entity) -> bool { ... }
    fn released(&self, input_store: &CentralInputStore, gamepad: Entity) -> bool { ... }
    fn value(&self, input_store: &CentralInputStore, gamepad: Entity) -> f32 { ... }
    fn get_value(
        &self,
        input_store: &CentralInputStore,
        gamepad: Entity,
    ) -> Option<f32> { ... }
    fn press(&self, world: &mut World) { ... }
    fn press_as_gamepad(&self, world: &mut World, _gamepad: Option<Entity>) { ... }
    fn release(&self, world: &mut World) { ... }
    fn release_as_gamepad(&self, world: &mut World, _gamepad: Option<Entity>) { ... }
    fn set_value(&self, world: &mut World, value: f32) { ... }
    fn set_value_as_gamepad(
        &self,
        world: &mut World,
        value: f32,
        _gamepad: Option<Entity>,
    ) { ... }
}

A trait used for buttonlike user inputs, which can be pressed or released with a value for how much they are pressed.

Required Methods

fn get_pressed( &self, input_store: &CentralInputStore, gamepad: Entity, ) -> Option<bool>

Checks if the input is currently active.

Provided Methods

fn pressed(&self, input_store: &CentralInputStore, gamepad: Entity) -> bool

Checks if the input is currently active.

fn released(&self, input_store: &CentralInputStore, gamepad: Entity) -> bool

Checks if the input is currently inactive.

fn value(&self, input_store: &CentralInputStore, gamepad: Entity) -> f32

Gets the current value of the button as an f32.

The returned value should be between 0.0 and 1.0, with 0.0 representing the input being fully released and 1.0 representing the input being fully pressed.

fn get_value( &self, input_store: &CentralInputStore, gamepad: Entity, ) -> Option<f32>

Gets the current value of the button as an f32. Or None if the input has never been pressed or set.

The returned value should be between 0.0 and 1.0, with 0.0 representing the input being fully released and 1.0 representing the input being fully pressed.

fn press(&self, world: &mut World)

Simulates a press of the buttonlike input by sending the appropriate message.

This method defaults to calling Buttonlike::press_as_gamepad if not overridden, as is the case for gamepad-reliant inputs.

fn press_as_gamepad(&self, world: &mut World, _gamepad: Option<Entity>)

Simulate a press of the buttonlike input, pretending to be the provided gamepad Entity.

This method defaults to calling Buttonlike::press if not overridden, as is the case for things like mouse buttons and keyboard keys.

Use find_gamepad inside of this method to search for a gamepad to press the button on if the provided gamepad is None.

fn release(&self, world: &mut World)

Simulates a release of the buttonlike input by sending the appropriate message.

This method defaults to calling Buttonlike::release_as_gamepad if not overridden, as is the case for gamepad-reliant inputs.

fn release_as_gamepad(&self, world: &mut World, _gamepad: Option<Entity>)

Simulate a release of the buttonlike input, pretending to be the provided gamepad Entity.

This method defaults to calling Buttonlike::release if not overridden, as is the case for things like mouse buttons and keyboard keys.

Use find_gamepad inside of this method to search for a gamepad to press the button on if the provided gamepad is None.

fn set_value(&self, world: &mut World, value: f32)

Simulate a value change of the buttonlike input by sending the appropriate message.

This method defaults to calling Buttonlike::set_value_as_gamepad if not overridden, as is the case for gamepad-reliant inputs.

Also updates the state of the button based on the value:

• If value > 0.0, the button will be pressed.
• If value <= 0.0, the button will be released.

fn set_value_as_gamepad( &self, world: &mut World, value: f32, _gamepad: Option<Entity>, )

Simulate a value change of the buttonlike input, pretending to be the provided gamepad Entity.

This method defaults to calling Buttonlike::set_value if not overridden, as is the case for things like a mouse wheel.

Also updates the state of the button based on the value:

• If value > 0.0, the button will be pressed.
• If value <= 0.0, the button will be released.

Use find_gamepad inside of this method to search for a gamepad to press the button on if the provided gamepad is None.

Trait Implementations

impl<'de> Deserialize<'de> for Box<dyn Buttonlike>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromReflect for Box<dyn Buttonlike>

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for Box<dyn Buttonlike>

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(_registry: &mut TypeRegistry)

Registers other types needed by this type.

impl<'hash> Hash for dyn Buttonlike + 'hash

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

impl<'hash> Hash for dyn Buttonlike + Send + 'hash

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

impl<'hash> Hash for dyn Buttonlike + Send + Sync + 'hash

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

impl<'hash> Hash for dyn Buttonlike + Sync + 'hash

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

impl<'eq> PartialEq<&Box<dyn Buttonlike + 'eq>> for Box<dyn Buttonlike + 'eq>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'eq> PartialEq<&Box<dyn Buttonlike + Send + 'eq>> for Box<dyn Buttonlike + Send + 'eq>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'eq> PartialEq<&Box<dyn Buttonlike + Sync + Send + 'eq>> for Box<dyn Buttonlike + Send + Sync + 'eq>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'eq> PartialEq<&Box<dyn Buttonlike + Sync + 'eq>> for Box<dyn Buttonlike + Sync + 'eq>

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'eq> PartialEq for dyn Buttonlike + 'eq

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'eq> PartialEq for dyn Buttonlike + Send + 'eq

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'eq> PartialEq for dyn Buttonlike + Send + Sync + 'eq

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'eq> PartialEq for dyn Buttonlike + Sync + 'eq

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialReflect for Box<dyn Buttonlike>

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

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

Returns an immutable enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

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

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

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

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

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

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for Box<dyn Buttonlike>

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

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

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

impl<'de> RegisterTypeTag<'de, dyn Buttonlike> for ButtonlikeChord

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Buttonlike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl<'de> RegisterTypeTag<'de, dyn Buttonlike> for GamepadButton

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Buttonlike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl<'de> RegisterTypeTag<'de, dyn Buttonlike> for GamepadControlDirection

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Buttonlike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl<'de> RegisterTypeTag<'de, dyn Buttonlike> for KeyCode

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Buttonlike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl<'de> RegisterTypeTag<'de, dyn Buttonlike> for ModifierKey

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Buttonlike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl<'de> RegisterTypeTag<'de, dyn Buttonlike> for MouseButton

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Buttonlike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl<'de> RegisterTypeTag<'de, dyn Buttonlike> for MouseMoveDirection

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Buttonlike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl<'de> RegisterTypeTag<'de, dyn Buttonlike> for MouseScrollDirection

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Buttonlike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl<'de> RegisterTypeTag<'de, dyn Buttonlike> for SpecificGamepadButton

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Buttonlike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl Serialize for dyn Buttonlike + '_

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TypePath for Box<dyn Buttonlike>

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Box<dyn Buttonlike>

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl<'eq> Eq for dyn Buttonlike + 'eq

impl<'eq> Eq for dyn Buttonlike + Send + 'eq

impl<'eq> Eq for dyn Buttonlike + Send + Sync + 'eq

impl<'eq> Eq for dyn Buttonlike + Sync + 'eq

Implementations on Foreign Types

impl Buttonlike for GamepadButton

fn get_pressed( &self, input_store: &CentralInputStore, gamepad: Entity, ) -> Option<bool>

Checks if the specified button is currently pressed down.

fn value(&self, input_store: &CentralInputStore, gamepad: Entity) -> f32

Retrieves the current value of the specified button.

This will be 0.0 if the button is released, and 1.0 if it is pressed. Physically triggerlike buttons will return a value between 0.0 and 1.0, depending on how far the button is pressed.

fn press_as_gamepad(&self, world: &mut World, gamepad: Option<Entity>)

Sends a RawGamepadEvent::Button message with a magnitude of 1.0 in the direction defined by self on the provided gamepad Entity.

fn release_as_gamepad(&self, world: &mut World, gamepad: Option<Entity>)

Sends a RawGamepadEvent::Button message with a magnitude of 0.0 in the direction defined by self on the provided gamepad Entity.

fn set_value_as_gamepad( &self, world: &mut World, value: f32, gamepad: Option<Entity>, )

Sends a RawGamepadEvent::Button message with the specified value in the direction defined by self on the provided gamepad Entity.

impl Buttonlike for KeyCode

fn get_pressed( &self, input_store: &CentralInputStore, _gamepad: Entity, ) -> Option<bool>

Checks if the specified key is currently pressed down.

fn press(&self, world: &mut World)

Sends a fake KeyboardInput message to the world with ButtonState::Pressed.

Note

The logical_key and window fields will be filled with placeholder values.

fn release(&self, world: &mut World)

Sends a fake KeyboardInput message to the world with ButtonState::Released.

Note

The logical_key and window fields will be filled with placeholder values.

fn set_value(&self, world: &mut World, value: f32)

If the value is greater than 0.0, press the key; otherwise release it.

impl Buttonlike for MouseButton

fn get_pressed( &self, input_store: &CentralInputStore, _gamepad: Entity, ) -> Option<bool>

Checks if the specified button is currently pressed down.

fn press(&self, world: &mut World)

Sends a fake MouseButtonInput message to the world with ButtonState::Pressed.

Note

The window field will be filled with a placeholder value.

fn release(&self, world: &mut World)

Sends a fake MouseButtonInput message to the world with ButtonState::Released.

Note

The window field will be filled with a placeholder value.

fn set_value(&self, world: &mut World, value: f32)

If the value is greater than 0.0, press the key; otherwise release it.

Implementors

impl Buttonlike for ModifierKey

impl Buttonlike for ButtonlikeChord

impl Buttonlike for GamepadControlDirection

impl Buttonlike for SpecificGamepadButton

impl Buttonlike for MouseMoveDirection

impl Buttonlike for MouseScrollDirection