Avian

https://docs.rs/avian3d/latest/
Admin
Avian is an ECS-driven 2D and 3D physics engine for the Bevy game engine, providing rigid body...
Tokens:5,347,943
Snippets:36,693
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Physics Diagnostics Setup Example

Source: https://docs.rs/avian3d/latest/src/avian3d/diagnostics/mod.rs.html?search=

Demonstrates how to add the PhysicsDiagnosticsPlugin and PhysicsDiagnosticsUiPlugin to a Bevy application. This enables writing physics diagnostics to the DiagnosticsStore and displaying them in a debug UI.

```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(),
            // Add the `PhysicsDiagnosticsPlugin` to write physics diagnostics
            // to the `DiagnosticsStore` resource in `bevy_diagnostic`.
            // Requires the `bevy_diagnostic` feature.
            #[cfg(feature = "bevy_diagnostic")]
            PhysicsDiagnosticsPlugin,
            // Add the `PhysicsDiagnosticsUiPlugin` to display physics diagnostics
            // in a debug UI. Requires the `diagnostic_ui` feature.
            #[cfg(feature = "diagnostic_ui")]
            PhysicsDiagnosticsUiPlugin,
        ))
        // ...your other plugins, systems and resources
        .run();
}

```

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

### Example of Collider Hierarchy Setup

Source: https://docs.rs/avian3d/latest/src/avian3d/collision/collider/collider_hierarchy/mod.rs.html?search=

Demonstrates how to spawn entities with RigidBody, Collider, and children entities, illustrating automatic attachment of colliders to the nearest rigid body.

```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))
    ]
));
# }

```

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

### Example Usage

Source: https://docs.rs/avian3d/latest/avian3d/dynamics/rigid_body/forces/struct.ConstantLocalTorque.html

Example of how to spawn a dynamic rigid body with a ConstantLocalTorque component.

```APIDOC
## Example

```rust
commands.spawn(( 
    RigidBody::Dynamic, 
    Collider::capsule(0.5, 1.0), 
    // Apply a constant torque of 5 N⋅m in the positive Z direction in local space.
    ConstantLocalTorque::new(0.0, 0.0, 5.0), 
));
```
```

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

### Example Usage

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

Example demonstrating how to spawn a dynamic rigid body with a `ConstantLocalAngularAcceleration` component.

```APIDOC
## Example
```rust
commands.spawn(( 
    RigidBody::Dynamic,
    Collider::capsule(0.5, 1.0),
    // Apply a constant angular acceleration of 1.0 rad/s² in the positive Z direction in local space.
    ConstantLocalAngularAcceleration::new(0.0, 0.0, 1.0),
));
```
```

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

### Example Usage

Source: https://docs.rs/avian3d/latest/avian3d/dynamics/rigid_body/forces/struct.ConstantLocalLinearAcceleration.html?search=

Example of how to spawn a dynamic rigid body with a ConstantLocalLinearAcceleration component.

```APIDOC
## Example Usage

### Description
This example demonstrates how to spawn a dynamic rigid body and apply a constant linear acceleration in its local space using `ConstantLocalLinearAcceleration`.

### Code
```rust
commands.spawn(( 
    RigidBody::Dynamic, 
    Collider::capsule(0.5, 1.0), 
    // Apply a constant linear acceleration of 10.0 m/s² in the positive Y direction in local space.
    ConstantLocalLinearAcceleration::new(0.0, 10.0, 0.0), 
));
```
```

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

### Example Usage

Source: https://docs.rs/avian3d/latest/avian3d/physics_transform/struct.Rotation.html?search=u32+-%3E+bool

Example of spawning a dynamic rigid body with a specific rotation.

```APIDOC
## Example
```rust
use avian3d::prelude::*;
use bevy::prelude::*;

fn setup(mut commands: Commands) {
    // Spawn a dynamic rigid body rotated by 1.5 radians around the x axis
    commands.spawn((RigidBody::Dynamic, Rotation(Quat::from_rotation_x(1.5))));
}
```
```

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

### Enabling and Configuring Physics Debug Rendering

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

Example of setting up a Bevy application with Avian3D, enabling the PhysicsDebugPlugin, and optionally overwriting the default PhysicsGizmos configuration. This setup ensures physics debug visualizations are active.

