Leafwing Input Manager

https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/
Admin
A straightforward but robust input-action manager for Bevy, collecting inputs from various sources...
Tokens:391,534
Snippets:3,172
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Basic Bevy App with Input Manager Setup

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/index.html

This example demonstrates the minimal setup required for the `leafwing-input-manager` in a Bevy application. It includes adding the necessary plugins, defining an `Actionlike` enum, and setting up a player entity with an `InputMap` and `ActionState`.

```rust
use bevy::prelude::*;
use leafwing_input_manager::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        // This plugin maps inputs to an input-type agnostic action-state
        // We need to provide it with an enum which stores the possible actions a player could take
        .add_plugins(InputManagerPlugin::<Action>::default())
        // The InputMap and ActionState components will be added to any entity with the Player component
        .add_systems(Startup, spawn_player)
        // Read the ActionState in your systems using queries!
        .add_systems(Update, jump)
        .run();
}

// This is the list of "things in the game I want to be able to do based on input"
#[derive(Actionlike, PartialEq, Eq, Hash, Clone, Copy, Debug, Reflect)]
enum Action {
    Run,
    Jump,
}

#[derive(Component)]
struct Player;

fn spawn_player(mut commands: Commands) {
    // Describes how to convert from player inputs into those actions
    let input_map = InputMap::new([(Action::Jump, KeyCode::Space)]);
    commands.spawn(input_map).insert(Player);
}

// Query for the `ActionState` component in your game logic systems!
fn jump(query: Query<&ActionState<Action>, With<Player>>) {
    let action_state = query.single();
    if let Ok(action_state) = action_state {
        // Each action has a button-like state of its own that you can check
        if action_state.just_pressed(&Action::Jump) {
            println!("I'm jumping!");
        }
    }
}
```

--------------------------------

### VirtualDPad Example Usage

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/virtual_axial/struct.VirtualDPad.html

Example demonstrating how to use VirtualDPad with Bevy and process input values.

```APIDOC
## Example Usage

```rust
use bevy::prelude::*;
use bevy::input::InputPlugin;
use leafwing_input_manager::user_input::testing_utils::FetchUserInput;
use leafwing_input_manager::prelude::*;
use leafwing_input_manager::plugin::CentralInputStorePlugin;

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

// Define a virtual D-pad using the WASD keys
let input = VirtualDPad::wasd();

// Pressing the W key activates the corresponding axis
KeyCode::KeyW.press(app.world_mut());
app.update();
assert_eq!(app.read_dual_axis_values(input), Vec2::new(0.0, 1.0));

// You can configure a processing pipeline (e.g., doubling the Y value)
let doubled = VirtualDPad::wasd().sensitivity_y(2.0);
assert_eq!(app.read_dual_axis_values(doubled), Vec2::new(0.0, 2.0));
```
```

--------------------------------

### HashMap Length Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Shows how to get the number of elements currently in a HashMap.

```rust
let mut map = HashMap::new();

assert_eq!(map.len(), 0);

map.insert("foo", 0);

assert_eq!(map.len(), 1);
```

--------------------------------

### InputManagerPlugin Finish Method

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/plugin/struct.InputManagerPlugin.html

Completes the plugin's setup after all other plugins have finished their initialization. This is useful for plugins that depend on the setup of other plugins.

```rust
fn finish(&self, _app: &mut App)
```

--------------------------------

### InputManagerPlugin Ready Method

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/plugin/struct.InputManagerPlugin.html

Checks if the plugin has finished its setup. This is useful for plugins that have asynchronous initialization steps.

```rust
fn ready(&self, _app: &App) -> bool
```

--------------------------------

### HashMap Keys Iterator Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Shows how to iterate over the keys of a HashMap. The order of iteration is not guaranteed.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);
map.insert("bar", 1);
map.insert("baz", 2);

for key in map.keys() {
    // foo, bar, baz
    // Note that the above order is not guaranteed
}
```

--------------------------------

### HashMap Iterator Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Shows how to iterate over key-value pairs in a HashMap. The order of iteration is not guaranteed.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);
map.insert("bar", 1);
map.insert("baz", 2);

for (key, value) in map.iter() {
    // ("foo", 0), ("bar", 1), ("baz", 2)
    // Note that the above order is not guaranteed
}
```

--------------------------------

### Using VirtualDPad with Bevy and Input Processing

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/virtual_axial/struct.VirtualDPad.html

Demonstrates how to set up a Bevy application, define a VirtualDPad using WASD keys, simulate input, and read the resulting dual-axis values. It also shows how to apply a sensitivity modifier to the Y-axis.

```rust
use bevy::prelude::*;
use bevy::input::InputPlugin;
use leafwing_input_manager::user_input::testing_utils::FetchUserInput;
use leafwing_input_manager::prelude::*;
use leafwing_input_manager::plugin::CentralInputStorePlugin;

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

// Define a virtual D-pad using the WASD keys
let input = VirtualDPad::wasd();

// Pressing the W key activates the corresponding axis
KeyCode::KeyW.press(app.world_mut());
app.update();
assert_eq!(app.read_dual_axis_values(input), Vec2::new(0.0, 1.0));

// You can configure a processing pipeline (e.g., doubling the Y value)
let doubled = VirtualDPad::wasd().sensitivity_y(2.0);
assert_eq!(app.read_dual_axis_values(doubled), Vec2::new(0.0, 2.0));
```

