Bevy Enhanced Input

https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/
Admin
Bevy Enhanced Input is a powerful observer-based input manager for Bevy, inspired by Unreal Engine...
Tokens:1,269,563
Snippets:7,382
Trust Score:9.7
Update:8 months ago
Show doc for...
Tokens:
Raw
### Example Usage of Start Event in Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/events/struct.Start_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the Start event observer in Bevy. This example shows spawning a player with an action and defining a 'throw' function that is triggered once when the associated key is pressed, similar to Bevy's 'just_pressed' functionality.

```rust
app.add_observer(throw);

app.world_mut().spawn(( 
    Player,
    actions!(Player[Action::<Throw>::new(), bindings![KeyCode::KeyF])),
));

/// Triggered only once on the first press, similar to `just_pressed` in `bevy_input`.
///
/// It will not trigger again until the key is released and pressed again.
fn throw(throw: On<Start<Throw>>, players: Query<(&Transform, &mut Health)>) {
    // ...
}
```

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

### Start Event Documentation

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/events/struct.Start_search=std%3A%3Avec

Details about the Start event, its purpose, fields, and usage examples.

```APIDOC
## Struct Start<A: InputAction>

### Description
Triggers when an action switches its state from `ActionState::None` to `ActionState::Fired` or `ActionState::Ongoing`. Triggered before `Fire` and `Ongoing`. See `ActionEvents` for all transitions.

### Method
(Event)

### Endpoint
(N/A - Event)

### Parameters
#### Path Parameters
(None)

#### Query Parameters
(None)

#### Request Body
(None)

### Request Example
```rust
app.add_observer(throw);

app.world_mut().spawn(( 
    Player,
    actions!(Player[Action::<Throw>::new(), bindings![KeyCode::KeyF]]),
));

/// Triggered only once on the first press, similar to `just_pressed` in `bevy_input`.
///
/// It will not trigger again until the key is released and pressed again.
fn throw(throw: On<Start<Throw>>, players: Query<(&Transform, &mut Health)>) {
    // ...
}
```

### Response
#### Success Response (Event Trigger)
- **context** (Entity) - Entity with the context component on which this event was triggered.
- **action** (Entity) - Action that triggered this event.
- **value** (A::Output) - Current action value.
- **state** (ActionState) - Current action state.

#### Response Example
(N/A - Event Structure)

## Fields
- **context**: Entity - Entity with the context component on which this event was triggered.
- **action**: Entity - Action that triggered this event.
- **value**: A::Output - Current action value.
- **state**: ActionState - Current action state.
```

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

### Example: Triggering an Action on Button Press (Rust)

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/events/struct.Start

Demonstrates how to use the `Start` event observer in Bevy to trigger a custom action, such as 'throwing an item', when a specific key (e.g., `KeyCode::KeyF`) is pressed. This example shows setting up the observer and spawning an entity with the associated action and bindings.

```rust
app.add_observer(throw);

app.world_mut().spawn(( 
    Player,
    actions!(Player[Action::<Throw>::new(), bindings![KeyCode::KeyF]]),
));

/// Triggered only once on the first press, similar to `just_pressed` in `bevy_input`.
///
/// It will not trigger again until the key is released and pressed again.
fn throw(throw: On<Start<Throw>>, players: Query<(&Transform, &mut Health)>) {
    // ...
}
```

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

### Setting Up Input Contexts, Actions, and Bindings in Bevy

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/index

Demonstrates the setup of Bevy's EnhancedInputPlugin, defining custom input contexts (Player), actions (Jump, Fire), and associating them with input sources (keyboard, gamepad) using macros. This example showcases the core structure for managing input in a Bevy application.

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

#[derive(Component)]
struct Player;

#[derive(InputAction)]
#[action_output(bool)]
struct Jump;

#[derive(InputAction)]
#[action_output(bool)]
struct Fire;

let mut app = App::new();
app.add_plugins(EnhancedInputPlugin)
    .add_input_context::<Player>()
    .finish();

app.world_mut().spawn((
    Player,
    actions!(Player[
        (
            Action::<Jump>::new(),
            bindings![KeyCode::Space, GamepadButton::South],
        ),
        (
            Action::<Fire>::new(),
            bindings![MouseButton::Left, GamepadButton::RightTrigger2],
        ),
    ])
));
```

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

### Example Searches for Rust Bevy Enhanced Input

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/enum.EnhancedInputSystems_search=

Provides examples of search queries that can be used within the Bevy Enhanced Input library or related documentation. These examples illustrate common patterns for searching types, function signatures, and generic transformations.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

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

### Example Type Registration Searches (Rust)

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/condition/combo/struct.Combo_search=

Provides example search queries for Bevy's type registration system. These examples illustrate how to find specific types or type relationships within the registered components and resources.

```rust
// Example searches:
//   * std::vec
//   * u32 -> bool
//   * Option<T>, (T -> U) -> Option<U>
```

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

### State Context Integration Example

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/state/index_search=u32+-%3E+bool

Demonstrates how to synchronize Bevy `States` with input contexts using `bevy_enhanced_input`. This example shows setting up states, input actions, and associating input contexts with specific game states.

```APIDOC
## Module state: bevy_enhanced_input