```rust
use avian3d::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::sphere(0.5)));
}
```

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

### RigidBodyQueryItem Search Examples

Source: https://docs.rs/avian3d/latest/avian3d/dynamics/rigid_body/struct.RigidBodyQueryItem.html?search=

Examples of how to perform searches on RigidBodyQueryItem.

```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 generic type transformations
```
Option<T>, (T -> U) -> Option<U>
```
```

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

### Sensor Usage Example

Source: https://docs.rs/avian3d/latest/avian3d/collision/collider/struct.Sensor.html

Example demonstrating how to spawn an entity with a static rigid body and a sensor collider.

```APIDOC
## §Example
```rust
use avian3d::prelude::*;
use bevy::prelude::*;

fn setup(mut commands: Commands) {
    // Spawn a static body with a sensor collider.
    // Other bodies will pass through, but it will still send collision events.
    commands.spawn((RigidBody::Static, Collider::sphere(0.5), Sensor));
}
```
```

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

### ActiveCollisionHooks Example Usage

Source: https://docs.rs/avian3d/latest/avian3d/collision/hooks/struct.ActiveCollisionHooks.html?search=

Examples demonstrating how to use ActiveCollisionHooks.

```APIDOC
## Example

```rust
// Spawn a collider with filtering hooks enabled.
commands.spawn((Collider::capsule(0.5, 1.5), ActiveCollisionHooks::FILTER_PAIRS));

// Spawn a collider with both filtering and contact modification hooks enabled.
commands.spawn((
    Collider::capsule(0.5, 1.5),
    ActiveCollisionHooks::FILTER_PAIRS | ActiveCollisionHooks::MODIFY_CONTACTS
));

// Alternatively, all hooks can be enabled with `ActiveCollisionHooks::all()`.
commands.spawn((Collider::capsule(0.5, 1.5), ActiveCollisionHooks::all()));
```
```

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

### Spawn a Rigid Body with Initial Rotation

Source: https://docs.rs/avian3d/latest/src/avian3d/physics_transform/transform.rs.html?search=std%3A%3Avec

Example of spawning a dynamic rigid body with an initial rotation. This demonstrates how to set the starting orientation of a physics object using the Rotation component.

```rust
# #[cfg(feature = "f32")]
fn setup(mut commands: Commands) {
    // Spawn a dynamic rigid body rotated by 1.5 radians around the x axis
    commands.spawn((RigidBody::Dynamic, Rotation(Quat::from_rotation_x(1.5))));
}
```

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

### Default Physics Plugins Setup

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

Configures the default physics simulation pipeline, including broad-phase, narrow-phase, and solver plugins. This setup is used when no custom collision hooks are specified.

```rust
impl PhysicsPlugins {
    pub fn new(schedule: impl ScheduleLabel) -> Self {
        let mut builder = PluginGroupBuilder::default();

        // Add core plugins.
        builder
            .add(ColliderHierarchyPlugin)
            .add(ColliderTransformPlugin::new(schedule));

        #[cfg(all(feature = "collider-from-mesh", feature = "default-collider"))]
        let builder = builder.add(ColliderCachePlugin);

        #[cfg(all(
            feature = "default-collider",
            any(feature = "parry-f32", feature = "parry-f64")
        ))]
        let builder = builder
            .add(ColliderBackendPlugin::<Collider>::new(schedule))
            .add(ColliderTreePlugin::<Collider>::default())
            .add(NarrowPhasePlugin::<Collider>::default());

        // Add solver plugins.
        let builder = builder.add_group(SolverPlugins::new_with_length_unit(self.length_unit));

        builder
            .add(BroadPhaseCorePlugin)
            .add(BvhBroadPhasePlugin::<()>::default())
            .add(JointPlugin)
            .add(SpatialQueryPlugin::new(schedule))
            .add(PhysicsTransformPlugin::new(schedule))
            .add(PhysicsInterpolationPlugin::default());

        Self { builder, length_unit: Scalar::default() }
    }
}
```

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

### Example: Projecting a Point in 3D Space

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

Demonstrates how to project a point onto the closest collider using `SpatialQuery::project_point`. This example shows setting the point, whether colliders are solid, and the query filter.

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