--------------------------------

### Get Tuple Struct Field

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_processing/dual_axis/struct.DualAxisSensitivity.html

Provides methods to get a field from a tuple struct by index.

```APIDOC
## get_field<T>(&self, index: usize) -> Option<&T>

### Description
Returns a reference to the value of the field with index `index`, downcast to `T`.

### Method
GET

### Endpoint
`/get_field`

### Parameters
#### Query Parameters
- **index** (usize) - Required - The index of the field to retrieve.

#### Response
##### Success Response (200)
- **T** (Option<&T>) - A reference to the field if found and downcastable, otherwise None.
```

```APIDOC
## get_field_mut<T>(&mut self, index: usize) -> Option<&mut T>

### Description
Returns a mutable reference to the value of the field with index `index`, downcast to `T`.

### Method
GET

### Endpoint
`/get_field_mut`

### Parameters
#### Query Parameters
- **index** (usize) - Required - The index of the field to retrieve.

#### Response
##### Success Response (200)
- **T** (Option<&mut T>) - A mutable reference to the field if found and downcastable, otherwise None.
```

--------------------------------

### GamepadStick Usage Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/gamepad/struct.GamepadStick.html

Demonstrates how to use GamepadStick for input, including reading axis values and applying custom processing like sensitivity adjustments.

```APIDOC
## Example Usage

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

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

// Left stick
let input = GamepadStick::LEFT;

// Movement on either axis activates the input
GamepadControlAxis::LEFT_Y.set_value(app.world_mut(), 1.0);
app.update();
assert_eq!(app.read_axis_values(input), [0.0, 1.0]);

// You can configure a processing pipeline (e.g., doubling the Y value)
let doubled = GamepadStick::LEFT.sensitivity_y(2.0);
assert_eq!(app.read_axis_values(doubled), [2.0]);
```
```

--------------------------------

### Get HashMap entry for manipulation

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Use `entry` to get an `Entry` for a key, allowing for in-place insertion or modification of the value.

```rust
let mut map = HashMap::new();

let value = map.entry("foo").or_insert(0);
```

--------------------------------

### GamepadStick Value Processing Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/gamepad/struct.GamepadStick.html

Demonstrates how to initialize Bevy, read gamepad stick input, and apply custom processing like doubling the Y-axis value.

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

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

// Left stick
let input = GamepadStick::LEFT;

// Movement on either axis activates the input
GamepadControlAxis::LEFT_Y.set_value(app.world_mut(), 1.0);
app.update();
assert_eq!(app.read_axis_values(input), [0.0, 1.0]);

// You can configure a processing pipeline (e.g., doubling the Y value)
let doubled = GamepadStick::LEFT.sensitivity_y(2.0);
assert_eq!(app.read_axis_values(doubled), [2.0]);
```

--------------------------------

### Get Button Value (f32)

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/trait.Buttonlike.html

Provided method to get the current value of the button as an f32, between 0.0 (released) and 1.0 (pressed).

```rust
fn value(&self, input_store: &CentralInputStore, gamepad: Entity) -> f32 { ... }
```

--------------------------------

### ActionState Basic Usage Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/action_state/struct.ActionState.html

Demonstrates the basic usage of ActionState, including initializing, checking action states (released, just released, just pressed, pressed), and ticking time to update states.

```rust
use bevy::prelude::Reflect;
use leafwing_input_manager::prelude::*;
use leafwing_input_manager::buttonlike::ButtonState;
use bevy::platform::time::Instant;

#[derive(Actionlike, Clone, Copy, PartialEq, Eq, Hash, Debug, Reflect)]
enum Action {
    Run,
    Jump,
}

let mut action_state = ActionState::<Action>::default();

// Actions start released
assert!(action_state.released(&Action::Jump));
assert!(!action_state.just_released(&Action::Run));

// Ticking time moves causes buttons just released to no longer be just released
let t0 = Instant::now();
let t1 = Instant::now();

action_state.tick(t1, t0);
assert!(action_state.released(&Action::Jump));
assert!(!action_state.just_released(&Action::Jump));

action_state.press(&Action::Jump);
assert!(action_state.just_pressed(&Action::Jump));

// Ticking time moves causes buttons just pressed to no longer be just pressed
let t2 = Instant::now();

action_state.tick(t2, t1);
assert!(action_state.pressed(&Action::Jump));
assert!(!action_state.just_pressed(&Action::Jump));

```

--------------------------------

### Get HashMap entry by reference

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Use `entry_ref` to get an `EntryRef` for a key by reference, enabling in-place manipulation of the value associated with that key.

```rust
let mut map = HashMap::new();

let value = map.entry_ref("foo").or_insert(0);
```

--------------------------------

### Create and Test ButtonlikeChord

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/chord/struct.ButtonlikeChord.html

Demonstrates how to create a ButtonlikeChord with multiple keys and test its activation. Ensure CentralInputStorePlugin is added to your Bevy app.

