### ShapeCaster Setup and Hit Detection Example

Source: https://docs.rs/avian2d/latest/src/avian2d/spatial_query/shape_caster.rs.html?search=u32+-%3E+bool

This example demonstrates how to spawn a ShapeCaster with a specific shape and direction, and how to iterate over detected hits. Ensure the appropriate Avian2D feature (2D or 3D) and Bevy are included.

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

/// A component used for [shapecasting](spatial_query#shapecasting).
///
/// **Shapecasting** is a type of [spatial query](spatial_query) where a shape travels along a straight
/// line and computes hits with colliders. This is often used to determine how far an object can move
/// in a direction before it hits something.
///
/// Each shapecast is defined by a `shape` (a [`Collider`]), its local `shape_rotation`, a local `origin` and
/// a local `direction`. The [`ShapeCaster`] will find each hit and add them to the [`ShapeHits`] component in
/// the order of distance.
///
/// Computing lots of hits can be expensive, especially against complex geometry, so the maximum number of hits
/// is one by default. This can be configured through the `max_hits` property.
///
/// The [`ShapeCaster`] is the easiest way to handle simple shapecasting. If you want more control and don't want
/// to perform shapecasts on every frame, consider using the [`SpatialQuery`] system parameter.
///
/// # Hit Count and Order
///
/// The results of a shapecast are in an arbitrary order by default. You can iterate over them in the order of
/// distance with the [`ShapeHits::iter_sorted`] method.
///
/// You can configure the maximum amount of hits for a shapecast using `max_hits`. By default this is unbounded,
/// so you will get all hits. When the number or complexity of colliders is large, this can be very
/// expensive computationally. Set the value to whatever works best for your case.
///
/// Note that when there are more hits than `max_hits`, **some hits will be missed**.
/// To guarantee that the closest hit is included, you should set `max_hits` to one or a value that
/// is enough to contain all hits.
///
/// # Example
///
/// ```
/// # #[cfg(feature = "2d")]
/// # use avian2d::prelude::*;
/// # #[cfg(feature = "3d")]
/// use avian3d::prelude::*;
/// use bevy::prelude::*;
///
/// # #[cfg(all(feature = "3d", feature = "f32"))]
/// fn setup(mut commands: Commands) {
///     // Spawn a shape caster with a ball shape moving right starting from the origin
///     commands.spawn(ShapeCaster::new(
/// #[cfg_attr(feature = "2d", doc = "        Collider::circle(0.5),")]
/// #[cfg_attr(feature = "3d", doc = "        Collider::sphere(0.5),")]
///         Vec3::ZERO,
///         Quat::default(),
///         Dir3::X,
///     ));
/// }
///
/// fn print_hits(query: Query<(&ShapeCaster, &ShapeHits)>) {
///     for (shape_caster, hits) in &query {
///         for hit in hits.iter() {
///             println!("Hit entity {}", hit.entity);
///         }
///     }
/// }
/// ```
#[derive(Component, Clone, Debug, Reflect)]
#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
#[reflect(Debug, Component)]
#[component(on_add = on_add_shape_caster)]
#[require(ShapeHits)]
pub struct ShapeCaster {
    /// Controls if the shape caster is enabled.
    pub enabled: bool,

    /// The shape being cast represented as a [`Collider`].
    #[reflect(ignore)]
    pub shape: Collider,

    /// The local origin of the shape relative to the [`Position`] and [`Rotation`]
    /// of the shape caster entity or its parent.
    ///
    /// To get the global origin, use the `global_origin` method.
    pub origin: Vector,

    /// The global origin of the shape.
    global_origin: Vector,

    /// The local rotation of the shape being cast relative to the [`Rotation`]
    /// of the shape caster entity or its parent. Expressed in radians.
    ///
    /// To get the global shape rotation, use the `global_shape_rotation` method.
    #[cfg(feature = "2d")]
    pub shape_rotation: Scalar,

    /// The local rotation of the shape being cast relative to the [`Rotation`]
    /// of the shape caster entity or its parent.
    ///
    /// To get the global shape rotation, use the `global_shape_rotation` method.
    #[cfg(feature = "3d")]
    pub shape_rotation: Quaternion,

    /// The global rotation of the shape.
    #[cfg(feature = "2d")]
    global_shape_rotation: Scalar,

    /// The global rotation of the shape.
    #[cfg(feature = "3d")]
    global_shape_rotation: Quaternion,

    /// The local direction of the shapecast relative to the [`Rotation`] of the shape caster entity or its parent.
    ///
    /// To get the global direction, use the `global_direction` method.
    pub direction: Dir,

    /// The global direction of the shapecast.
    global_direction: Dir,
}
```

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

### Raycasting Example: Setup and Hit Printing

Source: https://docs.rs/avian2d/latest/avian2d/spatial_query/struct.RayCaster.html

Demonstrates how to spawn a RayCaster and process its hits. Ensure colliders are also spawned for hits to occur. The `iter_sorted` method provides hits ordered by distance.

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

fn setup(mut commands: Commands) {
    // Spawn a ray at the center going right
    commands.spawn(RayCaster::new(Vec3::ZERO, Dir3::X));
    // ...spawn colliders and other things
}

fn print_hits(query: Query<(&RayCaster, &RayHits)>) {
    for (ray, hits) in &query {
        // For the faster iterator that isn't sorted, use `.iter()`
        for hit in hits.iter_sorted() {
            println!(
                "Hit entity {} at {} with normal {}",
                hit.entity,
                ray.origin + *ray.direction * hit.distance,
                hit.normal,
            );
        }
    }
}
```

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

