Enum GamepadRumbleRequest

Source

pub enum GamepadRumbleRequest {
    Add {
        duration: Duration,
        intensity: GamepadRumbleIntensity,
        gamepad: Entity,
    },
    Stop {
        gamepad: Entity,
    },
}

Expand description

An event that controls force-feedback rumbling of a Gamepad entity.

§Notes

Does nothing if the gamepad or platform does not support rumble.

§Example

fn rumble_gamepad_system(
    mut rumble_requests: EventWriter<GamepadRumbleRequest>,
    gamepads: Query<Entity, With<Gamepad>>,
) {
    for entity in gamepads.iter() {
        rumble_requests.send(GamepadRumbleRequest::Add {
            gamepad: entity,
            intensity: GamepadRumbleIntensity::MAX,
            duration: Duration::from_secs_f32(0.5),
        });
    }
}

Variants§

§

Add

Add a rumble to the given gamepad.

Simultaneous rumble effects add up to the sum of their strengths.

Consequently, if two rumbles at half intensity are added at the same time, their intensities will be added up, and the controller will rumble at full intensity until one of the rumbles finishes, then the rumble will continue at the intensity of the remaining event.

To replace an existing rumble, send a GamepadRumbleRequest::Stop event first.

Fields

§duration: Duration

How long the gamepad should rumble.

§intensity: GamepadRumbleIntensity

How intense the rumble should be.

§gamepad: Entity

The gamepad to rumble.

§

Stop

Stop all running rumbles on the given Entity.

Fields

§gamepad: Entity

The gamepad to stop rumble.

Enum GamepadRumbleRequestCopy item path

§Notes

§Example

Variants§

Add

Fields

Stop

Fields

Implementations§

impl GamepadRumbleRequest

pub fn gamepad(&self) -> Entity

Trait Implementations§

impl Clone for GamepadRumbleRequest

fn clone(&self) -> GamepadRumbleRequest

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

impl Component for GamepadRumbleRequestwhere 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, )

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

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

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

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

fn index_of(&self, __name_param: &str) -> Option<usize>

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

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

fn field_len(&self) -> usize

fn variant_name(&self) -> &str

fn variant_index(&self) -> usize

fn variant_type(&self) -> VariantType

fn clone_dynamic(&self) -> DynamicEnum

fn is_variant(&self, variant_type: VariantType) -> bool

fn variant_path(&self) -> String

fn get_represented_enum_info(&self) -> Option<&'static EnumInfo>

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

const AUTO_PROPAGATE: bool = false

type Traversal = ()

fn from_reflect(__param0: &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)

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

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

fn try_apply( &mut self, __value_param: &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 apply(&mut self, value: &(dyn PartialReflect + 'static))

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

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 TypePath for GamepadRumbleRequestwhere GamepadRumbleRequest: 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

Auto Trait Implementations§

impl Freeze for GamepadRumbleRequest

impl RefUnwindSafe for GamepadRumbleRequest

impl Send for GamepadRumbleRequest

impl Sync for GamepadRumbleRequest

impl Unpin for GamepadRumbleRequest

Enum GamepadRumbleRequest

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

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

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

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

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

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<T> ToOwned for T
where T: Clone,

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

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,