### Description
State-context integration for synchronizing Bevy `States` with input contexts. This module provides components that automatically activate/deactivate input contexts based on the current application state, eliminating manual `OnEnter`/`DespawnOnExit` boilerplate.

### Method
N/A (Configuration and Setup)

### Endpoint
N/A (In-memory Bevy App Configuration)

### Parameters
N/A

### Request Example
```rust
use bevy::{prelude::*, state::app::StatesPlugin};
use bevy_enhanced_input::prelude::*;

#[derive(States, Clone, PartialEq, Eq, Hash, Debug, Default)]
enum GameState {
    #[default]
    Playing,
    Paused,
}

#[derive(Component)]
struct Player;

#[derive(InputAction)]
#[action_output(bool)]
struct Jump;

let mut app = App::new();
app.add_plugins((StatesPlugin, EnhancedInputPlugin))
    .init_state::<GameState>()
    .add_input_context::<Player>()
    .sync_context_to_state::<Player, GameState>()
    .finish();

// When spawning entities, use `ActiveInStates` to declare which states activate the context.
app.world_mut().spawn(( 
    Player,
    ContextActivity::<Player>::INACTIVE,
    ActiveInStates::<Player, _>::single(GameState::Playing),
    actions!(Player[(Action::<Jump>::new(), bindings![KeyCode::Space])]),
));
```

### Response
N/A (This is a setup example, not an API endpoint)

### Success Response (200)
N/A

### Response Example
N/A
```

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

### Rust: Using Complete event for jump on button release

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/events/struct.Complete

This example demonstrates how to use the `Complete` event to trigger a jump action when a specific key (e.g., Spacebar) is released. It shows the setup of the Bevy application, spawning a player entity with associated actions, and defining a jump observer function that reacts to the `On<Complete<Jump>>` event.

```rust
app.add_observer(jump);

app.world_mut().spawn((
    Player,
    actions!(Player[Action::<Jump>::new(), bindings![KeyCode::Space]]),
));

/// Triggered only once when the user releases the key, similar to `just_released` in `bevy_input`.
fn jump(jump: On<Complete<Jump>>, players: Query<&mut Transform>) {
    // ...
}
```

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

### Clamp Examples: Binding Positive/Negative Gamepad Axis

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/modifier/clamp/struct.Clamp_search=u32+-%3E+bool

Demonstrates how to use Clamp::pos() and Clamp::neg() to bind only the positive or negative direction of a GamepadAxis. This example uses Bevy's action system.

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

actions!(Ui[
    (
        Action::<Up>::new(),
        Clamp::pos(),
        bindings![GamepadAxis::LeftStickY],
    ),
    (
        Action::<Down>::new(),
        Clamp::neg(),
        bindings![GamepadAxis::LeftStickY],
    ),
]);

#[derive(Component)]
struct Ui;

#[derive(InputAction)]
#[action_output(bool)]
struct Up;

#[derive(InputAction)]
#[action_output(bool)]
struct Down;
```

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

### Start Event Documentation

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/events/struct.Start

The Start event is triggered when an action transitions from a non-active state (None) to an active state (Fired or Ongoing). It fires before the Fire and Ongoing events.

```APIDOC
## Struct Start<A: InputAction>

### Description
Triggers when an action switches its state from `ActionState::None` to `ActionState::Fired` or `ActionState::Ongoing`. Triggered before `Fire` and `Ongoing`. See `ActionEvents` for all transitions.

### Method
(Event - Not an HTTP method)

### Endpoint
(Not applicable - this is an in-memory event)

### Parameters
#### Fields
- **context** (Entity) - The entity with the context component on which this event was triggered.
- **action** (Entity) - The action that triggered this event.
- **value** (A::Output) - The current action value.
- **state** (ActionState) - The current action state.

### Request Example
(Not applicable - this is an in-memory event)

### Response
#### Success Response (Event Triggered)
- **context** (Entity) - The entity with the context component on which this event was triggered.
- **action** (Entity) - The action that triggered this event.
- **value** (A::Output) - The current action value.
- **state** (ActionState) - The current action state.

#### Response Example
```rust
// Example of how the Start event might be structured internally
// Note: This is a conceptual representation, not a direct JSON response.
{
  "context": "some_entity_id",
  "action": "some_action_id",
  "value": "action_output_value",
  "state": "ActionState::Fired"
}
```

### Trait Implementations
- `Clone`
- `Debug`
- `EntityEvent`
- `Event`
- `Copy`
```

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