### Example: Setup and System for CollidingEntities

Source: https://docs.rs/avian2d/latest/avian2d/collision/collider/struct.CollidingEntities.html?search=

Demonstrates how to add the CollidingEntities component to a dynamic rigid body and how to create a system to query and print colliding entities. Ensure you have the necessary Avian2D and Bevy prelude imports.

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

fn setup(mut commands: Commands) {
    commands.spawn(( 
        RigidBody::Dynamic,
        Collider::capsule(0.5, 1.5),
        // Add the `CollidingEntities` component to read entities colliding with this entity.
        CollidingEntities::default(),
    ));
}

fn my_system(query: Query<(Entity, &CollidingEntities)>) {
    for (entity, colliding_entities) in &query {
        println!(
            "{} is colliding with the following entities: {:?}",
            entity,
            colliding_entities,
        );
    }
}
```

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

### Example: Setting up Physics Debug Rendering in Bevy

Source: https://docs.rs/avian2d/latest/src/avian2d/debug_render/configuration.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to enable the `PhysicsDebugPlugin` in a Bevy application to visualize physics entities. This setup allows for the rendering of colliders, AABBs, and other physics-related debug information.

```rust
use avian2d::prelude::*
use bevy::prelude::*

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, PhysicsPlugins::default(), PhysicsDebugPlugin))
        .run();
}

fn setup(mut commands: Commands) {
    // This rigid body and its collider and AABB will get rendered
    commands.spawn((RigidBody::Dynamic, Collider::circle(0.5), DebugRender::default().with_collider_color(Color::srgb(1.0, 0.0, 0.0))));
}
```

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

### Basic Physics Debugging Setup with Bevy

Source: https://docs.rs/avian2d/latest/avian2d/debug_render/struct.DebugRender.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to set up a Bevy application with Avian2D physics and enable debug rendering. This example shows spawning an entity with a RigidBody, Collider, and a custom DebugRender configuration.

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

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, PhysicsPlugins::default(), PhysicsDebugPlugin))
        .run();
}

fn setup(mut commands: Commands) {
    // This rigid body and its collider and AABB will get rendered
    commands.spawn((RigidBody::Dynamic,
        Collider::circle(0.5),
        // Overwrite default collider color (optional)
        DebugRender::default().with_collider_color(Color::srgb(1.0, 0.0, 0.0)),
    ));
}
```

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

### Example of Collider Hierarchy Setup

Source: https://docs.rs/avian2d/latest/src/avian2d/collision/collider/collider_hierarchy/mod.rs.html

Demonstrates how to spawn entities with RigidBody, Collider, and children colliders. All colliders will be attached to the parent rigid body by default.

```rust
# use avian2d::prelude::*
# use bevy::prelude::*
# fn setup(mut commands: Commands) {
commands.spawn((
    RigidBody::Dynamic,
    Collider::capsule(0.5, 1.5),
    children![
        (Collider::capsule(0.5, 1.5), Transform::from_xyz(-2.0, 0.0, 0.0)),
        (Collider::capsule(0.5, 1.5), Transform::from_xyz(2.0, 0.0, 0.0))
    ]
));
# }

```

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

### Observing CollisionStart Events

Source: https://docs.rs/avian2d/latest/avian2d/collision/collision_events/struct.CollisionStart.html?search=std%3A%3Avec

Example of how to observe CollisionStart events using Bevy's observer pattern, allowing for immediate reaction to collision starts.

```APIDOC
## Example: Observing CollisionStart

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

#[derive(Component)]
struct Player;

#[derive(Component)]
struct PressurePlate;

fn setup_pressure_plates(mut commands: Commands) {
    commands.spawn(( 
        PressurePlate,
        Collider::rectangle(1.0, 1.0),
        Sensor,
        // Enable collision events for this entity.
        CollisionEventsEnabled,
    ))
    .observe(on_player_stepped_on_plate);
}

fn on_player_stepped_on_plate(event: On<CollisionStart>, player_query: Query<&Player>) {
    // `colider1` and `body1` refer to the event target and its body.
    // `collider2` and `body2` refer to the other collider and its body.
    let pressure_plate = event.collider1;
    let other_entity = event.collider2;

    if player_query.contains(other_entity) {
        println!("Player {other_entity} stepped on pressure plate {pressure_plate}");
    }
}
```
```

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

### Setup ShapeCaster

Source: https://docs.rs/avian2d/latest/src/avian2d/spatial_query/mod.rs.html

Example of spawning a ShapeCaster with a sphere shape. Ensure the '3d' feature is enabled.

```rust
#[cfg(all(feature = "3d", feature = "f32"))]
fn setup(mut commands: Commands) {
    // Spawn a shape caster with a sphere shape at the center travelling right
    commands.spawn(ShapeCaster::new(
        Collider::sphere(0.5), // Shape
        Vec3::ZERO,            // Origin
        Quat::default(),       // Shape rotation
        Dir3::X                // Direction
    ));
    // ...spawn colliders and other things
}
```

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

### Raycasting Example

Source: https://docs.rs/avian2d/latest/src/avian2d/spatial_query/ray_caster.rs.html

Demonstrates how to spawn a RayCaster and process its hits. This example assumes a 3D context with f32 precision.

```rust
# #[cfg(feature = "2d")]
# use avian2d::prelude::*;
# #[cfg(feature = "3d")]
use avian3d::prelude::*;
use bevy::prelude::*;

