Struct GamepadVirtualAxis

pub struct GamepadVirtualAxis { /* private fields */ }

A virtual single-axis control constructed by combining two GamepadButtonTypes. One button represents the negative direction (left for the X-axis, down for the Y-axis), while the other represents the positive direction (right for the X-axis, up for the Y-axis).

By default, it reads from any connected gamepad. Use the InputMap::set_gamepad for specific ones.

Value Processing

You can customize how the values are processed using a pipeline of processors. See WithAxisProcessingPipelineExt for details.

The raw value is determined based on the state of the associated buttons:

• -1.0 if only the negative button is currently pressed.
• 1.0 if only the positive button is currently pressed.
• 0.0 if neither button is pressed, or both are pressed simultaneously.

use bevy::prelude::*;
use bevy::input::InputPlugin;
use leafwing_input_manager::prelude::*;

let mut app = App::new();
app.add_plugins(InputPlugin);

// Define a virtual Y-axis using D-pad "up" and "down" buttons
let axis = GamepadVirtualAxis::DPAD_Y;

// Pressing either button activates the input
GamepadButtonType::DPadUp.press(app.world_mut());
app.update();
assert_eq!(app.read_axis_values(axis), [1.0]);

// You can configure a processing pipeline (e.g., doubling the value)
let doubled = GamepadVirtualAxis::DPAD_Y.sensitivity(2.0);
assert_eq!(app.read_axis_values(doubled), [2.0]);

Implementations

impl GamepadVirtualAxis

pub const DPAD_X: Self = _

The GamepadVirtualAxis using the horizontal D-Pad button mappings. No processing is applied to raw data from the gamepad.

• GamepadButtonType::DPadLeft for negative direction.
• GamepadButtonType::DPadRight for positive direction.

pub const DPAD_Y: Self = _

The GamepadVirtualAxis using the vertical D-Pad button mappings. No processing is applied to raw data from the gamepad.

• GamepadButtonType::DPadDown for negative direction.
• GamepadButtonType::DPadUp for positive direction.

pub const ACTION_PAD_X: Self = _

The GamepadVirtualAxis using the horizontal action pad button mappings. No processing is applied to raw data from the gamepad.

• GamepadButtonType::West for negative direction.
• GamepadButtonType::East for positive direction.

pub const ACTION_PAD_Y: Self = _

The GamepadVirtualAxis using the vertical action pad button mappings. No processing is applied to raw data from the gamepad.

• GamepadButtonType::South for negative direction.
• GamepadButtonType::North for positive direction.

pub const fn new( negative: GamepadButtonType, positive: GamepadButtonType, ) -> Self

Creates a new GamepadVirtualAxis with two given GamepadButtonTypes. No processing is applied to raw data from the gamepad.

Trait Implementations

impl Axislike for GamepadVirtualAxis

fn value(&self, input_store: &CentralInputStore, gamepad: Gamepad) -> f32

Retrieves the current value of this axis after processing by the associated processors.

fn set_value_as_gamepad( &self, world: &mut World, value: f32, gamepad: Option<Gamepad>, )

Sends a GamepadEvent::Button event on the provided Gamepad.

If the value is negative, the negative button is pressed. If the value is positive, the positive button is pressed. If the value is zero, neither button is pressed.

fn set_value(&self, world: &mut World, value: f32)

Simulate an axis-like input by sending the appropriate event.

impl Clone for GamepadVirtualAxis

fn clone(&self) -> GamepadVirtualAxis

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for GamepadVirtualAxis

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GamepadVirtualAxis

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromReflect for GamepadVirtualAxis

where Self: Any + Send + Sync, GamepadButtonType: FromReflect + TypePath + RegisterForReflection, Vec<AxisProcessor>: FromReflect + TypePath + RegisterForReflection,

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

Constructs a concrete instance of Self from a reflected value.

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

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for GamepadVirtualAxis

where Self: Any + Send + Sync, GamepadButtonType: FromReflect + TypePath + RegisterForReflection, Vec<AxisProcessor>: FromReflect + TypePath + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Hash for GamepadVirtualAxis

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for GamepadVirtualAxis

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for GamepadVirtualAxis

where Self: Any + Send + Sync, GamepadButtonType: FromReflect + TypePath + RegisterForReflection, Vec<AxisProcessor>: FromReflect + TypePath + RegisterForReflection,

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

Returns the TypeInfo of the type represented by this value.

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

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

Returns the value as a &mut dyn Any.

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

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

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

Casts this type to a mutable reflected value.

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

Clones the value as a Reflect trait object.

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

Performs a type-checked assignment of a reflected value to this value.

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

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

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

Returns an immutable enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

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

Returns an owned enumeration of “kinds” of type.

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

Returns a “partial equality” comparison result.

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

