Struct bevy::input::prelude::TouchInput

source ·

pub struct TouchInput {
    pub phase: TouchPhase,
    pub position: Vec2,
    pub window: Entity,
    pub force: Option<ForceTouch>,
    pub id: u64,
}

Expand description

A touch input event.

§Logic

Every time the user touches the screen, a new TouchPhase::Started event with an unique identifier for the finger is generated. When the finger is lifted, the TouchPhase::Ended event is generated with the same finger id.

After a TouchPhase::Started event has been emitted, there may be zero or more TouchPhase::Moved events when the finger is moved or the touch pressure changes.

The finger id may be reused by the system after an TouchPhase::Ended event. The user should assume that a new TouchPhase::Started event received with the same id has nothing to do with the old finger and is a new finger.

A TouchPhase::Canceled event is emitted when the system has canceled tracking this touch, such as when the window loses focus, or on iOS if the user moves the device against their face.

§Note

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

Fields§

§phase: TouchPhase

The phase of the touch input.

§position: Vec2

The position of the finger on the touchscreen.

§window: Entity

The window entity registering the touch.

§force: Option<ForceTouch>

Describes how hard the screen was pressed.

May be None if the platform does not support pressure sensitivity. This feature is only available on iOS 9.0+ and Windows 8+.

§id: u64

The unique identifier of the finger.

Struct bevy::input::prelude::TouchInputCopy item path

§Logic

§Note

Fields§

Trait Implementations§

impl Clone for TouchInput

fn clone(&self) -> TouchInput

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

impl Component for TouchInputwhere TouchInput: Send + Sync + 'static,

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

fn register_component_hooks(_hooks: &mut ComponentHooks)

impl Debug for TouchInput

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

impl<'de> Deserialize<'de> for TouchInput

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

impl From<&TouchInput> for Touch

fn from(input: &TouchInput) -> Touch

impl From<TouchInput> for WinitEvent

fn from(e: TouchInput) -> WinitEvent

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

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

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

impl PartialEq for TouchInput

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

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

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

fn into_any(self: Box<TouchInput>) -> 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<TouchInput>) -> Box<dyn Reflect>

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

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

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

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

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

fn reflect_kind(&self) -> ReflectKind

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

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

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

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

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

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

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

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

fn is_dynamic(&self) -> bool

impl Serialize for TouchInput

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 Reflect + 'static)>

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

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

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

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

fn field_len(&self) -> usize

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

fn clone_dynamic(&self) -> DynamicStruct

impl TypePath for TouchInputwhere TouchInput: 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 Copy for TouchInput

impl Event for TouchInputwhere TouchInput: Send + Sync + 'static,

impl StructuralPartialEq for TouchInput

Auto Trait Implementations§

impl Freeze for TouchInput

impl RefUnwindSafe for TouchInput

impl Send for TouchInput

impl Sync for TouchInput

impl Unpin for TouchInput

impl UnwindSafe for TouchInput

Blanket Implementations§

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

fn type_id(&self) -> TypeId

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

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

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

fn borrow(&self) -> &T

Struct bevy::input::prelude::TouchInput

impl Component for TouchInput
where TouchInput: Send + Sync + 'static,

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

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

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

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

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<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<C> DynamicBundle for C
where C: Component,

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

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,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

impl<T> Serialize for T
where T: Serialize + ?Sized,