# #[cfg(all(feature = "3d", feature = "f32"))]
fn print_point_projection(spatial_query: SpatialQuery) {
    // Project a point and print the result
    if let Some(projection) = spatial_query.project_point(
        Vec3::ZERO,                    // Point
        true,                          // Are colliders treated as "solid"
        &SpatialQueryFilter::default(),// Query filter
    ) {
        println!("Projection: {:?}", projection);
    }
}
```

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

### GravityScale Example Usage

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

Example demonstrating how to spawn a dynamic rigid body with a custom GravityScale value using Bevy and avian3d.

```APIDOC
## Example

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

// Spawn a dynamic body with `1.5` times the normal gravity.
fn setup(mut commands: Commands) {
    commands.spawn((RigidBody::Dynamic, GravityScale(1.5)));
}
```
```

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

### LinearVelocity Example

Source: https://docs.rs/avian3d/latest/avian3d/dynamics/rigid_body/struct.LinearVelocity.html?search=std%3A%3Avec

An example demonstrating how to use the LinearVelocity struct to accelerate a rigid body's linear motion over time.

```APIDOC
## Example

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

fn accelerate_linear(mut query: Query<&mut LinearVelocity>, time: Res<Time>) {
    let delta_secs = time.delta_secs();
    for mut linear_velocity in &mut query {
        // Accelerate the entity towards +X at `2.0` units per second squared.
        linear_velocity.x += 2.0 * delta_secs;
    }
}
```
```

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

### PhysicsLengthUnit Resource Example

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

Demonstrates how to insert the `PhysicsLengthUnit` resource into an application, optionally specifying a custom length 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
```

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

### Accelerate Angular Velocity (3D Example)

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

Example demonstrating how to modify the angular velocity of a body over time, simulating acceleration. Requires `bevy::prelude::*` and `avian3d::prelude::*`.

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

# #[cfg(feature = "f32")]
fn accelerate_angular(mut query: Query<&mut AngularVelocity>, time: Res<Time>) {
    let delta_secs = time.delta_secs();
    for mut angular_velocity in &mut query {
        // Accelerate rotation about the Z axis at `0.5` radians per second squared.
        angular_velocity.z += 0.5 * delta_secs;
    }
}
# #[cfg(feature = "f64")]
# fn main() {}

```

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

### Ray Casting Example

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

Demonstrates how to iterate through ray cast hits sorted by distance. This example assumes you have a `RayCaster` component on an entity and are querying for `RayHits`.

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

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

```

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

### IslandPlugin Setup

Source: https://docs.rs/avian3d/latest/src/avian3d/dynamics/solver/islands/mod.rs.html

Initializes the PhysicsIslands resource and registers BodyIslandNode for SolverBody. This plugin manages the lifecycle of simulation islands.

```Rust
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<Discard, 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<Discard, 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>,
                ),
            >,

```

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

### 2D/3D Position Component Example

Source: https://docs.rs/avian3d/latest/src/avian3d/physics_transform/transform.rs.html?search=u32+-%3E+bool

Example demonstrating how to spawn an entity with a RigidBody and a Position component. The specific constructor used depends on whether the 2D or 3D feature is enabled.

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

fn setup(mut commands: Commands) {
    commands.spawn(( 
        RigidBody::Dynamic,
#[cfg_attr(feature = "2d", doc = "         Position::from_xy(0.0, 20.0),")]
#[cfg_attr(feature = "3d", doc = "         Position::from_xyz(0.0, 2.0, 0.0),")]
    ));
}
```

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

### Rust Vec split_at_spare_mut Example

Source: https://docs.rs/avian3d/latest/avian3d/dynamics/solver/struct.ContactConstraints.html?search=std%3A%3Avec

Illustrates using the nightly-only `split_at_spare_mut` to get mutable slices of initialized and uninitialized elements for advanced manipulation.

```rust
#![feature(vec_split_at_spare)]
let mut v = vec![1, 1, 2];
v.reserve(10);
let (init, uninit) = v.split_at_spare_mut();
let sum = init.iter().copied().sum::<u32>();
uninit[0].write(sum);
uninit[1].write(sum * 2);
uninit[2].write(sum * 3);
uninit[3].write(sum * 4);
unsafe {
    let len = v.len();
    v.set_len(len + 4);
}
assert_eq!(&v, &[1, 1, 2, 4, 8, 12, 16]);
```

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

### Spawn Dynamic Rigid Body with Collider

Source: https://docs.rs/avian3d/latest/avian3d/dynamics/rigid_body/mass_properties/components/struct.ColliderMassProperties.html?search=

Example of spawning a dynamic rigid body with a sphere collider. This snippet demonstrates the setup for entities that will have physics properties.

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

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

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

### STARTED_GENERATING_CONSTRAINTS Flag

Source: https://docs.rs/avian3d/latest/avian3d/collision/contact_types/struct.ContactPairFlags.html?search=u32+-%3E+bool

Indicates that a contact pair has just started generating contact constraints, for example, due to a sensor becoming a normal collider. This is a constant within ContactPairFlags.

```rust
pub const STARTED_GENERATING_CONSTRAINTS: Self
```

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

### PhysicsSchedulePlugin Setup

Source: https://docs.rs/avian3d/latest/src/avian3d/schedule/mod.rs.html

Initializes the `PhysicsSchedulePlugin` with a custom schedule. The default schedule is `FixedPostUpdate`.

```rust
pub struct PhysicsSchedulePlugin {
    schedule: Interned<dyn ScheduleLabel>,
}