```rust
use bevy::prelude::*
use bevy::input::InputPlugin
use leafwing_input_manager::plugin::CentralInputStorePlugin
use leafwing_input_manager::prelude::*
use leafwing_input_manager::user_input::testing_utils::FetchUserInput

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

// Define a chord using A and B keys
let input = ButtonlikeChord::new([KeyCode::KeyA, KeyCode::KeyB]);

// Pressing only one key doesn't activate the input
KeyCode::KeyA.press(app.world_mut());
app.update();
assert!(!app.read_pressed(input.clone()));

// Pressing both keys activates the input
KeyCode::KeyA.press(app.world_mut());
KeyCode::KeyB.press(app.world_mut());
app.update();
assert!(app.read_pressed(input.clone()));

```

--------------------------------

### Get value from HashMap by key

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Use `get` to retrieve an immutable reference to the value associated with a given key. Returns `None` if the key is not found.

```rust
let mut map = HashMap::new();

map.insert("foo", 0);

assert_eq!(map.get("foo"), Some(&0));
```

--------------------------------

### VirtualAxis Value Processing Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/virtual_axial/struct.VirtualAxis.html

Demonstrates how to define and use a VirtualAxis with Bevy, including pressing keys to activate the axis and applying sensitivity.

```rust
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::CentralInputStorePlugin;

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

// Define a virtual Y-axis using arrow "up" and "down" keys
let axis = VirtualAxis::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 = VirtualAxis::vertical_arrow_keys().sensitivity(2.0);
assert_eq!(app.read_axis_value(doubled), 2.0);
```

--------------------------------

### DualAxisBounds Usage Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_processing/dual_axis/struct.DualAxisBounds.html

Demonstrates creating DualAxisBounds using `new` and `AxisBounds::extend_dual_with_y`, and verifies clamping behavior against individual axis clamping.

```rust
use bevy::prelude::*
use leafwing_input_manager::prelude::*

// Restrict X to [-2.0, 2.5] and Y to [-1.0, 1.5].
let bounds = DualAxisBounds::new((-2.0, 2.5), (-1.0, 1.5));
assert_eq!(bounds.bounds_x().min_max(), (-2.0, 2.5));
assert_eq!(bounds.bounds_y().min_max(), (-1.0, 1.5));

// Another way to create a DualAxisBounds.
let bounds_x = AxisBounds::new(-2.0, 2.5);
let bounds_y = AxisBounds::new(-1.0, 1.5);
assert_eq!(bounds_x.extend_dual_with_y(bounds_y), bounds);

for x in -300..300 {
    let x = x as f32 * 0.01;
    for y in -300..300 {
        let y = y as f32 * 0.01;
        let value = Vec2::new(x, y);

        assert_eq!(bounds.clamp(value).x, bounds_x.clamp(x));
        assert_eq!(bounds.clamp(value).y, bounds_y.clamp(y));
    }
}
```

--------------------------------

### Get AxislikeChord Value (Alternative)

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/chord/struct.AxislikeChord.html

Gets the current value of the input as an f32. This is an alternative to `get_value` and may have slightly different behavior or usage context.

```rust
fn value(&self, input_store: &CentralInputStore, gamepad: Entity) -> f32
```

--------------------------------

### HashMap Is Empty Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Demonstrates checking if a HashMap is empty, returning true if it contains no elements.

```rust
let mut map = HashMap::new();

assert!(map.is_empty());

map.insert("foo", 0);

assert!(!map.is_empty());
```

--------------------------------

### ActionState Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/action_state/struct.ActionState.html

Demonstrates the basic usage of ActionState, including pressing, releasing, and checking the state of actions. It also shows how `tick` advances the state from `just_pressed` to `pressed` and `just_released` to `released`.

```rust
use bevy::reflect::Reflect;
use leafwing_input_manager::prelude::*;
use bevy::platform::time::Instant;

#[derive(Actionlike, PartialEq, Eq, Hash, Clone, Copy, Debug, Reflect)]
enum Action {
    Left,
    Right,
    Jump,
}

let mut action_state = ActionState::<Action>::default();

// Typically, this is done automatically by the `InputManagerPlugin` from user inputs
// using the `ActionState::update` method
action_state.press(&Action::Jump);

assert!(action_state.pressed(&Action::Jump));
assert!(action_state.just_pressed(&Action::Jump));
assert!(action_state.released(&Action::Left));

// Resets just_pressed and just_released
let t0 = Instant::now();
let t1 = Instant::now();

 action_state.tick(t1, t0);
assert!(action_state.pressed(&Action::Jump));
assert!(!action_state.just_pressed(&Action::Jump));

action_state.release(&Action::Jump);
assert!(!action_state.pressed(&Action::Jump));
assert!(action_state.released(&Action::Jump));
assert!(action_state.just_released(&Action::Jump));

let t2 = Instant::now();
action_state.tick(t2, t1);
assert!(action_state.released(&Action::Jump));
assert!(!action_state.just_released(&Action::Jump));

```

--------------------------------

### Get Dual Axis Pair (Simplified)

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/chord/struct.DualAxislikeChord.html