### Manual Input Binding Setup with Modifiers

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/preset/index_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates a manual setup for character movement input using keyboard keys and a gamepad stick. It includes modifiers like DeadZone and SmoothNudge, and shows how to map keys to axes using swizzling and negation. This approach is verbose and serves as a baseline for understanding the presets.

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

#[derive(Component)]
struct Player;

#[derive(InputAction)]
#[action_output(Vec2)]
struct Movement;

let mut world = World::new();
world.spawn((
    Player,
    actions!(Player[
        (
            Action::<Movement>::new(),
            // Modifier components at the action level.
            DeadZone::default(),    // Applies non-uniform normalization.
            SmoothNudge::default(), // Smoothes movement.
            bindings![
                // Keyboard keys captured as `bool`, but the output of `Movement` is defined as `Vec2`,
                // so you need to assign keys to axes using swizzle to reorder them and negation.
                (KeyCode::KeyW, SwizzleAxis::YXZ),
                (KeyCode::KeyA, Negate::all()),
                (KeyCode::KeyS, Negate::all(), SwizzleAxis::YXZ),
                KeyCode::KeyD,
                // In Bevy sticks split by axes and captured as 1-dimensional inputs,
                // so Y stick needs to be sweezled into Y axis.
                GamepadAxis::LeftStickX,
                (GamepadAxis::LeftStickY, SwizzleAxis::YXZ),
            ]
        ),
    ]),
));

```

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

### Valid Transmute Examples in Bevy

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/context/type.ActionsQuery_search=

Demonstrates various valid transmute operations for Bevy queries. These examples show how to change access levels (e.g., `&mut T` to `&T`), rearrange query structures, add or remove filters, and transmute to specific filtered types like `FilteredEntityMut`.

```rust
// `&mut T` and `Mut<T>` access the same data and can be transmuted to each other,
// `&T` and `Ref<T>` access the same data and can be transmuted to each other,
// and mutable versions can be transmuted to read-only versions
assert_valid_transmute::<&mut T, &T>();
assert_valid_transmute::<&mut T, Mut<T>>();
assert_valid_transmute::<Mut<T>, &mut T>();
assert_valid_transmute::<&T, Ref<T>>();
assert_valid_transmute::<Ref<T>, &T>();

// The structure can be rearranged, or subqueries dropped
assert_valid_transmute::<(&T, &U), &T>();
assert_valid_transmute::<((&T, &U), &V), (&T, (&U, &V))>();
assert_valid_transmute::<Option<(&T, &U)>, (Option<&T>, Option<&U>)>();

// Queries with no access can be freely added
assert_valid_transmute::<    &T,
    (&T, Entity, EntityLocation, &Archetype, Has<U>, PhantomData<T>),
>();

// Required access can be transmuted to optional,
// and optional access can be transmuted to other optional access
assert_valid_transmute::<&T, Option<&T>>();
assert_valid_transmute::<AnyOf<(&mut T, &mut U)>, Option<&T>>();
// Note that removing subqueries from `AnyOf` will result
// in an `AnyOf` where all subqueries can yield `None`!
assert_valid_transmute::<AnyOf<(&T, &U, &V)>, AnyOf<(&T, &U)>>();
assert_valid_transmute::<EntityMut, Option<&mut T>>();

// Anything can be transmuted to `FilteredEntityRef` or `FilteredEntityMut`
// This will create a `FilteredEntityMut` that only has read access to `T`
assert_valid_transmute::<&T, FilteredEntityMut>();
// This will create a `FilteredEntityMut` that has no access to `T`,
// read access to `U`, and write access to `V`.
assert_valid_transmute::<(&mut T, &mut U, &mut V), (&mut T, &U, FilteredEntityMut)>();

// `Added<T>` and `Changed<T>` filters have the same access as `&T` data
// Remember that they are only evaluated on the transmuted query, not the original query!
assert_valid_transmute_filtered::<Entity, Changed<T>, &T, ()>();
assert_valid_transmute_filtered::<&mut T, (), &T, Added<T>>();
// Nested inside of an `Or` filter, they have the same access as `Option<&T>`.
assert_valid_transmute_filtered::<Option<&T>, (), Entity, Or<(Changed<T>, With<U>)>>();

```

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

### Implement Plugin for EnhancedInputPlugin

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/struct.EnhancedInputPlugin_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implements the `Plugin` trait for `EnhancedInputPlugin`. This allows the plugin to be added to a Bevy `App`. The `build` method configures the app, while `finish` and `ready` handle asynchronous setup. `cleanup` runs after setup, and `name` provides a unique identifier.

```rust
impl Plugin for EnhancedInputPlugin {
    fn build(&self, app: &mut App) {
        // Configuration logic here
    }