impl PhysicsSchedulePlugin {
    /// Creates a [`PhysicsSchedulePlugin`] using the given schedule for running the [`PhysicsSchedule`].
    ///
    /// The default schedule is `FixedPostUpdate`.
    pub fn new(schedule: impl ScheduleLabel) -> Self {
        Self {
            schedule: schedule.intern(),
        }
    }
}

impl Default for PhysicsSchedulePlugin {
    fn default() -> Self {
        Self::new(FixedPostUpdate)
    }
}
```

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

### Example Usage of contact_manifolds

Source: https://docs.rs/avian3d/latest/avian3d/collision/collider/contact_query/fn.contact_manifolds.html?search=

Demonstrates how to use the `contact_manifolds` function to compute contact manifolds between a sphere and a cuboid collider. It shows the necessary imports and setup for the colliders and their transformations.

```rust
use avian3d::{collision::collider::contact_query::contact_manifolds, prelude::*};
use bevy::prelude::*;

let collider1 = Collider::sphere(0.5);
let collider2 = Collider::cuboid(1.0, 1.0, 1.0);

// Compute contact manifolds a collision that should be penetrating
let mut manifolds = Vec::new();
contact_manifolds(
    // First collider
    &collider1,
    Vec3::default(),
    Quat::default(),
    // Second collider
    &collider2,
    Vec3::X * 0.25,
    Quat::default(),
    // Prediction distance
    0.0,
    // Output manifolds
    &mut manifolds,
);

assert_eq!(manifolds.is_empty(), false);
```

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

### Initialize Bevy App with Physics Plugins

Source: https://docs.rs/avian3d/latest/src/avian3d/collision/collider/constructor.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Sets up a Bevy application with default plugins, disabling Winit and Diagnostics, and enabling PhysicsPlugins. This is a common setup for physics-enabled applications.

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

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

### Setting up XPBD Solver Systems

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

Integrate custom constraint preparation and solving into the physics substepping schedule. This includes preparing joints, solving user constraints, and optionally writing back joint forces.

```rust
// Prepare custom constraint
app.add_systems(
    PhysicsSchedule,
    prepare_xpbd_joint::<CustomConstraint>
        .in_set(SolverSystems::PrepareJoints),
);

// Solve custom constraint
app.add_systems(
    SubstepSchedule,
    solve_xpbd_joint::<CustomConstraint>
        .in_set(XpbdSolverSystems::SolveUserConstraints),
);

// Optional: Write back constraint forces to the `JointForces` component.
app.add_systems(
    PhysicsSchedule,
    write_back_joint_forces::<CustomConstraint>
        .in_set(SolverSystems::Finalize)
        .ambiguous_with(SolverSystems::Finalize),
);

```

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

### Get Element Offset in a Slice

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

Use `element_offset` to find the index of a given element reference within a slice. Returns `None` if the reference is not aligned to an element's start.

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

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

```Rust
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: Printing Raycast Hits

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

Demonstrates how to query for RayHits and iterate through them, printing entity and distance. Uses `iter_sorted` for ordered output.

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

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

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

### Spawning a Dynamic Body with Linear Damping - Avian3D Example