# #[cfg(all(feature = "3d", feature = "f32"))]
# fn setup(mut commands: Commands) {
    // Spawn a ray at the center going right
    commands.spawn(RayCaster::new(Vec3::ZERO, Dir3::X));
    // ...spawn colliders and other things
# }

# #[cfg(all(feature = "3d", feature = "f32"))]
fn print_hits(query: Query<(&RayCaster, &RayHits)>) {
    for (ray, hits) in &query {
        // For the faster iterator that isn't sorted, use `.iter()`
        for hit in hits.iter_sorted() {
            println!(
                "Hit entity {} at {} with normal {}",
                hit.entity,
                ray.origin + *ray.direction * hit.distance,
                hit.normal,
            );
        }
    }
}

```

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

### IslandPlugin Setup

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/solver/islands/mod.rs.html?search=std%3A%3Avec

This code demonstrates the setup for the `IslandPlugin` within a Bevy application. It initializes the `PhysicsIslands` resource and registers `BodyIslandNode` for `SolverBody` components.

```rust
use bevy::prelude::*;
use crate::dynamics::solver::solver_body::SolverBody;

/// A plugin for managing [`PhysicsIsland`]s.
///
/// See the [module-level documentation](self) for more information.
pub struct IslandPlugin;

impl Plugin for IslandPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<PhysicsIslands>();

        // Insert `BodyIslandNode` for each `SolverBody`.
        app.register_required_components::<SolverBody, BodyIslandNode>();

        // Add `BodyIslandNode` for each dynamic and kinematic rigid body
        // when the associated rigid body is enabled.
        app.add_observer(
            |trigger: On<Replace, RigidBodyDisabled>,
             rb_query: Query<&RigidBody>,
             mut commands: Commands| {
                let Ok(rb) = rb_query.get(trigger.entity) else {
                    return;
                };
                if rb.is_dynamic() || rb.is_kinematic() {
                    commands
                        .entity(trigger.entity)
                        .try_insert(BodyIslandNode::default());
                }
            },
        );
        app.add_observer(
            |trigger: On<Replace, Disabled>,
             rb_query: Query<
                &RigidBody,
                (
                    // The body still has `Disabled` at this point,
                    // and we need to include in the query to match against the entity.
                    With<Disabled>,
                    Without<RigidBodyDisabled>,
                ),
            >,
             mut commands: Commands| {
                let Ok(rb) = rb_query.get(trigger.entity) else {
                    return;
                };

```

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

### Raycasting Example

Source: https://docs.rs/avian2d/latest/src/avian2d/spatial_query/ray_caster.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to spawn a RayCaster and iterate over its sorted hits. This example assumes a 3D context with f32 precision.

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

#[derive(Component, Clone, Debug, PartialEq, Reflect)]
#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
#[reflect(Debug, Component, PartialEq)]
#[component(on_add = on_add_ray_caster)]
#[require(RayHits)]
pub struct RayCaster {
    /// Controls if the ray caster is enabled.
    pub enabled: bool,

    /// The local origin of the ray relative to the [`Position`] and [`Rotation`] of the ray entity or its parent.
    ///
    /// To get the global origin, use the `global_origin` method.
    pub origin: Vector,

    /// The global origin of the ray.
    global_origin: Vector,

    /// The local direction of the ray relative to the [`Rotation`] of the ray entity or its parent.
    ///
    /// To get the global direction, use the `global_direction` method.
    pub direction: Dir,

    /// The global direction of the ray.
    global_direction: Dir,

    /// The maximum number of hits allowed.
    ///
    /// When there are more hits than `max_hits`, **some hits will be missed**.
    /// To guarantee that the closest hit is included, you should set `max_hits` to one or a value that
    /// is enough to contain all hits.
    pub max_hits: u32,

    /// The maximum distance the ray can travel.
    ///
    /// By default this is infinite, so the ray will travel until all hits up to `max_hits` have been checked.
    #[doc(alias = "max_time_of_impact")]
    pub max_distance: Scalar,

    /// Controls how the ray behaves when the ray origin is inside of a [collider](Collider).
    ///
    /// If `true`, shapes will be treated as solid, and the ray cast will return with a distance of `0.0`
    /// if the ray origin is inside of the shape. Otherwise, shapes will be treated as hollow, and the ray
    /// will always return a hit at the shape's boundary.
    pub solid: bool,

    /// If true, the ray caster ignores hits against its own [`Collider`]. This is the default.
    pub ignore_self: bool,

    /// Rules that determine which colliders are taken into account in the ray cast.
    pub query_filter: SpatialQueryFilter,
}

#[cfg(all(feature = "3d", feature = "f32"))]
fn setup(mut commands: Commands) {
    // Spawn a ray at the center going right
    commands.spawn(RayCaster::new(Vec3::ZERO, Dir3::X));
    // ...spawn colliders and other things
}

#[cfg(all(feature = "3d", feature = "f32"))]
fn print_hits(query: Query<(&RayCaster, &RayHits)>) {
    for (ray, hits) in &query {
        // For the faster iterator that isn't sorted, use `.iter()`
        for hit in hits.iter_sorted() {
            println!(
                "Hit entity {} at {} with normal {}",
                hit.entity,
                ray.origin + *ray.direction * hit.distance,
                hit.normal,
            );
        }
    }
}

```

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

### Finish Plugin Setup

Source: https://docs.rs/avian2d/latest/avian2d/collision/narrow_phase/struct.NarrowPhasePlugin.html?search=std%3A%3Avec

Completes the setup of the NarrowPhasePlugin after all other plugins have been built. This is useful for plugins that have asynchronous initialization or depend on other plugins' setup.

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

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

### Raycasting Example in Avian2D/3D

Source: https://docs.rs/avian2d/latest/src/avian2d/spatial_query/ray_caster.rs.html?search=std%3A%3Avec

This example demonstrates how to set up a RayCaster in a 3D Bevy application and how to process the resulting RayHits. It shows spawning a ray and iterating through sorted hits to print information about each intersection.

```rust
use crate::prelude::*
use bevy::prelude::*

#[cfg(all(feature = "3d", feature = "f32"))]
fn setup(mut commands: Commands) {
    // Spawn a ray at the center going right
    commands.spawn(RayCaster::new(Vec3::ZERO, Dir3::X));
    // ...spawn colliders and other things
}

#[cfg(all(feature = "3d", feature = "f32"))]
fn print_hits(query: Query<(&RayCaster, &RayHits)>) {
    for (ray, hits) in &query {
        // For the faster iterator that isn't sorted, use `.iter()`
        for hit in hits.iter_sorted() {
            println!(
                "Hit entity {} at {} with normal {}",
                hit.entity,
                ray.origin + *ray.direction * hit.distance,
                hit.normal,
            );
        }
    }
}
```

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

### Finish ColliderTransformPlugin Setup

Source: https://docs.rs/avian2d/latest/avian2d/collision/collider/collider_transform/struct.ColliderTransformPlugin.html

Completes the setup of the ColliderTransformPlugin after all other registered plugins are ready. This is essential for plugins that depend on the asynchronous completion of other plugins.

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

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

### Example: Spawning Entities with Collider Constructors

Source: https://docs.rs/avian2d/latest/src/avian2d/collision/collider/constructor.rs.html?search=u32+-%3E+bool

Demonstrates how to spawn entities with different ColliderConstructor types. This example shows how to create a 2D circle collider and a 3D convex hull collider from a mesh.

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

fn setup(mut commands: Commands, mut assets: ResMut<AssetServer>, mut meshes: Assets<Mesh>) {
     // Spawn a circle with radius 2
    commands.spawn((
        ColliderConstructor::Circle { radius: 2.0 },
        Mesh2d(meshes.add(Circle::new(2.0))),
    ));
}

```

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

fn setup(mut commands: Commands, mut assets: ResMut<AssetServer>, mut meshes: Assets<Mesh>) {
    // Spawn a cube with a convex hull collider generated from the mesh
    commands.spawn((
        ColliderConstructor::ConvexHullFromMesh,
        Mesh3d(meshes.add(Cuboid::default())),
    ));
}

```

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

### HashSet Length Example

Source: https://docs.rs/avian2d/latest/avian2d/collision/collider/struct.CollidingEntities.html

Illustrates how to get the number of elements in a HashSet, which can be used with CollidingEntities.

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

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

map.insert("foo");

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

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

### Example: Enabling and Configuring PhysicsDebugPlugin

Source: https://docs.rs/avian2d/latest/avian2d/debug_render/struct.PhysicsDebugPlugin.html

Demonstrates how to add the PhysicsDebugPlugin to a Bevy application and configure global debug rendering settings.

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

fn main() {
    App::new()
        .add_plugins(( 
            DefaultPlugins,
            PhysicsPlugins::default(),
            // Enables debug rendering
            PhysicsDebugPlugin,
        ))
        // Overwrite default debug rendering configuration (optional)
        .insert_gizmo_config(
            PhysicsGizmos {
                aabb_color: Some(Color::WHITE),
                ..default()
            },
            GizmoConfig::default(),
        )
        .run();
}

fn setup(mut commands: Commands) {
    // This rigid body and its collider and AABB will get rendered
    commands.spawn(( 
        RigidBody::Dynamic,
        Collider::circle(0.5),
        // Overwrite default collider color (optional)
        DebugRender::default().with_collider_color(Color::srgb(1.0, 0.0, 0.0)),
    ));
}
```

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

### Move and Slide Character Controller Example

Source: https://docs.rs/avian2d/latest/src/avian2d/character_controller/move_and_slide.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the move_and_slide function to control a character's movement, including handling collisions and updating velocity. This example is suitable for 2D physics simulations.

```rust
use bevy::prelude::*
use std::collections::HashSet;
#[cfg_attr(feature = "2d", doc = "use avian2d::{prelude::*, math::{Vector, AdjustPrecision as _, AsF32 as _}}

#[derive(Component)]
struct CharacterController {
    velocity: Vector,
}

fn perform_move_and_slide(
    player: Single<(Entity, &Collider, &mut CharacterController, &mut Transform)>, 
    move_and_slide: MoveAndSlide,
    time: Res<Time>
) {
    let (entity, collider, mut controller, mut transform) = player.into_inner();
    let velocity = controller.velocity + Vector::X * 10.0;
    let filter = SpatialQueryFilter::from_excluded_entities([entity]);
    let mut collisions = HashSet::new();
    let out = move_and_slide.move_and_slide(
        collider,
        transform.translation.xy().adjust_precision(),
        transform.rotation.to_euler(EulerRot::XYZ).2.adjust_precision(),
        velocity,
        time.delta(),
        &MoveAndSlideConfig::default(),
        &filter,
        |hit| {
            collisions.insert(hit.entity);
            MoveAndSlideHitResponse::Accept
        },
    );
    transform.translation = out.position.f32().extend(0.0);
    controller.velocity = out.projected_velocity;
    info!("Colliding with entities: {:?}", collisions);
}

```

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

### Enabling and Configuring Physics Debug Rendering

Source: https://docs.rs/avian2d/latest/src/avian2d/debug_render/configuration.rs.html?search=u32+-%3E+bool

This example shows how to set up a Bevy application with physics and enable debug rendering. It demonstrates inserting the `PhysicsDebugPlugin` and customizing the `PhysicsGizmos` configuration.

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

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, PhysicsPlugins::default(), PhysicsDebugPlugin))
        .insert_gizmo_config(
            PhysicsGizmos {
                aabb_color: Some(Color::WHITE),
                ..default()
            },
            GizmoConfig::default(),
        )
        .run();
}

fn setup(mut commands: Commands) {
    // This rigid body and its collider and AABB will get rendered
    commands.spawn((RigidBody::Dynamic, Collider::circle(0.5)));
}
```

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

### HashSet Drain Example

Source: https://docs.rs/avian2d/latest/avian2d/collision/collider/struct.CollidingEntities.html

Shows how to clear a HashSet and get an iterator over its elements. This method is available on CollidingEntities.

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

map.insert("foo");
map.insert("bar");
map.insert("baz");

for value in map.drain() {
    // "foo", "bar", "baz"
    // Note that the above order is not guaranteed
}

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

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

### Get Disjoint Mut Example

Source: https://docs.rs/avian2d/latest/src/avian2d/data_structures/sparse_secondary_map.rs.html?search=u32+-%3E+bool

This snippet demonstrates how to get mutable references to values corresponding to a set of entities, assuming they are valid and disjoint. It includes logic for temporarily modifying and then restoring entity generations to ensure disjointness checks.

```rust
unsafe {
                        *core::mem::transmute::<&mut EntityGeneration, &mut u32>(generation) ^= 1;
                    }
```

```rust
for entity in &entities[0..i] {
            match self.slots.get_mut(&entity.index_u32()) {
                Some(Slot { generation, .. }) => unsafe {
                    *core::mem::transmute::<&mut EntityGeneration, &mut u32>(generation) ^= 1;
                },
                _ => unsafe { core::hint::unreachable_unchecked() },
            }
        }
```

```rust
Some(unsafe { core::mem::transmute_copy::<_, [&mut V; N]>(&ptrs) })
```

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

### Semi-Implicit Euler Integration Test Setup

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/integrator/mod.rs.html

Sets up a Bevy App with necessary plugins and resources for physics simulation, including a dynamic rigid body with initial angular velocity for testing integration methods.

```rust
fn create_app() -> App {
    let mut app = App::new();
    app.add_plugins(( 
        MinimalPlugins,
        PhysicsPlugins::default(),
        TransformPlugin,
        #[cfg(feature = "bevy_scene")]
        AssetPlugin::default(),
        #[cfg(feature = "bevy_scene")]
        bevy::scene::ScenePlugin,
        MeshPlugin,
    ));
    app
}

#[test]
fn semi_implicit_euler() {
    let mut app = create_app();
    app.insert_resource(SubstepCount(1));
    app.finish();

    let body_entity = app
        .world_mut()
        .spawn(( 
            RigidBody::Dynamic,
            #[cfg(feature = "2d")]
            {
                (
                    MassPropertiesBundle::from_shape(&Rectangle::from_length(1.0), 1.0),
                    AngularVelocity(2.0),
                )
            },
            #[cfg(feature = "3d")]
            {
                (
                    MassPropertiesBundle::from_shape(&Cuboid::from_length(1.0), 1.0),
                    AngularVelocity(Vector::Z * 2.0),
                )
            },
        ))
        .id();

    // Step by 100 steps of 0.1 seconds.
}
```

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

### ShapeCaster Example

Source: https://docs.rs/avian2d/latest/src/avian2d/spatial_query/shape_caster.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Spawns a ShapeCaster with a circular shape moving to the right from the origin. This demonstrates basic setup for a 2D shapecast.

```Rust
use crate::prelude::*;
use bevy::prelude::*;

fn setup(mut commands: Commands) {
    // Spawn a shape caster with a ball shape moving right starting from the origin
    commands.spawn(ShapeCaster::new(
        Collider::circle(0.5),
        Vector::ZERO,
        Scalar::default(),
        Dir::X,
    ));
}
```

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

### Initializing ActiveCollisionHooks with Empty Flags

Source: https://docs.rs/avian2d/latest/avian2d/collision/hooks/struct.ActiveCollisionHooks.html

Shows how to get an ActiveCollisionHooks value with no hooks enabled, useful for starting with a default state.

```rust
ActiveCollisionHooks::empty()
```

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

### Example: Enabling and Configuring Debug Rendering

Source: https://docs.rs/avian2d/latest/src/avian2d/debug_render/configuration.rs.html

Demonstrates how to set up the physics engine with debug rendering enabled and spawn an entity with custom collider color.

```rust
#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*")]
#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*")]
use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, PhysicsPlugins::default(), PhysicsDebugPlugin))
        .run();
}

fn setup(mut commands: Commands) {
    // This rigid body and its collider and AABB will get rendered
    commands.spawn((
        RigidBody::Dynamic,
        #[cfg_attr(feature = "2d", doc = "        Collider::circle(0.5),")]
        #[cfg_attr(feature = "3d", doc = "        Collider::sphere(0.5),")]
        // Overwrite default collider color (optional)
        DebugRender::default().with_collider_color(Color::srgb(1.0, 0.0, 0.0)),
    ));
}
```

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

### ShapeCaster Initialization Example

Source: https://docs.rs/avian2d/latest/src/avian2d/spatial_query/shape_caster.rs.html?search=std%3A%3Avec

Spawns a ShapeCaster entity with a circular shape moving right from the origin. This demonstrates basic setup for shapecasting.

```rust
use avian2d::prelude::*
use bevy::prelude::*

fn setup(mut commands: Commands) {
    // Spawn a shape caster with a ball shape moving right starting from the origin
    commands.spawn(ShapeCaster::new(
        Collider::circle(0.5),
        Vec3::ZERO,
        Quat::default(),
        Dir3::X,
    ));
}
```

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

### Solver Configuration Defaults

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/solver/mod.rs.html?search=

Shows how to create a solver using the default configuration settings.

```rust
use avian2d::dynamics::solver::Solver;
use avian2d::dynamics::World;

let mut world = World::new();
let mut solver = Solver::new(&world); // Uses default SolverConfig
```

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

### App Setup with Disabled Plugins

Source: https://docs.rs/avian2d/latest/src/avian2d/collision/collider/constructor.rs.html

Demonstrates setting up a Bevy App with specific plugins disabled, such as WinitPlugin and DiagnosticsPlugin, while enabling PhysicsPlugins.

```rust
let mut app = App::new();
app.add_plugins((
    DefaultPlugins
        .build()
        .disable::<WinitPlugin>()
        .disable::<DiagnosticsPlugin>(),
    PhysicsPlugins::default(),
));
app.finish();
app.cleanup();
app
```

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

### Shapecasting with ShapeCaster Component

Source: https://docs.rs/avian2d/latest/src/avian2d/spatial_query/mod.rs.html?search=std%3A%3Avec

Placeholder for an example demonstrating the setup of a ShapeCaster component for 3D shapecasting. This component is used for sweep testing and automatically updates results each frame.

```rust
# #[cfg(feature = "2d")]
# use avian2d::prelude::*;
# #[cfg(feature = "3d")]
use avian3d::prelude::*;

```

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

### Spawn a Dynamic Rigid Body with a Collider

Source: https://docs.rs/avian2d/latest/avian2d/index.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Create a new entity with a dynamic rigid body and a circular collider. This is a fundamental example for starting with Avian2D physics objects.

```rust
use avian2d::prelude::*
use bevy::prelude::*

fn setup(mut commands: Commands) {
    commands.spawn((RigidBody::Dynamic, Collider::circle(0.5)));
}
```

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

### Raycast Example

Source: https://docs.rs/avian2d/latest/avian2d/spatial_query/struct.SpatialQuery.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to perform a raycast using SpatialQuery. It shows how to cast a single ray and retrieve multiple hits.

```Rust
use avian3d::prelude::*;
use bevy::prelude::*;

fn print_hits(spatial_query: SpatialQuery) {
    // Ray origin and direction
    let origin = Vec3::ZERO;
    let direction = Dir3::X;

    // Configuration for the ray cast
    let max_distance = 100.0;
    let solid = true;
    let filter = SpatialQueryFilter::default();

    // Cast ray and print first hit
    if let Some(first_hit) = spatial_query.cast_ray(origin, direction, max_distance, solid, &filter) {
        println!("First hit: {:?}", first_hit);
    }

    // Cast ray and get up to 20 hits
    let hits = spatial_query.ray_hits(origin, direction, max_distance, 20, solid, &filter);

    // Print hits
    for hit in hits.iter() {
        println!("Hit: {:?}", hit);
    }
}
```

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

### Initialize SolverPlugin Resources

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/solver/plugin.rs.html?search=u32+-%3E+bool

Initializes essential resources for the solver, such as configuration, softness coefficients, contact constraints, and the constraint graph. This setup is crucial before the solver can operate.

```rust
app.init_resource::<SolverConfig>()
            .init_resource::<ContactSoftnessCoefficients>()
            .init_resource::<ContactConstraints>()
            .init_resource::<ConstraintGraph>();
```

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

### Get and Assert Initial Mass Properties

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/rigid_body/mass_properties/mod.rs.html?search=

Retrieves and asserts the computed mass properties of a rigid body after initial setup. Ensures the mass, angular inertia, and center of mass match expected values.

```rust
let (mass, angular_inertia, center_of_mass) = 
            get_computed_mass_properties(app.world_mut(), body_entity);

        assert_eq!(mass.value() as f32, 5.0);
        assert_eq!(
            angular_inertia.value() as f32,
            mass.value() as f32 * collider_mass_props.unit_angular_inertia()
        );
        assert_eq!(*center_of_mass, ComputedCenterOfMass::default());
```

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

### PhysicsLengthUnit Resource Example

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/solver/plugin.rs.html?search=

Demonstrates how to set the `PhysicsLengthUnit` resource when initializing `PhysicsPlugins` for a 2D game with a specific scale.

```rust
# #[cfg(feature = "2d")]
use avian2d::prelude::*;
use bevy::prelude::*;

# #[cfg(feature = "2d")]
fn main() {
    App::new()
        .add_plugins((
            DefaultPlugins,
            // A 2D game with 100 pixels per meter
            PhysicsPlugins::default().with_length_unit(100.0),
        ))
        .run();
}
# #[cfg(not(feature = "2d"))]
# fn main() {} // Doc test needs main
```

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

### Rust Slice `split_at` Example

Source: https://docs.rs/avian2d/latest/avian2d/collision/collider/collider_hierarchy/struct.RigidBodyColliders.html

Shows how to use `split_at` to divide a slice into two at a specified index. The first part contains elements from the start up to (but not including) the index, and the second part contains elements from the index to the end. Panics if the index is out of bounds.

```rust
let v = ['a', 'b', 'c'];

{
   let (left, right) = v.split_at(0);
   assert_eq!(left, []);
   assert_eq!(right, ['a', 'b', 'c']);
}

{
    let (left, right) = v.split_at(2);
    assert_eq!(left, ['a', 'b']);
    assert_eq!(right, ['c']);
}

{
    let (left, right) = v.split_at(3);
    assert_eq!(left, ['a', 'b', 'c']);
    assert_eq!(right, []);
}
```

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

### Enabling Physics Debug Rendering in Bevy

Source: https://docs.rs/avian2d/latest/avian2d/debug_render/struct.PhysicsGizmos.html?search=

Example of setting up a Bevy application with default plugins, physics plugins, and the physics debug plugin. It demonstrates how to overwrite default debug rendering configuration.

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

fn main() {
    App::new()
        .add_plugins(( 
            DefaultPlugins,
            PhysicsPlugins::default(),
            // Enables debug rendering
            PhysicsDebugPlugin,
        ))
        // Overwrite default debug rendering configuration (optional)
        .insert_gizmo_config(
            PhysicsGizmos {
                aabb_color: Some(Color::WHITE),
                ..default()
            },
            GizmoConfig::default(),
        )
        .run();
}

fn setup(mut commands: Commands) {
    // This rigid body and its collider and AABB will get rendered
    commands.spawn((RigidBody::Dynamic, Collider::circle(0.5)));
}
```

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

### Example Search: std::vec

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/prelude/struct.AngularInertiaTensor.html?search=

Example search query for 'std::vec'.

```text
std::vec
```

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

### MoveHitData Search Examples

Source: https://docs.rs/avian2d/latest/avian2d/character_controller/move_and_slide/struct.MoveHitData.html?search=

Examples of how to search for MoveHitData. These demonstrate different query patterns.

```APIDOC
## Search Examples

### Example 1: Searching for a specific type

```
std::vec
```

### Example 2: Searching for a type conversion

```
u32 -> bool
```

### Example 3: Searching for a generic function with type mapping

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

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

### Character Controller Move and Slide Example

Source: https://docs.rs/avian2d/latest/src/avian2d/character_controller/move_and_slide.rs.html

Demonstrates how to implement character movement using `move_and_slide` within a Bevy system. It includes setting up the character controller, defining movement velocity, filtering collisions, and handling hit responses.

```rust
use bevy::prelude::*
use std::collections::HashSet;
#[cfg_attr(feature = "2d", doc = "use avian2d::{prelude::*, math::{Vector, AdjustPrecision as _, AsF32 as _}}")]
#[cfg_attr(feature = "3d", doc = "use avian3d::{prelude::*, math::{Vector, AdjustPrecision as _, AsF32 as _}}")]

#[derive(Component)]
struct CharacterController {
    velocity: Vector,
}

fn perform_move_and_slide(
    player: Single<(Entity, &Collider, &mut CharacterController, &mut Transform)>,
    move_and_slide: MoveAndSlide,
    time: Res<Time>,
) {
    let (entity, collider, mut controller, mut transform) = player.into_inner();
    let velocity = controller.velocity + Vector::X * 10.0;
    let filter = SpatialQueryFilter::from_excluded_entities([entity]);
    let mut collisions = HashSet::new();
    let out = move_and_slide.move_and_slide(
        collider,
        #[cfg_attr(feature = "2d", doc = "transform.translation.xy().adjust_precision()") ]
        #[cfg_attr(feature = "3d", doc = "transform.translation.adjust_precision()") ]
        #[cfg_attr(feature = "2d", doc = "transform.rotation.to_euler(EulerRot::XYZ).2.adjust_precision()") ]
        #[cfg_attr(feature = "3d", doc = "transform.rotation.adjust_precision()") ]
        velocity,
        time.delta(),
        &MoveAndSlideConfig::default(),
        &filter,
        |hit| {
            collisions.insert(hit.entity);
            MoveAndSlideHitResponse::Accept
        },
    );
    #[cfg_attr(feature = "2d", doc = "transform.translation = out.position.f32().extend(0.0)")]
    #[cfg_attr(feature = "3d", doc = "transform.translation = out.position.f32()") ]
    controller.velocity = out.projected_velocity;
    info!("Colliding with entities: {:?}", collisions);
}

```

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

### Get Bit

Source: https://docs.rs/avian2d/latest/avian2d/data_structures/bit_vec/struct.BitVec.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the bit at the specified index. Returns false if out of bounds or unset.

```rust
pub fn get(&self, index: usize) -> bool
```

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

### Example: Spawn Dynamic Body with MaxLinearSpeed

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/rigid_body/struct.MaxLinearSpeed.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to spawn a dynamic rigid body with its linear velocity clamped to a specific speed using MaxLinearSpeed.

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

// Spawn a dynamic body with linear velocity clamped to `100.0` units per second.
fn setup(mut commands: Commands) {
    commands.spawn((RigidBody::Dynamic, MaxLinearSpeed(100.0)));
}
```

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

### Common Search Examples

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/solver/solver_body/mod.rs.html?search=

Illustrative examples of search queries that can be performed, demonstrating common patterns.

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

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

### Example: Spawning a Dynamic Rigid Body with LinearDamping

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/rigid_body/struct.LinearDamping.html

Demonstrates how to spawn a dynamic rigid body with a LinearDamping component. This is useful for simulating effects like air resistance.

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

fn setup(mut commands: Commands) {
    commands.spawn((RigidBody::Dynamic, LinearDamping(0.8)));
}
```

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

### Example Search: u32 -> bool

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/prelude/struct.AngularInertiaTensor.html?search=

Example search query for a function signature 'u32 -> bool'.

```text
u32 -> bool
```

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

### type_id() - Get TypeId

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/solver/joint_graph/struct.JointComponentId.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the `TypeId` of the JointComponentId instance. This can be used for runtime type identification.

```APIDOC
#### fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Returns
- `TypeId`: The unique identifier for the type of `self`.
```

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

### SubstepCount Resource Example

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/solver/schedule.rs.html?search=std%3A%3Avec

Demonstrates how to insert the `SubstepCount` resource to change the number of substeps used in the simulation. A higher substep count increases accuracy but decreases performance.

```rust
#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*")]
#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*")]
use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
        .insert_resource(SubstepCount(12))
        .run();
}

```

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

### Solver Configuration

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/solver/mod.rs.html?search=

Demonstrates how to configure the solver with specific parameters, such as iteration counts for constraint solving.

```rust
use avian2d::dynamics::solver::{Solver, SolverConfig};
use avian2d::dynamics::World;

let mut world = World::new();
let config = SolverConfig {
    iterations: 10,
    // ... other configuration options
};
let mut solver = Solver::with_config(&world, config);

// The solver will now use the specified configuration.
```

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

### Bundle Get Component IDs

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/rigid_body/struct.Restitution.html?search=u32+-%3E+bool

Get an iterator over optional component IDs for a Bundle from existing components.

```APIDOC
## fn get_component_ids( components: &Components, ) -> impl Iterator<Item = Option<ComponentId>>

### Description
Return a iterator over this `Bundle`’s component ids. This will be `None` if the component has not been registered.

### Parameters
- `components`: A reference to the `Components` struct.

### Returns
- impl Iterator<Item = Option<ComponentId>>: An iterator over optional `ComponentId`s.
```

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

### Test Setup for Semi-Implicit Euler Integration

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/integrator/mod.rs.html?search=

Sets up a Bevy App with necessary plugins for physics testing, including minimal plugins, physics plugins, and transform plugins. Configures the app for a single physics substep.

```rust
fn create_app() -> App {
    let mut app = App::new();
    app.add_plugins(( 
        MinimalPlugins,
        PhysicsPlugins::default(),
        TransformPlugin,
        #[cfg(feature = "bevy_scene")]
        AssetPlugin::default(),
        #[cfg(feature = "bevy_scene")]
        bevy::scene::ScenePlugin,
        MeshPlugin,
    ));
    app
}

#[test]
fn semi_implicit_euler() {
    let mut app = create_app();
    app.insert_resource(SubstepCount(1));
    app.finish();

    let body_entity = app
        .world_mut()
        .spawn(( 
            RigidBody::Dynamic,
            #[cfg(feature = "2d")]
            {
                (
                    MassPropertiesBundle::from_shape(&Rectangle::from_length(1.0), 1.0),
                    AngularVelocity(2.0),
                )
            },
            #[cfg(feature = "3d")]
            {
                (
                    MassPropertiesBundle::from_shape(&Cuboid::from_length(1.0), 1.0),
                    AngularVelocity(Vector::Z * 2.0),
                )
            },
        ))
        .id();

    // Step by 100 steps of 0.1 seconds.

```

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

### Enabling and Configuring Physics Debug Rendering

Source: https://docs.rs/avian2d/latest/src/avian2d/debug_render/configuration.rs.html

This example demonstrates how to add the `PhysicsDebugPlugin` to a Bevy application and optionally overwrite the default debug rendering configuration. It shows how to set the `aabb_color` for physics gizmos.

```rust
use avian2d::prelude::*
use bevy::prelude::*

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, PhysicsPlugins::default(), PhysicsDebugPlugin))
        // Overwrite default debug rendering configuration (optional)
        .insert_gizmo_config(
            PhysicsGizmos {
                aabb_color: Some(Color::WHITE),
                ..default()
            },
            GizmoConfig::default(),
        )
        .run();
}

fn setup(mut commands: Commands) {
    // This rigid body and its collider and AABB will get rendered
    commands.spawn((RigidBody::Dynamic, Collider::circle(0.5)));
}
```

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

### LockedAxes Usage Example

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/rigid_body/struct.LockedAxes.html

This example demonstrates how to spawn a rigid body with locked rotation using the LockedAxes component.

```APIDOC
## LockedAxes Usage Example

This example demonstrates how to spawn a rigid body with locked rotation using the LockedAxes component.

### Code
```rust
use avian2d::prelude::*;
use bevy::prelude::*;

fn spawn(mut commands: Commands) {
    commands.spawn(( 
        RigidBody::Dynamic,
        Collider::capsule(0.5, 1.0),
        LockedAxes::ROTATION_LOCKED,
    ));
}
```
```