    fn finish(&self, app: &mut App) {
        // Asynchronous setup completion
    }

    fn ready(&self, _app: &App) -> bool {
        // Check if setup is complete
        true
    }

    fn cleanup(&self, _app: &mut App) {
        // Cleanup logic after build and finish
    }

    fn name(&self) -> &str {
        "EnhancedInputPlugin"
    }

    fn is_unique(&self) -> bool {
        true
    }
}

```

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

### Mouse Wheel Binding Example

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/binding/enum.Binding_search=std%3A%3Avec

Demonstrates how to configure a mouse wheel binding for an action, specifically using SwizzleAxis::YXZ to capture vertical scrolling for an f32 output action. This example requires Bevy and bevy_enhanced_input.

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

actions!(PlayerCam[
    (
        Action::<Zoom>::new(),
        // Without this modifier, it will use horizontal mouse scrolling.
        bindings![(Binding::mouse_wheel(), SwizzleAxis::YXZ)],
    )
]);

#[derive(InputAction)]
#[action_output(f32)]
struct Zoom;

#[derive(Component)]
struct PlayerCam;
```

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

### Valid Transmute Examples for Bevy Queries (Rust)

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/context/type.ActionsQuery

Provides various examples of valid transmutes for Bevy queries, showcasing transformations between different reference types (`&mut T`, `Mut<T>`, `&T`, `Ref<T>`), structural rearrangements, and modifications to query access levels. These transmutes are crucial for optimizing query performance and flexibility.

```rust
// `&mut T` and `Mut<T>` access the same data and can be transmuted to each other,
// `&T` and `Ref<T>` access the same data and can be transmuted to each other,
// and mutable versions can be transmuted to read-only versions
assert_valid_transmute::<&mut T, &T>();
assert_valid_transmute::<&mut T, Mut<T>>();
assert_valid_transmute::<Mut<T>, &mut T>();
assert_valid_transmute::<&T, Ref<T>>();
assert_valid_transmute::<Ref<T>, &T>();

// The structure can be rearranged, or subqueries dropped
assert_valid_transmute::<(&T, &U), &T>();
assert_valid_transmute::<((&T, &U), &V), (&T, (&U, &V))>();
assert_valid_transmute::<Option<(&T, &U)>, (Option<&T>, Option<&U>)>();

// Queries with no access can be freely added
assert_valid_transmute::<    &T,
    (&T, Entity, EntityLocation, &Archetype, Has<U>, PhantomData<T>),
>();

// Required access can be transmuted to optional,
// and optional access can be transmuted to other optional access
assert_valid_transmute::<&T, Option<&T>>();
assert_valid_transmute::<AnyOf<(&mut T, &mut U)>, Option<&T>>();
// Note that removing subqueries from `AnyOf` will result
// in an `AnyOf` where all subqueries can yield `None`!
assert_valid_transmute::<AnyOf<(&T, &U, &V)>, AnyOf<(&T, &U)>>();
assert_valid_transmute::<EntityMut, Option<&mut T>>();

// Anything can be transmuted to `FilteredEntityRef` or `FilteredEntityMut`
// This will create a `FilteredEntityMut` that only has read access to `T`
assert_valid_transmute::<&T, FilteredEntityMut>();
// This will create a `FilteredEntityMut` that has no access to `T`,
// read access to `U`, and write access to `V`.
assert_valid_transmute::<(&mut T, &mut U, &mut V), (&mut T, &U, FilteredEntityMut)>();

// `Added<T>` and `Changed<T>` filters have the same access as `&T` data
// Remember that they are only evaluated on the transmuted query, not the original query!
assert_valid_transmute_filtered::<Entity, Changed<T>, &T, ()>();
assert_valid_transmute_filtered::<&mut T, (), &T, Added<T>>();
// Nested inside of an `Or` filter, they have the same access as `Option<&T>`.
assert_valid_transmute_filtered::<Option<&T>, (), Entity, Or<(Changed<T>, With<U>)>>();
```

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

### Rust Vector Capacity Example

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/binding/relationship/struct.Bindings_search=u32+-%3E+bool

Demonstrates how to check the capacity of a `Vec` in Rust using the `capacity()` method. It shows that capacity is the total number of elements the vector can hold before reallocating and provides an example with zero-sized elements.

```rust
let mut vec: Vec<i32> = Vec::with_capacity(10);
vec.push(42);
assert!(vec.capacity() >= 10);

#[derive(Clone)]
struct ZeroSized;

fn main() {
    assert_eq!(std::mem::size_of::<ZeroSized>(), 0);
    let v = vec![ZeroSized; 0];
    assert_eq!(v.capacity(), usize::MAX);
}

```

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

### Get Vector Capacity in Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/relationship/struct.Actions_search=std%3A%3Avec