Source: https://docs.rs/avian3d/latest/src/avian3d/dynamics/rigid_body/mod.rs.html?search=u32+-%3E+bool

Example of spawning a dynamic rigid body with a `LinearDamping` of 0.8, simulating significant air resistance. This component is added during entity spawning.

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

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

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

### SubstepCount Resource Example

Source: https://docs.rs/avian3d/latest/src/avian3d/dynamics/solver/schedule.rs.html

Demonstrates how to configure the number of substeps for the physics simulation by inserting the `SubstepCount` resource into the Bevy App. A higher 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();
}

```

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

### Component-Based Shape Casting Example

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

Example of spawning a ShapeCaster component for a sphere. This demonstrates how to set up a shape, its origin, rotation, and direction for casting. Ensure the '3d' and 'f32' features are enabled.

```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 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
}

fn print_hits(query: Query<(&ShapeCaster, &ShapeHits)>) {
    for (shape_caster, hits) in &query {
        for hit in hits.iter() {
            println!("Hit entity {}", hit.entity);
        }
    }
}

```

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

### Setup: Spawning Bodies and Fixed Joint

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

Demonstrates how to spawn two dynamic bodies and connect them with a fixed joint.

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

fn setup(mut commands: Commands) {
    let body1 = commands.spawn(RigidBody::Dynamic).id();
    let body2 = commands.spawn(RigidBody::Dynamic).id();
     
    // Connect the bodies with a fixed joint.
    commands.spawn(FixedJoint::new(body1, body2));
}
```

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

### Apply Warm Starting to Contact Constraint

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

Applies warm starting to a contact constraint by iterating through its points and applying previously calculated impulses. This helps maintain stability and reduce jitter in simulations.

```rust
let inv_mass1 = inertia1.effective_inv_mass();
let inv_mass2 = inertia2.effective_inv_mass();
let inv_angular_inertia1 = inertia1.effective_inv_angular_inertia();
let inv_angular_inertia2 = inertia2.effective_inv_angular_inertia();

let tangent_directions = self.tangent_directions();

for point in self.points.iter() {

```

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

### PhysicsDiagnosticsSystems Search Examples

Source: https://docs.rs/avian3d/latest/avian3d/diagnostics/enum.PhysicsDiagnosticsSystems.html?search=

Provides examples of how to search within PhysicsDiagnosticsSystems. These examples demonstrate different search patterns and types.

```APIDOC
## Example Searches

### Search Pattern 1: Direct Type

```
std::vec
```

### Search Pattern 2: Type Conversion

```
u32 -> bool
```

### Search Pattern 3: Generic Type Transformation

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

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

### Example: Spawn Dynamic Body with Custom Gravity Scale

Source: https://docs.rs/avian3d/latest/avian3d/dynamics/rigid_body/struct.GravityScale.html?search=

Demonstrates how to spawn a dynamic rigid body with a custom gravity scale. This example shows how to apply 1.5 times the normal gravity to a body.

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

// Spawn a dynamic body with `1.5` times the normal gravity.
fn setup(mut commands: Commands) {
    commands.spawn((RigidBody::Dynamic, GravityScale(1.5)));
}
```

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

### Configuring PhysicsLengthUnit with PhysicsPlugins

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

Example of how to set a custom length unit for the physics engine when adding PhysicsPlugins.

```rust
# #[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
```

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

### Friction Combination Example

Source: https://docs.rs/avian3d/latest/src/avian3d/dynamics/rigid_body/physics_material.rs.html?search=u32+-%3E+bool

Demonstrates how friction properties are combined when two bodies collide, based on the `combine_rule`.

```APIDOC
## Friction Combination

Combine the properties of two [`Friction`] components:

```ignore
# use avian3d::prelude::*;
let first = Friction::new(0.8).with_combine_rule(CoefficientCombine::Average);
let second = Friction::new(0.5).with_combine_rule(CoefficientCombine::Multiply);

// `CoefficientCombine::Multiply` has higher priority, so the coefficients are multiplied
assert_eq!(
    first.combine(second),
    Friction::new(0.4).with_combine_rule(CoefficientCombine::Multiply)
);
```
```

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

### Configure Physics Gizmos with Default Settings

Source: https://docs.rs/avian3d/latest/avian3d/debug_render/struct.PhysicsGizmos.html