Gets the values of this input along the X and Y axes. This simplified version directly returns a Vec2, assuming the button is pressed.

```rust
fn axis_pair(&self, input_store: &CentralInputStore, gamepad: Entity) -> Vec2
```

--------------------------------

### Retrieving Values with `get` in Hashbrown HashMap

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Illustrates how to retrieve a reference to a value associated with a key using the `get` method. The key can be any borrowed form that matches the map's key type.

```rust
use hashbrown::HashMap;

let mut map = HashMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);
```

--------------------------------

### FromWorld Implementation

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/action_state/struct.DualAxisData.html

Creates an instance using the default value.

```APIDOC
## `from_world`

### Description
Creates `Self` using `default()`.

### Signature
`fn from_world(_world: &mut World) -> T`
```

--------------------------------

### Value Processing Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/mouse/struct.MouseMove.html

Demonstrates how to use the MouseMove struct and customize its value processing pipeline, including setting sensitivity.

```APIDOC
## §Value Processing

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

```rust
use bevy::prelude::*;
use bevy::input::InputPlugin;
use leafwing_input_manager::plugin::CentralInputStorePlugin;
use leafwing_input_manager::prelude::*;
use leafwing_input_manager::user_input::testing_utils::FetchUserInput;

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

let input = MouseMove::default();

// Movement on either axis activates the input
MouseMoveAxis::Y.set_value(app.world_mut(), 3.0);
app.update();
assert_eq!(app.read_dual_axis_values(input), Vec2::new(0.0, 3.0));

// You can configure a processing pipeline (e.g., doubling the Y value)
let doubled = MouseMove::default().sensitivity_y(2.0);
assert_eq!(app.read_dual_axis_values(doubled), Vec2::new(0.0, 6.0));
```
```

--------------------------------

### Get Button Value (Option<f32>)

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/trait.Buttonlike.html

Provided method to get the current value of the button as an Option<f32>. Returns None if the input has never been pressed or set. The value is between 0.0 (released) and 1.0 (pressed).

```rust
fn get_value(
        &self,
        input_store: &CentralInputStore,
        gamepad: Entity,
    ) -> Option<f32> { ... }
```

--------------------------------

### swap_to_update

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/systems/index.html

Prepares systems for the Main schedule.

```APIDOC
## swap_to_update

### Description
We are about to enter the `Main` schedule, so we:

### Method
(Not specified, likely a function call within a system)

### Endpoint
(Not applicable, this is a function within a library)

### Parameters
(No parameters explicitly documented)

### Request Example
(Not applicable)

### Response
(No response details explicitly documented)
```

--------------------------------

### value

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/virtual_axial/struct.VirtualAxis.html

Gets the current value of the input as an `f32`.

```APIDOC
## value

### Description
Gets the current value of the input as an `f32`.

### Signature
`fn value(&self, input_store: &CentralInputStore, gamepad: Entity) -> f32`
```

--------------------------------

### GetField for S

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/gamepad/struct.GamepadControlAxis.html

Provides methods to get fields from a struct.

```APIDOC
## fn get_field<T>(&self, name: &str) -> Option<&T>

Returns a reference to the value of the field named `name`, downcast to `T`.

### Method
`get_field`

### Parameters
- `name` (&str): The name of the field to retrieve.

### Returns
- `Option<&T>`: An optional reference to the field value if found and downcastable to T.
```

```APIDOC
## fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>

Returns a mutable reference to the value of the field named `name`, downcast to `T`.

### Method
`get_field_mut`

### Parameters
- `name` (&str): The name of the field to retrieve.

### Returns
- `Option<&mut T>`: An optional mutable reference to the field value if found and downcastable to T.
```

--------------------------------

### from

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/updating/struct.CentralInputStore.html

Creates a new instance from a given value.

```APIDOC
## from

### Description
Returns the argument unchanged.

### Method
`from`

### Parameters
- `t` (T) - The value to convert from.

### Returns
T - The original value.
```

--------------------------------

### get

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Returns a reference to the value corresponding to the key.

```APIDOC
## get

### Description
Returns a reference to the value corresponding to the key.

### Method
`get<Q>(&self, k: &Q) -> Option<&V>`

### Parameters
#### Path Parameters
- **k** (&Q) - Required - The key to look up.

### Request Example
```rust
let mut map = HashMap::new();
map.insert("foo", 0);
assert_eq!(map.get("foo"), Some(&0));
```

### Response
- **Option<&V>** - An Option containing a reference to the value if the key exists, otherwise None.

### Response Example
None provided in source.
```

--------------------------------

### IntoScheduleConfigs<Interned<dyn SystemSet>, ()> for S

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/plugin/struct.TickActionStateSystem.html

Provides methods for configuring systems within a schedule.

```APIDOC
## into_configs

### Description
Convert into a `ScheduleConfigs`.

### Signature
`fn into_configs(self) -> ScheduleConfigs<Interned<dyn SystemSet>>`
```

```APIDOC
## in_set

### Description
Add these systems to the provided `set`.

### Signature
`fn in_set(self, set: impl SystemSet) -> ScheduleConfigs<T>`
```

