Struct KeyboardInput

Source

pub struct KeyboardInput {
    pub key_code: KeyCode,
    pub logical_key: Key,
    pub state: ButtonState,
    pub text: Option<SmolStr>,
    pub repeat: bool,
    pub window: Entity,
}

Expand description

A keyboard input event.

This event is the translated version of the WindowEvent::KeyboardInput from the winit crate. It is available to the end user and can be used for game logic.

§Usage

The event is consumed inside of the keyboard_input_system to update the ButtonInput<KeyCode> resource.

Fields§

§key_code: KeyCode

The physical key code of the key.

§logical_key: Key

The logical key of the input

§state: ButtonState

The press state of the key.

§text: Option<SmolStr>

Contains the text produced by this keypress.

In most cases this is identical to the content of the Character variant of logical_key. However, on Windows when a dead key was pressed earlier but cannot be combined with the character from this keypress, the produced text will consist of two characters: the dead-key-character followed by the character resulting from this keypress.

This is None if the current keypress cannot be interpreted as text.

§repeat: bool

On some systems, holding down a key for some period of time causes that key to be repeated as though it were being pressed and released repeatedly. This field is true if this event is the result of one of those repeats.

§window: Entity

Window that received the input.

Struct KeyboardInputCopy item path

§Usage

Fields§

Trait Implementations§

impl Clone for KeyboardInput

fn clone(&self) -> KeyboardInput

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

impl Debug for KeyboardInput

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

impl<'de> Deserialize<'de> for KeyboardInput

fn deserialize<__D>( __deserializer: __D, ) -> Result<KeyboardInput, <__D as Deserializer<'de>>::Error>where __D: Deserializer<'de>,

impl Event for KeyboardInputwhere KeyboardInput: Send + Sync + 'static,

const AUTO_PROPAGATE: bool = false

type Traversal = ()

fn register_component_id(world: &mut World) -> ComponentId

fn component_id(world: &World) -> Option<ComponentId>

impl From<KeyboardInput> for WindowEvent

fn from(e: KeyboardInput) -> WindowEvent

type This<'from_arg> = &'from_arg KeyboardInput

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static KeyboardInput as FromArg>::This<'_>, ArgError>

type This<'from_arg> = &'from_arg mut KeyboardInput

fn from_arg( arg: Arg<'_>, ) -> Result<<&'static mut KeyboardInput as FromArg>::This<'_>, ArgError>

type This<'from_arg> = KeyboardInput

fn from_arg( arg: Arg<'_>, ) -> Result<<KeyboardInput as FromArg>::This<'_>, ArgError>

fn from_reflect( reflect: &(dyn PartialReflect + 'static), ) -> Option<KeyboardInput>

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

fn ownership() -> Ownership

fn ownership() -> Ownership

fn ownership() -> Ownership

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

impl Hash for KeyboardInput

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

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

fn into_return<'into_return>(self) -> Return<'into_return>where &KeyboardInput: 'into_return,

fn into_return<'into_return>(self) -> Return<'into_return>where &mut KeyboardInput: 'into_return,

fn into_return<'into_return>(self) -> Return<'into_return>where KeyboardInput: 'into_return,

impl PartialEq for KeyboardInput

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

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

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

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

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

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

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

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

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

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

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

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

fn is_dynamic(&self) -> bool

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

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

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

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

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

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

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

impl Serialize for KeyboardInput

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where __S: Serializer,

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

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

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

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

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

fn field_len(&self) -> usize

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

fn to_dynamic_struct(&self) -> DynamicStruct

fn clone_dynamic(&self) -> DynamicStruct

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

impl TypePath for KeyboardInputwhere KeyboardInput: Any + Send + Sync,

Struct KeyboardInput

fn deserialize<D>( deserializer: D, ) -> Result<KeyboardInput, <D as Deserializer<'de>>::Error>
where __D: Deserializer<'de>,

impl Event for KeyboardInput
where KeyboardInput: Send + Sync + 'static,

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

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

fn into_return<'into_return>(self) -> Return<'into_return>
where &KeyboardInput: 'into_return,

fn into_return<'into_return>(self) -> Return<'into_return>
where &mut KeyboardInput: 'into_return,

fn into_return<'into_return>(self) -> Return<'into_return>
where KeyboardInput: 'into_return,

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

impl TypePath for KeyboardInput
where KeyboardInput: Any + Send + Sync,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

fn conv<T>(self) -> T
where Self: Into<T>,

impl<T> Downcast for T
where T: Any,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSend for T
where T: Any + Send,

impl<T> DowncastSync for T
where T: Any + Send + Sync,

impl<T> DynEq for T
where T: Any + Eq,