Demonstrates how to get the total capacity of a vector, which is the number of elements it can hold without reallocating. Includes examples for standard vectors and vectors with zero-sized elements.

```rust
let mut vec: Vec<i32> = Vec::with_capacity(10);
vec.push(42);
assert!(vec.capacity() >= 10);
```

```rust

#[derive(Clone)]
struct ZeroSized;

fn main() {
    assert_eq!(std::mem::size_of::<ZeroSized>(), 0);
    let v = vec![ZeroSized; 0];
    assert_eq!(v.capacity(), usize::MAX);
}
```

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

### Get Vector Capacity in Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/relationship/struct.Actions_search=

Demonstrates how to get the total capacity of a Rust Vec<T> before reallocation. It shows examples with standard integers and zero-sized elements, highlighting that zero-sized elements result in a capacity of usize::MAX.

```rust
let mut vec: Vec<i32> = Vec::with_capacity(10);
vec.push(42);
assert!(vec.capacity() >= 10);
```

```rust
#[derive(Clone)]
struct ZeroSized;

fn main() {
    assert_eq!(std::mem::size_of::<ZeroSized>(), 0);
    let v = vec![ZeroSized; 0];
    assert_eq!(v.capacity(), usize::MAX);
}
```

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

### Demonstrate Valid Query Transmutes in Bevy

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/context/type.ActionsQuery_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates various valid transmute operations for Bevy queries. These examples show how to change access levels (e.g., `&mut T` to `&T`), rearrange query structures, add or remove query terms, and convert between different query filter types like `Option` and `AnyOf`. It covers basic data access, structural changes, and filter manipulations.

```rust
assert_valid_transmute::<&mut T, &T>();
assert_valid_transmute::<&mut T, Mut<T>>();
assert_valid_transmute::<Mut<T>, &mut T>();
assert_valid_transmute::<&T, Ref<T>>();
assert_valid_transmute::<Ref<T>, &T>();

// The structure can be rearranged, or subqueries dropped
assert_valid_transmute::<(&T, &U), &T>();
assert_valid_transmute::<((&T, &U), &V), (&T, (&U, &V))>();
assert_valid_transmute::<Option<(&T, &U)>, (Option<&T>, Option<&U>)>();

// Queries with no access can be freely added
assert_valid_transmute::<&T, (&T, Entity, EntityLocation, &Archetype, Has<U>, PhantomData<T>)>();

// Required access can be transmuted to optional,
// and optional access can be transmuted to other optional access
assert_valid_transmute::<&T, Option<&T>>();
assert_valid_transmute::<AnyOf<(&mut T, &mut U)>, Option<&T>>();
// Note that removing subqueries from `AnyOf` will result
// in an `AnyOf` where all subqueries can yield `None`!
assert_valid_transmute::<AnyOf<(&T, &U, &V)>, AnyOf<(&T, &U)>>();
assert_valid_transmute::<EntityMut, Option<&mut T>>();

// Anything can be transmuted to `FilteredEntityRef` or `FilteredEntityMut`
// This will create a `FilteredEntityMut` that only has read access to `T`
assert_valid_transmute::<&T, FilteredEntityMut>();
// This will create a `FilteredEntityMut` that has no access to `T`,
// read access to `U`, and write access to `V`.
assert_valid_transmute::<(&mut T, &mut U, &mut V), (&mut T, &U, FilteredEntityMut)>();

// `Added<T>` and `Changed<T>` filters have the same access as `&T` data
// Remember that they are only evaluated on the transmuted query, not the original query!
assert_valid_transmute_filtered::<Entity, Changed<T>, &T, ()>();
assert_valid_transmute_filtered::<&mut T, (), &T, Added<T>>();
// Nested inside of an `Or` filter, they have the same access as `Option<&T>`.
assert_valid_transmute_filtered::<Option<&T>, (), Entity, Or<(Changed<T>, With<U>)>>();
```

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

### Get Slice Reference from Container (Rust)

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/relationship/struct.Actions

Provides examples of using `as_slice` to obtain a reference to the underlying slice data from container types like `Box<[T]>` or `Arc<[T]>`. This is a nightly-only experimental API.

```rust
// Example usage with Box<[T]> (conceptual, requires nightly)
// let boxed_slice: Box<[i32]> = Box::new([1, 2, 3]);
// let slice_ref: &[i32] = boxed_slice.as_slice();

// Example usage with Arc<[T]> (conceptual, requires nightly)
// use std::sync::Arc;
// let arc_slice: Arc<[i32]> = Arc::new([4, 5, 6]);
// let slice_ref: &[i32] = arc_slice.as_slice();

```

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

### Query SystemParam Implementation

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/context/type.ActionsQuery_search=

This section details the SystemParam implementation for Bevy's Query, including state initialization, access registration, parameter retrieval, and deferred mutation handling.