```APIDOC
## before

### Description
Runs before all systems in `set`. If `self` has any systems that produce `Commands` or other `Deferred` operations, all systems in `set` will see their effect.

### Signature
`fn before<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
```

```APIDOC
## after

### Description
Run after all systems in `set`. If `set` has any systems that produce `Commands` or other `Deferred` operations, all systems in `self` will see their effect.

### Signature
`fn after<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
```

```APIDOC
## before_ignore_deferred

### Description
Run before all systems in `set`.

### Signature
`fn before_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
```

```APIDOC
## after_ignore_deferred

### Description
Run after all systems in `set`.

### Signature
`fn after_ignore_deferred<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
```

```APIDOC
## distributive_run_if

### Description
Add a run condition to each contained system.

### Signature
`fn distributive_run_if<M>(self, condition: impl SystemCondition<M> + Clone) -> ScheduleConfigs<T>`
```

```APIDOC
## run_if

### Description
Run the systems only if the `SystemCondition` is `true`.

### Signature
`fn run_if<M>(self, condition: impl SystemCondition<M>) -> ScheduleConfigs<T>`
```

```APIDOC
## ambiguous_with

### Description
Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with systems in `set`.

### Signature
`fn ambiguous_with<M>(self, set: impl IntoSystemSet<M>) -> ScheduleConfigs<T>`
```

```APIDOC
## ambiguous_with_all

### Description
Suppress warnings and errors that would result from these systems having ambiguities (conflicting access but indeterminate order) with any other system.

### Signature
`fn ambiguous_with_all(self) -> ScheduleConfigs<T>`
```

```APIDOC
## chain

### Description
Treat this collection as a sequence of systems.

### Signature
`fn chain(self) -> ScheduleConfigs<T>`
```

```APIDOC
## chain_ignore_deferred

### Description
Treat this collection as a sequence of systems.

### Signature
`fn chain_ignore_deferred(self) -> ScheduleConfigs<T>`
```

--------------------------------

### Create and Use AxisBounds

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_processing/single_axis/struct.AxisBounds.html

Demonstrates creating an AxisBounds instance with specific limits and converting it into an AxisProcessor. It also shows how the clamp method behaves with values inside and outside the defined bounds.

```rust
use leafwing_input_manager::prelude::*;

// Restrict values to [-2.0, 1.5].
let bounds = AxisBounds::new(-2.0, 1.5);

// The ways to create an AxisProcessor.
let processor = AxisProcessor::from(bounds);
assert_eq!(processor, AxisProcessor::ValueBounds(bounds));

for value in -300..300 {
    let value = value as f32 * 0.01;
    assert_eq!(bounds.clamp(value), value.clamp(-2.0, 1.5));
}
```

--------------------------------

### AxislikeChord::value

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/chord/struct.AxislikeChord.html

Gets the current value of the axis.

```APIDOC
#### fn value(&self, input_store: &CentralInputStore, gamepad: Entity) -> f32

Gets the current value of the input as an `f32`.
```

--------------------------------

### MouseScroll Usage Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/mouse/struct.MouseScroll.html

Demonstrates how to use the MouseScroll struct, including setting scroll values and configuring a processing pipeline.

```APIDOC
## §Value Processing

```
use bevy::prelude::*
use bevy::input::InputPlugin
use leafwing_input_manager::plugin::CentralInputStorePlugin
use leafwing_input_manager::prelude::*
use leafwing_input_manager::user_input::testing_utils::FetchUserInput

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

let input = MouseScroll::default();

// Scrolling on either axis activates the input
MouseScrollAxis::Y.set_value(app.world_mut(), 3.0);
app.update();
assert_eq!(app.read_dual_axis_values(input), Vec2::new(0.0, 3.0));

// You can configure a processing pipeline (e.g., doubling the Y value)
let doubled = MouseScroll::default().sensitivity_y(2.0);
assert_eq!(app.read_dual_axis_values(doubled), Vec2::new(0.0, 6.0));
```
```

--------------------------------

### GetField Methods

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/updating/struct.CentralInputStore.html

Methods for getting field values by name.

```APIDOC
## get_field

### Description
Returns a reference to the value of the field named `name`, downcast to `T`.

### Method
`get_field`

### Parameters
- `name` (&str) - The name of the field.

### Returns
`Option<&T>` - An optional reference to the field value.
```

```APIDOC
## get_field_mut

### Description
Returns a mutable reference to the value of the field named `name`, downcast to `T`.

### Method
`get_field_mut`

### Parameters
- `name` (&str) - The name of the field.

### Returns
`Option<&mut T>` - An optional mutable reference to the field value.
```

--------------------------------

### Using GamepadControlAxis for Input

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/gamepad/struct.GamepadControlAxis.html

Demonstrates how to use GamepadControlAxis for reading and processing gamepad input, including setting values and applying custom processing like sensitivity adjustments.

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

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

// Y-axis movement on left stick
let input = GamepadControlAxis::LEFT_Y;

// Movement on the chosen axis activates the input
GamepadControlAxis::LEFT_Y.set_value(app.world_mut(), 1.0);
app.update();
assert_eq!(app.read_axis_value(input), 1.0);

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

