Struct KeyboardVirtualAxis

pub struct KeyboardVirtualAxis { /* private fields */ }

A virtual single-axis control constructed from two KeyCodes. One key 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).

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::*;
use leafwing_input_manager::user_input::testing_utils::FetchUserInput;
use leafwing_input_manager::plugin::{AccumulatorPlugin, CentralInputStorePlugin};

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

// Define a virtual Y-axis using arrow "up" and "down" keys
let axis = KeyboardVirtualAxis::VERTICAL_ARROW_KEYS;

// Pressing either key activates the input
KeyCode::ArrowUp.press(app.world_mut());
app.update();
assert_eq!(app.read_axis_value(axis), 1.0);

// You can configure a processing pipeline (e.g., doubling the value)
let doubled = KeyboardVirtualAxis::VERTICAL_ARROW_KEYS.sensitivity(2.0);
assert_eq!(app.read_axis_value(doubled), 2.0);

Implementations

impl KeyboardVirtualAxis

pub const VERTICAL_ARROW_KEYS: Self = _

The KeyboardVirtualAxis using the vertical arrow key mappings.

• KeyCode::ArrowDown for negative direction.
• KeyCode::ArrowUp for positive direction.

pub const HORIZONTAL_ARROW_KEYS: Self = _

The KeyboardVirtualAxis using the horizontal arrow key mappings.

• KeyCode::ArrowLeft for negative direction.
• KeyCode::ArrowRight for positive direction.

pub const WS: Self = _

The KeyboardVirtualAxis using the common W/S key mappings.

• KeyCode::KeyS for negative direction.
• KeyCode::KeyW for positive direction.

pub const AD: Self = _

The KeyboardVirtualAxis using the common A/D key mappings.

• KeyCode::KeyA for negative direction.
• KeyCode::KeyD for positive direction.

pub const VERTICAL_NUMPAD: Self = _

The KeyboardVirtualAxis using the vertical numpad key mappings.

• KeyCode::Numpad2 for negative direction.
• KeyCode::Numpad8 for positive direction.

pub const HORIZONTAL_NUMPAD: Self = _

The KeyboardVirtualAxis using the horizontal numpad key mappings.

• KeyCode::Numpad4 for negative direction.
• KeyCode::Numpad6 for positive direction.

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

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

Trait Implementations

impl Axislike for KeyboardVirtualAxis

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(&self, world: &mut World, value: f32)

Sends a KeyboardInput event.

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_as_gamepad( &self, world: &mut World, value: f32, _gamepad: Option<Gamepad>, )

Simulate an axis-like input, pretending to be the provided Gamepad.

impl Clone for KeyboardVirtualAxis

fn clone(&self) -> KeyboardVirtualAxis

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for KeyboardVirtualAxis

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeyboardVirtualAxis

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromReflect for KeyboardVirtualAxis

where Self: Any + Send + Sync, KeyCode: 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 KeyboardVirtualAxis

where Self: Any + Send + Sync, KeyCode: 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 KeyboardVirtualAxis

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 KeyboardVirtualAxis

fn eq(&self, other: &KeyboardVirtualAxis) -> 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 KeyboardVirtualAxis

where Self: Any + Send + Sync, KeyCode: 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 KeyboardVirtualAxis

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

Registers the specified type tag into the InfallibleMapRegistry.

impl Serialize for KeyboardVirtualAxis

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 KeyboardVirtualAxis

where Self: Any + Send + Sync, KeyCode: 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 KeyboardVirtualAxis

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 KeyboardVirtualAxis

where Self: Any + Send + Sync, KeyCode: 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 KeyboardVirtualAxis

fn kind(&self) -> InputControlKind

KeyboardVirtualAxis acts as a virtual axis input.

fn decompose(&self) -> BasicInputs

KeyboardVirtualAxis represents a compositions of two KeyCodes.

impl WithAxisProcessingPipelineExt for KeyboardVirtualAxis

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 KeyboardVirtualAxis

impl StructuralPartialEq for KeyboardVirtualAxis