```APIDOC
## Query SystemParam Implementation

### Description
This documentation outlines the `SystemParam` implementation for Bevy's `Query`. It covers the methods required for initializing and managing the state of a query within a system, accessing world data, and handling deferred mutations.

### Methods

#### `into_iter`

*   **Description**: Creates an iterator from a value.
*   **Signature**: `fn into_iter(self) -> <Query<'w, 's, D, F> as IntoIterator>::IntoIter`

#### `init_state`

*   **Description**: Creates a new instance of this param’s `State`. Used to store data which persists across invocations of a system.
*   **Signature**: `fn init_state(world: &mut World) -> <Query<'_, '_, D, F> as SystemParam>::State`

#### `init_access`

*   **Description**: Registers any `World` access used by this `SystemParam`.
*   **Signature**: `fn init_access( state: &<Query<'_, '_, D, F> as SystemParam>::State, system_meta: &mut SystemMeta, component_access_set: &mut FilteredAccessSet, world: &mut World, )`

#### `get_param` (unsafe)

*   **Description**: Creates a parameter to be passed into a `SystemParamFunction`. Retrieves the query parameter from the world state.
*   **Signature**: `unsafe fn get_param<'w, 's>( state: &'s mut <Query<'_, '_, D, F> as SystemParam>::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'w>, change_tick: Tick, ) -> <Query<'_, '_, D, F> as SystemParam>::Item<'w, 's>`

#### `apply`

*   **Description**: Applies any deferred mutations stored in this `SystemParam`’s state. This is used to apply `Commands` during `ApplyDeferred`.
*   **Signature**: `fn apply(state: &mut Self::State, system_meta: &SystemMeta, world: &mut World)`

#### `queue`

*   **Description**: Queues any deferred mutations to be applied at the next `ApplyDeferred`.
*   **Signature**: `fn queue( state: &mut Self::State, system_meta: &SystemMeta, world: DeferredWorld<'_>, )`

#### `validate_param` (unsafe)

*   **Description**: Validates that the param can be acquired by the `get_param`.
*   **Signature**: `unsafe fn validate_param( state: &mut Self::State, system_meta: &SystemMeta, world: UnsafeWorldCell<'_>, ) -> Result<(), SystemParamValidationError>`

### Associated Types

#### `State`

*   **Description**: Used to store data which persists across invocations of a system.
*   **Type**: `QueryState<D, F>`

#### `Item<'w, 's>`

*   **Description**: The item type returned when constructing this system param. The value of this associated type should be `Self`, instantiated with new lifetimes.
*   **Type**: `Query<'w, 's, D, F>`

### Traits

*   **`Copy`**: Implemented if `D: ReadOnlyQueryData` and `F: QueryFilter`.
*   **`ReadOnlySystemParam`**: Implemented if `D: ReadOnlyQueryData + 'static` and `F: QueryFilter + 'static`.
```

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

### Getting Owned Reflect Value in Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/context/struct.ContextActivity_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `reflect_owned` function consumes the value and returns an owned, boxed version that implements `Reflect`. This is useful when you need to take ownership of the reflected data, for example, when moving it between systems.

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

```

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

### Generic Implementations

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/modifier/clamp/struct.Clamp_search=

Documentation for various blanket implementations, including `Any`, `Borrow`, `Bundle`, `CloneToUninit`, `Downcast`, `DowncastSend`, `DynamicBundle`, `DynamicTypePath`, and `DynamicTyped`.

```APIDOC
## Generic Implementations

This section details various blanket implementations provided for generic types.

### `impl<T> Any for T`

*   **`type_id()`**: Gets the `TypeId` of `self`.

### `impl<T> Borrow<T> for T`

*   **`borrow()`**: Immutably borrows from an owned value.

### `impl<T> BorrowMut<T> for T`

*   **`borrow_mut()`**: Mutably borrows from an owned value.

### `impl<C> Bundle for C`

*   **`component_ids()`**: Returns an iterator over this `Bundle`’s component IDs.
*   **`get_component_ids()`**: Returns an iterator over this `Bundle`’s component IDs. This will be `None` if the component has not been registered.

### `impl<C> BundleFromComponents for C`

*   **`from_components()`**: Creates a bundle from components.

### `impl<T> CloneToUninit for T`

*   **`clone_to_uninit()`**: Performs copy-assignment from `self` to `dest`. (Nightly-only experimental API)

### `impl<T> Downcast for T`

*   **`into_any()`**: Converts `Box<dyn Trait>` to `Box<dyn Any>`.
*   **`into_any_rc()`**: Converts `Rc<Trait>` to `Rc<Any>`.
*   **`as_any()`**: Converts `&Trait` to `&Any`.
*   **`as_any_mut()`**: Converts `&mut Trait` to `&mut Any`.

### `impl<T> DowncastSend for T`

*   **`into_any_send()`**: Converts `Box<Trait>` to `Box<dyn Any + Send>`.

### `impl<C> DynamicBundle for C`

*   **`Effect`**: An operation on the entity that happens _after_ inserting this bundle.
*   **`get_components()`**: Moves the components out of the bundle.
*   **`apply_effect()`**: Applies the after-effects of spawning this bundle.

### `impl<T> DynamicTypePath for T`

*   **`reflect_type_path()`**: See `TypePath::type_path`.
*   **`reflect_short_type_path()`**: See `TypePath::short_type_path`.
*   **`reflect_type_ident()`**: See `TypePath::type_ident`.
*   **`reflect_crate_name()`**: See `TypePath::crate_name`.
*   **`reflect_module_path()`**: See `TypePath::module_path`.

### `impl<T> DynamicTyped for T`

*   **`reflect_type_info()`**: See `Typed::type_info`.

### `impl<T> From<T> for T`

*   No specific methods documented here.
```

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

### Get Element Offset (Rust)

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/binding/relationship/struct.Bindings

Returns the index of an element within a slice using pointer arithmetic. It returns `Some(index)` if the element reference points to the start of an element, and `None` otherwise. This method does not compare elements and panics if `T` is zero-sized.

```rust
pub fn element_offset(&self, element: &T) -> Option<usize>

// Example Usage:
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(nums.element_offset(num), Some(2));

let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(arr.element_offset(weird_elm), None);
```

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

### Get Element Offset (Rust)

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/relationship/struct.Actions

Returns the index of a given element reference within a slice using pointer arithmetic. It returns `None` if the element reference does not point to the start of an element within the slice or if `T` is zero-sized. This method does not compare element values.

```rust
pub fn element_offset(&self, element: &T) -> Option<usize>
{
    // Implementation details omitted for brevity
    unimplemented!();
}

// Example Usage:
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));

let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

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

### Example: bindings! with multiple inputs - Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/macro.bindings

Demonstrates using the bindings! macro with multiple input types that implement Into<Binding>, such as KeyCode and GamepadButton.

```rust
world.spawn(bindings![KeyCode::Space, GamepadButton::South]);
```

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

### Get Element Index from Reference (Rust)

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/relationship/struct.Actions_search=

Determines the index of a given element reference within a slice using pointer arithmetic. It returns `Some(index)` if the reference points to the start of an element, and `None` otherwise. This method does not compare element values and panics if `T` is zero-sized.

```rust
let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));