--------------------------------

### GamepadControlAxis::value

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/gamepad/struct.GamepadControlAxis.html

Gets the current value of the input as an f32.

```APIDOC
## `GamepadControlAxis::value(&self, input_store: &CentralInputStore, gamepad: Entity) -> f32`

Gets the current value of the input as an `f32`.
```

--------------------------------

### ButtonlikeChord::value

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/chord/struct.ButtonlikeChord.html

Gets the current value of the ButtonlikeChord as an f32.

```APIDOC
## ButtonlikeChord::value

### Description
Gets the current value of the button as an `f32`.

### Signature
```rust
fn value(&self, input_store: &CentralInputStore, gamepad: Entity) -> f32
```
```

--------------------------------

### InputMap::on_despawn

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.InputMap.html

Gets the `on_despawn` ComponentHook if defined for this Component.

```APIDOC
## fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

### Description
Gets the `on_despawn` `ComponentHook` for this `Component` if one is defined.

### Method
`on_despawn`

### Response
- Returns an `Option<for<'w> fn(DeferredWorld<'w>, HookContext)>`.
```

--------------------------------

### HashMap Capacity Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Demonstrates how to check the capacity of a HashMap. The capacity indicates the number of elements the map can hold before reallocating.

```rust
let map = HashMap::with_capacity(5);

assert!(map.capacity() >= 5);
```

--------------------------------

### InputMap::on_remove

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.InputMap.html

Gets the `on_remove` ComponentHook if defined for this Component.

```APIDOC
## fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

### Description
Gets the `on_remove` `ComponentHook` for this `Component` if one is defined.

### Method
`on_remove`

### Response
- Returns an `Option<for<'w> fn(DeferredWorld<'w>, HookContext)>`.
```

--------------------------------

### InputMap::on_replace

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.InputMap.html

Gets the `on_replace` ComponentHook if defined for this Component.

```APIDOC
## fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

### Description
Gets the `on_replace` `ComponentHook` for this `Component` if one is defined.

### Method
`on_replace`

### Response
- Returns an `Option<for<'w> fn(DeferredWorld<'w>, HookContext)>`.
```

--------------------------------

### InputMap::on_insert

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.InputMap.html

Gets the `on_insert` ComponentHook if defined for this Component.

```APIDOC
## fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

### Description
Gets the `on_insert` `ComponentHook` for this `Component` if one is defined.

### Method
`on_insert`

### Response
- Returns an `Option<for<'w> fn(DeferredWorld<'w>, HookContext)>`.
```

--------------------------------

### enable

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/action_state/struct.ActionState.html

Enables the entire `ActionState`.

```APIDOC
## pub fn enable(&mut self)

### Description
Enables the entire `ActionState`.
```

--------------------------------

### InputMap::on_add

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.InputMap.html

Gets the `on_add` ComponentHook if defined for this Component.

```APIDOC
## fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

### Description
Gets the `on_add` `ComponentHook` for this `Component` if one is defined.

### Method
`on_add`

### Response
- Returns an `Option<for<'w> fn(DeferredWorld<'w>, HookContext)>`.
```

--------------------------------

### Example Usage of MouseMoveAxis

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/mouse/struct.MouseMoveAxis.html

Demonstrates how to use MouseMoveAxis for tracking and processing mouse movement, including setting values and configuring sensitivity.

```APIDOC
```rust
use bevy::prelude::*;
use bevy::input::InputPlugin;
use leafwing_input_manager::plugin::CentralInputStorePlugin;
use leafwing_input_manager::prelude::*;
use leafwing_input_manager::user_input::testing_utils::FetchUserInput;

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

// Y-axis movement
let input = MouseMoveAxis::Y;

// Movement on the chosen axis activates the input
MouseMoveAxis::Y.set_value(app.world_mut(), 1.0);
app.update();
assert_eq!(app.read_axis_value(input), 1.0);

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

--------------------------------

### Getting the Radius of CircleExclusion

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_processing/dual_axis/struct.CircleExclusion.html

Returns the configured radius of the CircleExclusion.

```rust
pub fn radius(&self) -> f32
```

--------------------------------

### axis_pair

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/virtual_axial/struct.VirtualDPad.html

Gets the values of this input along the X and Y axes (if applicable).

```APIDOC
## axis_pair

### Description
Gets the values of this input along the X and Y axes (if applicable).

### Method
`&self`

### Parameters
- `input_store`: `&CentralInputStore` - The central input store.
- `gamepad`: `Entity` - The entity representing the gamepad.

### Returns
- `Vec2` - The values along the X and Y axes.
```

--------------------------------

### Processing Mouse Movement with MouseMoveAxis

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/mouse/struct.MouseMoveAxis.html

Demonstrates how to set up an application with input plugins, simulate mouse movement on the Y-axis, and read the processed value. It also shows how to configure sensitivity for processing.

