Struct InputActionState

pub struct InputActionState<'w, A: InputAction> { /* private fields */ }

Provides read-only access to the current state of an input action.

An action may be in either:

• Active status: The action is currently active and has an associated value.
• Idle status: The action is not active.

Usage

Use this type in systems that need to read the state of an input action.

Notes

• The state is updated every frame based on the values poured into the InputActionDrain.
• To check if the action is active without cloning the value, use InputActionState::is_active.

Implementations

impl<A: InputAction> InputActionState<'_, A>

pub fn is_active(&self) -> bool

Returns whether the input action is currently active.

pub fn state(&self) -> Option<A>

Returns the current state of the input action.

The input action can be in one of two statuses:

• Active: The action is currently active, and this method returns Some(value).
• Idle: The action is not active, and this method returns None.

Notes

• If the action is Active, this method clones the associated value. If you only need to check whether the action is active (without cloning the value), use InputActionState::is_active.
• Cloning the value may have a performance cost, so avoid calling this method repeatedly if you only need to check the active status.

Trait Implementations

impl<'w, A: Debug + InputAction> Debug for InputActionState<'w, A>

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

Formats the value using the given formatter.

impl<A: InputAction> SystemParam for InputActionState<'_, A>

type State = FetchState<A>

Used to store data which persists across invocations of a system.

type Item<'w, 's> = InputActionState<'w, A>

The item type returned when constructing this system param. The value of this associated type should be Self, instantiated with new lifetimes.

fn init_state(world: &mut World, system_meta: &mut SystemMeta) -> Self::State

Registers any World access used by this SystemParam and creates a new instance of this param’s State.

unsafe fn new_archetype( state: &mut Self::State, archetype: &Archetype, system_meta: &mut SystemMeta, )

For the specified Archetype, registers the components accessed by this SystemParam (if applicable).a

fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)

Applies any deferred mutations stored in this SystemParam’s state. This is used to apply Commands during ApplyDeferred.

fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )

Queues any deferred mutations to be applied at the next ApplyDeferred.

unsafe fn validate_param<'w, 's>( state: &'s Self::State, _system_meta: &SystemMeta, _world: UnsafeWorldCell<'w>, ) -> Result<(), SystemParamValidationError>

Validates that the param can be acquired by the get_param.

unsafe fn get_param<'w, 's>( state: &'s mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> Self::Item<'w, 's>

Creates a parameter to be passed into a SystemParamFunction.

impl<'w, 's, A: InputAction> ReadOnlySystemParam for InputActionState<'w, A>

where Res<'w, InputActionState<A>>: ReadOnlySystemParam,