let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1
```

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

### Loading Input Bindings from Settings

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/preset/index

Provides an example of loading input configurations from a `Resource` struct, `InputSettings`, which holds arrays of `Binding`s for actions like forward, backward, left, and right. It demonstrates how to map these settings to `Cardinal` presets.

```rust
// Could be loaded from a file.
// `Binding::None` represents unbound inputs.
let settings = InputSettings {
    forward: [Binding::from(KeyCode::KeyW), Binding::None],
    right: [Binding::from(KeyCode::KeyA), Binding::None],
    backward: [Binding::from(KeyCode::KeyS), Binding::None],
    left: [Binding::from(KeyCode::KeyD), Binding::None],
};

Bindings::spawn((
    Cardinal {
        north: settings.forward[0],
        east: settings.right[0],
        south: settings.backward[0],
        west: settings.left[0],
    },
    Cardinal {
        north: settings.forward[1],
        east: settings.right[1],
        south: settings.backward[1],
        west: settings.left[1],
    },
));

/// Bindings for actions.
///
/// Represented as arrays because in games you usually
/// have 2 or 3 bindings for a single action.
///
/// Usually stored as a resource.
#[derive(Resource)]
struct InputSettings {
    forward: [Binding; 2],
    right: [Binding; 2],
    backward: [Binding; 2],
    left: [Binding; 2],
}
```

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

### GET /query/into_query_lens

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/context/type.ActionsQuery_search=u32+-%3E+bool

Consumes the query to get a `QueryLens` with the same accesses as the existing query.

```APIDOC
## GET /query/into_query_lens

### Description
This method consumes the original `Query` (takes `self`) and returns a `QueryLens` that possesses the identical data accesses. This is useful when you want to convert a `Query` into a `QueryLens` and no longer need the original `Query` object.

### Method
GET