```rust
use bevy::prelude::*
use bevy::input::InputPlugin
use leafwing_input_manager::plugin::CentralInputStorePlugin
use leafwing_input_manager::prelude::*
use leafwing_input_manager::user_input::testing_utils::FetchUserInput

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

// Y-axis movement
let input = MouseMoveAxis::Y

// Movement on the chosen axis activates the input
MouseMoveAxis::Y.set_value(app.world_mut(), 1.0)
app.update()
assert_eq!(app.read_axis_value(input), 1.0)

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

--------------------------------

### Basic MouseMoveDirection Usage

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/mouse/struct.MouseMoveDirection.html

Demonstrates how to set up and use MouseMoveDirection for detecting mouse movement in a specific direction. It shows how to initialize the Bevy app, simulate mouse movement, and assert the input state.

```rust
use bevy::prelude::*
use bevy::input::InputPlugin
use leafwing_input_manager::plugin::CentralInputStorePlugin
use leafwing_input_manager::prelude::*
use leafwing_input_manager::user_input::testing_utils::FetchUserInput

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

// Positive Y-axis movement
let input = MouseMoveDirection::UP

// Movement in the opposite direction doesn't activate the input
MouseMoveAxis::Y.set_value(app.world_mut(), -5.0)
app.update()
assert!(!app.read_pressed(input))

// Movement in the chosen direction activates the input
MouseMoveAxis::Y.set_value(app.world_mut(), 5.0)
app.update()
assert!(app.read_pressed(input))
```

--------------------------------

### Get HashMap Length

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Returns the number of elements currently in the map.

```rust
use hashbrown::HashMap;

let mut a = HashMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);
```

--------------------------------

### Example Usage of Actionlike

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/trait.Actionlike.html

Demonstrates how to derive the Actionlike trait for an enum representing player actions, including common trait bounds and the derive macro.

```APIDOC
## Examples

```rust
use bevy::prelude::Reflect;
use leafwing_input_manager::Actionlike;

#[derive(Actionlike, Debug, PartialEq, Eq, Clone, Copy, Hash, Reflect)]
enum PlayerAction {
   // Movement
   Up,
   Down,
   Left,
   Right,
   // Abilities
   Ability1,
   Ability2,
   Ability3,
   Ability4,
   Ultimate,
}
```
```

--------------------------------

### get_disjoint_mut

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_map/struct.UpdatedActions.html

Attempts to get mutable references to `N` values in the map at once.

```APIDOC
## get_disjoint_mut

### Description
Attempts to get mutable references to `N` values in the map at once.

### Method
`get_disjoint_mut<Q, const N: usize>(&mut self, ks: [&Q; N]) -> [Option<&mut V>; N]`

### Parameters
#### Path Parameters
- **ks** ([&Q; N]) - Required - An array of keys to look up.

### Request Example
None provided in source.

### Response
- **[Option<&mut V>; N]** - An array of Options, where each Option contains a mutable reference to the value if the corresponding key exists, otherwise None.

### Response Example
None provided in source.
```

--------------------------------

### DualAxislikeChord::axis_pair

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/chord/struct.DualAxislikeChord.html

Gets the values of this input along the X and Y axes.

```APIDOC
## DualAxislikeChord::axis_pair

### Description
Gets the values of this input along the X and Y axes (if applicable).

### Signature
```rust
fn axis_pair(&self, input_store: &CentralInputStore, gamepad: Entity) -> Vec2
```

### Parameters
* `input_store`: The central input store.
* `gamepad`: The entity representing the gamepad.

### Returns
A `Vec2` representing the axis pair.
```

--------------------------------

### CircleDeadZone Example

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_processing/dual_axis/struct.CircleDeadZone.html

Demonstrates how to use CircleDeadZone to process input values. It checks if values are within the dead zone, live zone, or outside the bounds, and asserts the expected normalization behavior for each case.

```rust
use bevy::prelude::*
use leafwing_input_manager::prelude::*

// Exclude magnitudes less than or equal to 0.2
let deadzone = CircleDeadZone::new(0.2);

for x in -300..300 {
    let x = x as f32 * 0.01;
    for y in -300..300 {
        let y = y as f32 * 0.01;
        let value = Vec2::new(x, y);

        // Values within the dead zone are treated as zeros.
        if value.length() <= 0.2 {
            assert!(deadzone.within_exclusion(value));
            assert_eq!(deadzone.normalize(value), Vec2::ZERO);
        }

        // Values within the live zone are scaled linearly.
        else if value.length() <= 1.0 {
            assert!(deadzone.within_livezone(value));

            let expected_scale = f32::inverse_lerp(0.2, 1.0, value.length());
            let expected = value.normalize() * expected_scale;
            let delta = (deadzone.normalize(value) - expected).abs();
            assert!(delta.x <= 0.00001);
            assert!(delta.y <= 0.00001);
        }

        // Values outside the bounds are restricted to the region.
        else {
            assert!(!deadzone.within_bounds(value));

            let expected = value.clamp_length_max(1.0);
            let delta = (deadzone.normalize(value) - expected).abs();
            assert!(delta.x <= 0.00001);
            assert!(delta.y <= 0.00001);
        }
    }
}
```

--------------------------------

### GetField

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_processing/dual_axis/struct.DualAxisBounds.html

Provides methods to get field values from a struct by name.

```APIDOC
## fn get_field<T>(&self, name: &str) -> Option<&T>