Applies a reflected value to this value.

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

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

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

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<'de> RegisterTypeTag<'de, dyn Axislike> for GamepadVirtualAxis

fn register_typetag(registry: &mut InfallibleMapRegistry<dyn Axislike>)

Registers the specified type tag into the InfallibleMapRegistry.

impl Serialize for GamepadVirtualAxis

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for GamepadVirtualAxis

where Self: Any + Send + Sync, GamepadButtonType: FromReflect + TypePath + RegisterForReflection, Vec<AxisProcessor>: FromReflect + TypePath + RegisterForReflection,

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

Returns a reference to the value of the field named name as a &dyn Reflect.

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

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

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

Returns a reference to the value of the field with index index as a &dyn Reflect.

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

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

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

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

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

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl TypePath for GamepadVirtualAxis

where Self: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

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

Returns the name of the type, or None if it is anonymous.

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

Returns the name of the crate the type is in, or None if it is anonymous.

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

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for GamepadVirtualAxis

where Self: Any + Send + Sync, GamepadButtonType: FromReflect + TypePath + RegisterForReflection, Vec<AxisProcessor>: FromReflect + TypePath + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl UserInput for GamepadVirtualAxis

fn kind(&self) -> InputControlKind

GamepadVirtualAxis acts as an axis input.

fn decompose(&self) -> BasicInputs

Returns the two GamepadButtonTypes used by this axis.

impl WithAxisProcessingPipelineExt for GamepadVirtualAxis

fn reset_processing_pipeline(self) -> Self

Resets the processing pipeline, removing any currently applied processors.

fn replace_processing_pipeline( self, processors: impl IntoIterator<Item = AxisProcessor>, ) -> Self

Replaces the current processing pipeline with the given AxisProcessors.

fn with_processor(self, processor: impl Into<AxisProcessor>) -> Self

Appends the given AxisProcessor as the next processing step.

fn digital(self) -> Self

Appends an AxisProcessor::Digital processor as the next processing step, similar to f32::signum but returning 0.0 for zero values.

fn inverted(self) -> Self

Appends an AxisProcessor::Inverted processor as the next processing step, flipping the sign of values on the axis.

fn sensitivity(self, sensitivity: f32) -> Self

Appends an AxisProcessor::Sensitivity processor as the next processing step, multiplying values on the axis with the given sensitivity factor.

fn with_bounds(self, min: f32, max: f32) -> Self

Appends an AxisBounds processor as the next processing step, restricting values within the range [min, max] on the axis.

fn with_bounds_symmetric(self, threshold: f32) -> Self

Appends an AxisBounds processor as the next processing step, restricting values within the range [-threshold, threshold].

fn at_least(self, min: f32) -> Self

Appends an AxisBounds processor as the next processing step, restricting values to a minimum value.

fn at_most(self, max: f32) -> Self

Appends an AxisBounds processor as the next processing step, restricting values to a maximum value.

fn with_deadzone(self, negative_max: f32, positive_min: f32) -> Self

Appends an AxisDeadZone processor as the next processing step, excluding values within the dead zone range [negative_max, positive_min] on the axis, treating them as zeros, then normalizing non-excluded input values into the “live zone”, the remaining range within the AxisBounds::magnitude(1.0) after dead zone exclusion.

fn with_deadzone_symmetric(self, threshold: f32) -> Self

Appends an AxisDeadZone processor as the next processing step, excluding values within the dead zone range [-threshold, threshold] on the axis, treating them as zeros, then normalizing non-excluded input values into the “live zone”, the remaining range within the AxisBounds::magnitude(1.0) after dead zone exclusion.

fn only_positive(self, positive_min: f32) -> Self

Appends an AxisDeadZone processor as the next processing step, only passing positive values that greater than positive_min and then normalizing them into the “live zone” range [positive_min, 1.0].

fn only_negative(self, negative_max: f32) -> Self

Appends an AxisDeadZone processor as the next processing step, only passing negative values that less than negative_max and then normalizing them into the “live zone” range [-1.0, negative_max].

fn with_deadzone_unscaled(self, negative_max: f32, positive_min: f32) -> Self

Appends an AxisExclusion processor as the next processing step, ignoring values within the dead zone range [negative_max, positive_min] on the axis, treating them as zeros.

fn with_deadzone_symmetric_unscaled(self, threshold: f32) -> Self

Appends an AxisExclusion processor as the next processing step, ignoring values within the dead zone range [-threshold, threshold] on the axis, treating them as zeros.

fn only_positive_unscaled(self, positive_min: f32) -> Self

Appends an AxisExclusion processor as the next processing step, only passing positive values that greater than positive_min.

fn only_negative_unscaled(self, negative_max: f32) -> Self

Appends an AxisExclusion processor as the next processing step, only passing negative values that less than negative_max.

impl Eq for GamepadVirtualAxis

impl StructuralPartialEq for GamepadVirtualAxis