This example demonstrates how to enable the `PhysicsDebugPlugin` and optionally overwrite the default `PhysicsGizmos` configuration. It shows how to set the `aabb_color` to white while using default values for all other fields.

```rust
use avian3d::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::sphere(0.5)));
}
```

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

### Enable and Configure Physics Debug Rendering

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

This example demonstrates how to enable the `PhysicsDebugPlugin` and customize the default debug rendering configuration by inserting a `PhysicsGizmos` struct with specific settings. It also shows how to spawn a rigid body with a collider that will be debug rendered.

```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)));
}
```

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

### AngularVelocity Search Examples

Source: https://docs.rs/avian3d/latest/avian3d/dynamics/rigid_body/struct.AngularVelocity.html?search=

Examples of how to search for AngularVelocity related items.

```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 constraints
```
Option<T>, (T -> U) -> Option<U>
```
```

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

### PhysicsDebugPlugin Finish Setup

Source: https://docs.rs/avian3d/latest/avian3d/debug_render/struct.PhysicsDebugPlugin.html?search=u32+-%3E+bool

Completes the setup of the PhysicsDebugPlugin after all plugins are ready.

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

### Description
Finishes adding this plugin to the `App` after all registered plugins are ready. This is useful for plugins that depend on the asynchronous setup of other plugins, such as the renderer.

### Parameters
- **_app** (`&mut App`): A mutable reference to the Bevy `App`.
```

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

### PhysicsLengthUnit Resource Example

Source: https://docs.rs/avian3d/latest/src/avian3d/dynamics/solver/plugin.rs.html

Demonstrates how to set a custom `PhysicsLengthUnit` resource when initializing the physics plugins. This scales internal engine properties to match the world's units, improving stability.

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

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

### Collision Started

Source: https://docs.rs/avian3d/latest/src/avian3d/collision/contact_types/mod.rs.html?search=std%3A%3Avec

Returns `true` if a collision started during the current frame.

```APIDOC
## collision_started

### Description
Returns `true` if a collision started during the current frame.

### Method
`collision_started(&self) -> bool`

### Returns
`true` if a collision started, `false` otherwise.
```

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

### GetField

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

Provides methods to get or mutably get fields by name.

```APIDOC
## impl<S> GetField for S

### get_field<T>(&self, name: &str) -> Option<&T>
Gets a reference to the value of the field named `name`, downcast to `T`.

### get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
Gets a mutable reference to the value of the field named `name`, downcast to `T`.
```

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

### Semi-Implicit Euler Test Setup

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

Sets up a Bevy application for testing physics integration. It configures the application with necessary plugins and resources, including physics and time updates, and inserts a specific substep count for the simulation.

```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();

```

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

### Get Path

Source: https://docs.rs/avian3d/latest/avian3d/collision/collider/collider_hierarchy/struct.RigidBodyColliders.html?search=u32+-%3E+bool

Provides methods for getting a reference to a value by path.

```APIDOC
## fn reflect_path<'p>( &self, path: impl ReflectPath<'p>, ) -> Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>

### Description
Returns a reference to the value specified by `path`.

### Parameters
- `path`: impl ReflectPath<'p> - The path to the desired value.

### Returns
- `Result<&(dyn PartialReflect + 'static), ReflectPathError<'p>>` - A result containing a reference to the value or a `ReflectPathError`.
```

```APIDOC
## fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>

### Description
Returns a mutable reference to the value specified by `path`.

### Parameters
- `path`: impl ReflectPath<'p> - The path to the desired value.

### Returns
- `Result<&mut (dyn PartialReflect + 'static), ReflectPathError<'p>>` - A result containing a mutable reference to the value or a `ReflectPathError`.
```

```APIDOC
## fn path<'p, T>( &self, path: impl ReflectPath<'p>, ) -> Result<&T, ReflectPathError<'p>>

### Description
Returns a statically typed reference to the value specified by `path`.

### Parameters
- `path`: impl ReflectPath<'p> - The path to the desired value.

### Returns
- `Result<&T, ReflectPathError<'p>>` - A result containing a statically typed reference to the value or a `ReflectPathError`.
```

```APIDOC
## fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut T, ReflectPathError<'p>>

### Description
Returns a statically typed mutable reference to the value specified by `path`.