### Description
Returns a reference to the value of the field named `name`, downcast to `T`.

### Method
fn

### Parameters
- **name**: &str - The name of the field to retrieve.

### Returns
- Option<&T>: An optional reference to the field value if found and downcastable to `T`.
```

```APIDOC
## fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>

### Description
Returns a mutable reference to the value of the field named `name`, downcast to `T`.

### Method
fn

### Parameters
- **name**: &str - The name of the field to retrieve.

### Returns
- Option<&mut T>: An optional mutable reference to the field value if found and downcastable to `T`.
```

--------------------------------

### from_world

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/updating/struct.CentralInputStore.html

Creates a new instance from the world.

```APIDOC
## from_world

### Description
Creates `Self` using `default()`.

### Method
`from_world`

### Parameters
- `_world` (&mut World) - The world to create the instance from.

### Returns
T - The newly created instance.
```

--------------------------------

### GetField Trait

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_processing/dual_axis/struct.DualAxisDeadZone.html

Provides methods to get field values by name.

```APIDOC
## get_field

### Description
Returns a reference to the value of the field named `name`, downcast to `T`.

### Method
`get_field`
```

```APIDOC
## get_field_mut

### Description
Returns a mutable reference to the value of the field named `name`, downcast to `T`.

### Method
`get_field_mut`
```

--------------------------------

### Simulate Button Release as Gamepad

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/trait.Buttonlike.html

Provided method to simulate a release of the buttonlike input, pretending to be the provided gamepad Entity. Defaults to calling `release` for non-gamepad inputs. Use `find_gamepad` if the provided gamepad is None.

```rust
fn release_as_gamepad(&self, world: &mut World, _gamepad: Option<Entity>) { ... }
```

--------------------------------

### VirtualAxis::ws

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/user_input/virtual_axial/struct.VirtualAxis.html

Creates a VirtualAxis configured for W/S key input.

```APIDOC
## VirtualAxis::ws

### Description
Creates a `VirtualAxis` using the common W/S key mappings.

### Mappings
- `KeyCode::KeyS` for negative direction.
- `KeyCode::KeyW` for positive direction.

### Returns
A `VirtualAxis` instance configured for W/S keys.
```

--------------------------------

### GetField for S

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/buttonlike/struct.ButtonValue.html

Provides methods to get field values by name from a struct.

```APIDOC
## fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,

Returns a reference to the value of the field named `name`, downcast to `T`.

## fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
where T: Reflect,

Returns a mutable reference to the value of the field named `name`, downcast to `T`.
```

--------------------------------

### Get Positive Direction

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/axislike/enum.DualAxisType.html

Returns the positive DualAxisDirection for the current axis.

```rust
pub const fn positive(&self) -> DualAxisDirection
```

--------------------------------

### Creating and Using AxisDeadZone

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/input_processing/single_axis/struct.AxisDeadZone.html

Demonstrates how to create an AxisDeadZone with custom exclusion bounds and how its normalization and boundary checks behave for various input values. It also shows how to convert it to an AxisProcessor.

```rust
use bevy::prelude::*
use leafwing_input_manager::prelude::*

// Exclude values between -0.2 and 0.3
let deadzone = AxisDeadZone::new(-0.2, 0.3);

// Another way to create an AxisDeadzone.
let exclusion = AxisExclusion::new(-0.2, 0.3);
assert_eq!(exclusion.scaled(), deadzone);

// The ways to create an AxisProcessor.
let processor = AxisProcessor::from(deadzone);
assert_eq!(processor, AxisProcessor::DeadZone(deadzone));

// The bounds after normalization.
let bounds = deadzone.bounds();
assert_eq!(bounds.min(), -1.0);
assert_eq!(bounds.max(), 1.0);

for value in -300..300 {
    let value = value as f32 * 0.01;

    // Values within the dead zone are treated as zero.
    if -0.2 <= value && value <= 0.3 {
        assert!(deadzone.within_exclusion(value));
        assert_eq!(deadzone.normalize(value), 0.0);
    }

    // Values within the live zone are scaled linearly.
    else if -1.0 <= value && value < -0.2 {
        assert!(deadzone.within_livezone_lower(value));

        let expected = f32::inverse_lerp(-1.0, -0.2, value) - 1.0;
        assert!((deadzone.normalize(value) - expected).abs() <= f32::EPSILON);
    } else if 0.3 < value && value <= 1.0 {
        assert!(deadzone.within_livezone_upper(value));

        let expected = f32::inverse_lerp(0.3, 1.0, value);
        assert!((deadzone.normalize(value) - expected).abs() <= f32::EPSILON);
    }

    // Values outside the bounds are restricted to the range.
    else {
        assert!(!deadzone.within_bounds(value));
        assert_eq!(deadzone.normalize(value), value.clamp(-1.0, 1.0));
    }
}
```

--------------------------------

### Get Negative Direction

Source: https://docs.rs/leafwing-input-manager/0.20.0/leafwing_input_manager/axislike/enum.DualAxisType.html

Returns the negative DualAxisDirection for the current axis.

```rust
pub const fn negative(&self) -> DualAxisDirection
```
Tokens:
Raw