### Endpoint
`/query/into_query_lens`

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **query_lens** (QueryLens<'w, D>) - A QueryLens with the same data accesses as the original query, consuming the original query.

#### Response Example
```json
{
  "query_lens": "<QueryLens<'w, D>>"
}
```
```

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

### GET /query/as_query_lens

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/context/type.ActionsQuery_search=u32+-%3E+bool

Gets a `QueryLens` with the same accesses as the existing query without consuming it.

```APIDOC
## GET /query/as_query_lens

### Description
This method retrieves a `QueryLens` that mirrors the exact data accesses of the existing query. Unlike `into_query_lens`, this method borrows the query mutably (`&mut self`) and does not consume it, allowing the original query to be used further.

### Method
GET

### Endpoint
`/query/as_query_lens`

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **query_lens** (QueryLens<'_, D>) - A QueryLens with the same data accesses as the original query.

#### Response Example
```json
{
  "query_lens": "<QueryLens<'_, D>>"
}
```
```

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

### ComboStep Constructor and Methods (Rust)

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/condition/combo/struct.ComboStep

Provides methods for creating and configuring ComboStep instances. `new` initializes a ComboStep with default events and timeout, while `with_events` and `with_timeout` allow for custom configuration.

```rust
impl ComboStep {
    pub fn new(action: Entity) -> Self
    pub fn with_events(self, events: ActionEvents) -> Self
    pub fn with_timeout(self, timeout: f32) -> Self
}
```

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

### Bundle and DynamicBundle Implementations

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/modifier/clamp/struct.Clamp_search=std%3A%3Avec

Documentation for `Bundle` and `DynamicBundle` related implementations, including component registration and dynamic insertion.

```APIDOC
### impl<C> Bundle for C

#### fn component_ids( components: &mut ComponentsRegistrator<'_>, ) -> impl Iterator<Item = ComponentId>

#### fn get_component_ids( components: &Components, ) -> impl Iterator<Item = Option<ComponentId>>
Return a iterator over this `Bundle`’s component ids.

### impl<C> BundleFromComponents for C

#### unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C

### impl<C> DynamicBundle for C

#### type Effect = ()

#### unsafe fn get_components( ptr: MovingPtr<'_, C>, func: &mut impl FnMut(StorageType, OwningPtr<'_>), ) -> <C as DynamicBundle>::Effect
Moves the components out of the bundle.

#### unsafe fn apply_effect( _ptr: MovingPtr<'_, MaybeUninit<C>>, _entity: &mut EntityWorldMut<'_>, )
Applies the after-effects of spawning this bundle.
```

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

### Get Slice Length in Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/relationship/struct.Actions_search=

Demonstrates how to get the number of elements in a Rust slice using the `len` method.

```rust
let a = [1, 2, 3];
assert_eq!(a.len(), 3);
```

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

### Dynamic Bundle Creation from Components (Rust)

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/struct.ActionSettings

Enables the creation of a `Bundle` from a set of components using a provided context and a function to retrieve components. This is an unsafe operation requiring careful management.

```rust
unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,
Source§
```

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

### Example: bindings! with tuple input - Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/macro.bindings

Shows how to use the bindings! macro with a tuple, where the first element is an input type implementing Into<Binding> and the second element is a regular component.

```rust
world.spawn(bindings![( GamepadButton::RightTrigger2, Down::new(0.3), )]);
```

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

### Get Type Path Information

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/condition/tap/struct.Tap_search=

These functions provide different ways to get the path and identity information for a given type. They are useful for debugging and reflection purposes.

```rust
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.
```

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

### Get First Element of Slice in Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/action/relationship/struct.Actions_search=

Demonstrates how to safely get a reference to the first element of a Rust slice using `first`. It returns `Some(&T)` if the slice is not empty, and `None` otherwise.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());
```

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

### GamepadDevice Equality Comparison

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/context/enum.GamepadDevice_search=

Details the equality comparison methods for `GamepadDevice`.

```APIDOC
## GamepadDevice Equality Comparison

### Description
This section describes how `GamepadDevice` instances are compared for equality.

### Implementations

#### `impl PartialEq for GamepadDevice`
- `eq(&self, other: &GamepadDevice)`: Tests if two `GamepadDevice` instances are equal.
- `ne(&self, other: &Rhs)`: Tests if two `GamepadDevice` instances are not equal.
```

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

### Example: bindings! with multiple tuple inputs - Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/macro.bindings

Illustrates using the bindings! macro with a list of tuples, each containing an input type implementing Into<Binding> and additional components.

```rust
world.spawn(bindings![
    (GamepadButton::RightTrigger2, Down::new(0.3)),
    MouseButton::Left,
]);
```

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

### Get Value by Path - Rust

Source: https://docs.rs/bevy_enhanced_input/0.23.2/bevy_enhanced_input/binding/enum.Binding

Provides methods to get an immutable reference to a value within a structure using a `ReflectPath`. This is a powerful tool for navigating nested data.

```rust
impl<I> GetPath for I
where I: Reflect + ?Sized,
{
    fn reflect_path<'p>(
        &self,
        path: impl ReflectPath<'p>,
    ) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>;
    fn path<'p, T>(
        &self,
        path: impl ReflectPath<'p>,
    ) -> Result<&T, ReflectPathError<'p>> where T: Reflect;
}
```
Tokens:
Raw