Struct KeyboardInput

Source

pub struct KeyboardInput {
    pub key_code: KeyCode,
    pub logical_key: Key,
    pub state: ButtonState,
    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.

§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 Component for KeyboardInputwhere Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::SparseSet

fn register_component_hooks(_hooks: &mut ComponentHooks)

fn register_required_components( _component_id: ComponentId, _components: &mut Components, _storages: &mut Storages, _required_components: &mut RequiredComponents, _inheritance_depth: u16, )

impl Debug for KeyboardInput

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

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

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

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

const AUTO_PROPAGATE: bool = false

type Traversal = ()

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

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

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

impl Hash for KeyboardInput

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

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

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 clone_value(&self) -> Box<dyn PartialReflect>

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

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

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

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

fn as_partial_reflect(&self) -> &dyn PartialReflect

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

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

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

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

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

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

fn is_dynamic(&self) -> bool

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

fn as_any(&self) -> &dyn Any

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

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

fn as_reflect(&self) -> &dyn Reflect

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

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

impl Serialize for KeyboardInput

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

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

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

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

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

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

fn field_len(&self) -> usize

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

fn clone_dynamic(&self) -> DynamicStruct

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

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

fn type_path() -> &'static str

fn short_type_path() -> &'static str

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

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

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

fn type_info() -> &'static TypeInfo

impl Eq for KeyboardInput

impl StructuralPartialEq for KeyboardInput

Auto Trait Implementations§

impl Freeze for KeyboardInput

impl RefUnwindSafe for KeyboardInput

impl Send for KeyboardInput

impl Sync for KeyboardInput

impl Unpin for KeyboardInput

Struct KeyboardInput

impl Component for KeyboardInput
where Self: Send + Sync + 'static,

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

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

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

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

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

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

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

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

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

impl<C> Bundle for C
where C: Component,

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

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

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

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

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

impl<T> DynHash for T
where T: DynEq + Hash,

impl<C> DynamicBundle for C
where C: Component,

impl<T> DynamicTypePath for T
where T: TypePath,

impl<T> DynamicTyped for T
where T: Typed,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<S> GetField for S
where S: Struct,

fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,

fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
where T: Reflect,

impl<T> GetPath for T
where T: Reflect + ?Sized,

fn path<'p, T>( &self, path: impl ReflectPath<'p>, ) -> Result<&T, ReflectPathError<'p>>
where T: Reflect,

fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut T, ReflectPathError<'p>>
where T: Reflect,