### Parameters
- `path`: impl ReflectPath<'p> - The path to the desired value.

### Returns
- `Result<&mut T, ReflectPathError<'p>>` - A result containing a statically typed mutable reference to the value or a `ReflectPathError`.
```

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

### Velocity Integration Query Item Search Examples

Source: https://docs.rs/avian3d/latest/avian3d/dynamics/integrator/struct.VelocityIntegrationQueryItem.html?search=

Provides examples of how to search for velocity integration query items. These examples demonstrate common search patterns and can be adapted for specific needs.

```APIDOC
## Search Examples

### Example Searches

- `std::vec`
- `u32 -> bool`
- `Option<T>, (T -> U) -> Option<U>`
```

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

### Building a Trimesh with Default Settings

Source: https://docs.rs/avian3d/latest/avian3d/collision/collider/trimesh_builder/struct.TrimeshBuilder.html

Demonstrates how to create a TrimeshBuilder from a sphere collider and build a trimesh using default subdivision settings.

```rust
let collider = Collider::sphere(1.0);

// Using default settings
let trimesh = collider.trimesh_builder().build().unwrap();
```

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

### Configure PhysicsGizmos in Bevy App

Source: https://docs.rs/avian3d/latest/avian3d/debug_render/struct.PhysicsGizmos.html?search=std%3A%3Avec

Example showing how to register the PhysicsDebugPlugin and override default gizmo colors.

```rust
use avian3d::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::sphere(0.5)));
}
```

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

### TrimeshBuilder Usage Examples

Source: https://docs.rs/avian3d/latest/avian3d/collision/collider/trimesh_builder/struct.TrimeshBuilder.html

Demonstrates how to use the TrimeshBuilder to create triangle meshes with default settings, custom subdivisions, and transformations.

```APIDOC
## Example Usage

### Basic Trimesh Generation
```rust
let collider = Collider::sphere(1.0);
let trimesh = collider.trimesh_builder().build().unwrap();
```

### Customizing Sphere Subdivisions
```rust
let collider = Collider::sphere(1.0);
let trimesh = collider
    .trimesh_builder()
    .sphere_subdivisions(20, 20)
    .build()
    .unwrap();
```

### Setting Different Subdivisions for Various Shapes
```rust
let collider = Collider::sphere(1.0);
let trimesh = collider
    .trimesh_builder()
    .sphere_subdivisions(20, 20)
    .capsule_subdivisions(10, 5)
    .fallback_subdivisions(15)
    .build()
    .unwrap();
```

### Generating Trimesh with Transformation
```rust
let collider = Collider::sphere(1.0);
let trimesh = collider
    .trimesh_builder()
    .translated(Vector::new(1.0, 0.0, 0.0))
    .build()
    .unwrap();
```
```

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

### Entity Mapping Example

Source: https://docs.rs/avian3d/latest/src/avian3d/spatial_query/ray_caster.rs.html?search=

Illustrates how an entity is retrieved and mapped within the Avian3D system. This is part of the internal logic for spatial queries.

```rust
self.entity = entity_mapper.get_mapped(self.entity);
```

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

### Setup Physics Diagnostics UI

Source: https://docs.rs/avian3d/latest/src/avian3d/diagnostics/ui.rs.html?search=

Initializes the main physics diagnostics UI node. It spawns a root node with specific layout properties and children built by `build_diagnostic_texts`.

```rust
fn setup_diagnostics_ui(mut commands: Commands, settings: Res<PhysicsDiagnosticsUiSettings>) {
    commands
        .spawn(( 
            Name::new("Physics Diagnostics"),
            PhysicsDiagnosticsUiNode,
            Node {
                position_type: PositionType::Absolute,
                top: Val::Px(5.0),
                left: Val::Px(5.0),
                width: Val::Px(270.0),
                padding: UiRect::all(Val::Px(10.0)),
                border_radius: BorderRadius::all(Val::Px(5.0)),
                display: if settings.enabled {
                    Display::Flex
                } else {
                    Display::None
                },
                flex_direction: FlexDirection::Column,
                row_gap: Val::Px(10.0),
                ..default()
            },
            BackgroundColor(Color::srgba(0.0, 0.0, 0.0, 0.8)),
        ))
        .with_children(build_diagnostic_texts);
}
```
Tokens:
Raw