Avian

https://docs.rs/avian2d/0.5.0/
Admin
Avian is an ECS-driven 2D and 3D physics engine for the Bevy game engine, featuring rigid body...
Tokens:7,739,442
Snippets:40,773
Trust Score:9.7
Update:8 months ago
Show doc for...
Tokens:
Raw
### Example: Project Point on Closest Collider (Rust)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/spatial_query/system_param.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

An example demonstrating how to use `project_point` to find the projection of a point on the closest collider and print the result. It includes necessary imports and setup for a Bevy environment.

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

```

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

### 3D Character Controller Examples in Avian

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/lib.rs_search=std%3A%3Avec

Demonstrates how to get started with custom character controllers in Avian's 3D physics. It points to example implementations for dynamic and kinematic character controllers.

```rust
#![cfg_attr(feature = "3d", doc = "[`dynamic_character_3d`] and [`kinematic_character_3d`] examples to get started.")]
#![cfg_attr(feature = "3d", doc = "[`dynamic_character_3d`]: https://github.com/avianphysics/avian/tree/main/crates/avian3d/examples/dynamic_character_3d
[`kinematic_character_3d`]: https://github.com/avianphysics/avian/tree/main/crates/avian3d/examples/kinematic_character_3d")
```

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

### 2D Character Controller Examples in Avian

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/lib.rs_search=std%3A%3Avec

Demonstrates how to get started with custom character controllers in Avian's 2D physics. It points to example implementations for dynamic and kinematic character controllers.

```rust
#![cfg_attr(feature = "2d", doc = "[`dynamic_character_2d`] and [`kinematic_character_2d`] examples to get started.")]
#![cfg_attr(feature = "2d", doc = "[`dynamic_character_2d`]: https://github.com/avianphysics/avian/tree/main/crates/avian2d/examples/dynamic_character_2d
[`kinematic_character_2d`]: https://github.com/avianphysics/avian/tree/main/crates/avian2d/examples/kinematic_character_2d")
```

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

### Example: Project Point with Predicate (Rust)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/spatial_query/system_param.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

An example showing how to use `project_point_predicate` to project a point onto the closest collider, excluding entities with the `Invisible` component. It demonstrates filtering based on entity properties.

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

#[derive(Component)]
struct Invisible;

# #[cfg(all(feature = "3d", feature = "f32"))]
fn print_point_projection(spatial_query: SpatialQuery, query: Query<&Invisible>) {
    // Project a point and print the result
    if let Some(projection) = spatial_query.project_point_predicate(
        Vec3::ZERO,                    // Point
        true,                          // Are colliders treated as "solid"
        SpatialQueryFilter::default(), // Query filter
        &|entity| {                    // Predicate
            // Skip entities with the `Invisible` component.
            !query.contains(entity)
        }
    ) {
        println!("Projection: {:?}", projection);
    }
}

```

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

### PhysicsLengthUnit Usage Example (Rust)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/dynamics/solver/plugin.rs_search=u32+-%3E+bool

Demonstrates how to specify the `PhysicsLengthUnit` when initializing the Bevy application with `PhysicsPlugins`. This example shows setting a length unit of 100.0, indicating 100 pixels per meter for a 2D game.

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

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

### Example: Spawning a Rotated Rigid Body (Rust)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/physics_transform/transform.rs

Demonstrates how to spawn a dynamic rigid body with an initial rotation using Bevy and Avian. The example shows creating a rigid body rotated by 1.5 radians around the x-axis.

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

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

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

### Rust Search Examples

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/dynamics/integrator/mod.rs_search=

These are example search queries for Rust, demonstrating how to find specific types, function signatures, and generic type transformations. They are useful for navigating Rust codebases and understanding type relationships.

```rust
std::vec
```

```rust
u32 -> bool
```

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

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

### Point Projection Example - Rust

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/spatial_query/system_param.rs_search=std%3A%3Avec

Example demonstrating how to project a point onto the closest collider using SpatialQuery in Rust. It shows how to handle the Option result and print the projection details.

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

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

### Initialize Solver Resources and Systems in Rust

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/dynamics/solver/plugin.rs_search=std%3A%3Avec

This Rust code snippet demonstrates how to initialize essential resources and add systems to the Bevy App for the SolverPlugin. It sets up resources like SolverConfig, ContactSoftnessCoefficients, ContactConstraints, and ConstraintGraph. It also integrates custom systems into the PhysicsSchedule, ensuring they run in the correct order relative to other physics steps.

```rust
impl Plugin for SolverPlugin {
    fn build(&self, app: &mut App) {
        app.init_resource::<SolverConfig>()
            .init_resource::<ContactSoftnessCoefficients>()
            .init_resource::<ContactConstraints>()
            .init_resource::<ConstraintGraph>();

        if app
            .world()
            .get_resource::<PhysicsLengthUnit>()
            .is_none_or(|unit| unit.0 == 1.0)
        {
            app.insert_resource(PhysicsLengthUnit(self.length_unit));
        }

        let physics = app
            .get_schedule_mut(PhysicsSchedule)
            .expect("add PhysicsSchedule first");

        physics.add_systems(update_contact_softness.before(PhysicsStepSystems::NarrowPhase));

        physics.add_systems(
            prepare_contact_constraints.in_set(SolverSystems::PrepareContactConstraints),
        );
    }
}
```

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

### Example: Setting up Rigid Bodies with Swept CCD in Rust (Bevy)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/dynamics/ccd/mod.rs_search=

Demonstrates how to spawn `RigidBody` entities with `SweptCcd` in a Bevy application. It shows configurations for default CCD, linear-only motion, and contrasts behavior with rotating vs. non-rotating objects.

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

# #[cfg(feature = "f32")]
fn setup(mut commands: Commands) {
    // Spawn a dynamic rigid body with swept CCD, travelling towards the right at a high speed.
    // The default CCD configuration considers both translational and rotational motion.
    commands.spawn(( 
        RigidBody::Dynamic,
        SweptCcd::default(),
#[cfg_attr(feature = "2d", doc = "        LinearVelocity(Vec2::X * 100.0),")]
#[cfg_attr(feature = "3d", doc = "        LinearVelocity(Vec3::X * 100.0),")]
#[cfg_attr(feature = "2d", doc = "        Collider::circle(0.1),")]
#[cfg_attr(feature = "3d", doc = "        Collider::sphere(0.1),")]
        Transform::from_xyz(-10.0, 3.0, 0.0),
    ));

    // Spawn another dynamic rigid body with swept CCD, but this time only considering
    // linear motion and not rotation.
    commands.spawn(( 
        RigidBody::Dynamic,
        SweptCcd::LINEAR, // or `SweptCcd::new_with_mode(SweepMode::Linear)`
#[cfg_attr(feature = "2d", doc = "        LinearVelocity(Vec2::X * 100.0),")]
#[cfg_attr(feature = "3d", doc = "        LinearVelocity(Vec3::X * 100.0),")]
#[cfg_attr(feature = "2d", doc = "        Collider::circle(0.1),")]
#[cfg_attr(feature = "3d", doc = "        Collider::sphere(0.1),")]
        Transform::from_xyz(-10.0, -3.0, 0.0),
    ));

    // Spawn a thin, long object rotating at a high speed.
    // The first ball should hit it, but the second one does not consider
    // rotational motion, and most likely passes through.
    commands.spawn(( 
        RigidBody::Dynamic,
        LockedAxes::TRANSLATION_LOCKED,
#[cfg_attr(feature = "2d", doc = "        AngularVelocity(100.0),")]
#[cfg_attr(feature = "3d", doc = "        AngularVelocity(Vec3::Z * 100.0),")]
#[cfg_attr(feature = "2d", doc = "        Collider::rectangle(0.2, 10.0),")]
#[cfg_attr(feature = "3d", doc = "        Collider::cuboid(0.2, 10.0, 10.0),")]
    ));

    // Spawn another thin, long object, this time not rotating.
    // The second ball should now hit this.
    commands.spawn(( 
        RigidBody::Static,
#[cfg_attr(feature = "2d", doc = "        Collider::rectangle(0.2, 10.0),")]
#[cfg_attr(feature = "3d", doc = "        Collider::cuboid(0.2, 10.0, 10.0),")]
        Transform::from_xyz(15.0, 0.0, 0.0),
    ));
}

```

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

### Rust Vec Len Example

Source: https://docs.rs/avian2d/0.5.0/avian2d/dynamics/solver/struct.ContactConstraints

Provides an example of using the `len` method to get the number of elements currently in a vector.

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

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

### Generic Implementations

Source: https://docs.rs/avian2d/0.5.0/avian2d/dynamics/rigid_body/struct.LockedAxes_search=u32+-%3E+bool

Documentation for generic implementations like Any, Borrow, and CloneToUninit.

```APIDOC
## GET /generic/type_id

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

### Method
GET

### Endpoint
/generic/type_id

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body needed for this operation."
}
```

### Response
#### Success Response (200)
- **TypeId** - The `TypeId` of the instance.

#### Response Example
```json
{
  "example": "<TypeId>"
}
```

## GET /generic/as_bind_group_shader_type

### Description
Return the `T` `ShaderType` for `self`. When used in `AsBindGroup` derives, it is safe to assume that all images in `self` exist.

### Method
GET

### Endpoint
/generic/as_bind_group_shader_type

### Parameters
#### Path Parameters
None

#### Query Parameters
- **_images** (RenderAssets<GpuImage>) - Required - Render assets for images.

#### Request Body
None

### Request Example
```json
{
  "_images": "<RenderAssets<GpuImage>>"
}
```

### Response
#### Success Response (200)
- **U** - The `ShaderType` for the instance.

#### Response Example
```json
{
  "example": "<U>"
}
```

## GET /generic/borrow

### Description
Immutably borrows from an owned value.

### Method
GET

### Endpoint
/generic/borrow

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body needed for this operation."
}
```

### Response
#### Success Response (200)
- **&T** - An immutable reference to the borrowed value.

#### Response Example
```json
{
  "example": "<T>"
}
```

## GET /generic/borrow_mut

### Description
Mutably borrows from an owned value.

### Method
GET

### Endpoint
/generic/borrow_mut

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body needed for this operation."
}
```

### Response
#### Success Response (200)
- **&mut T** - A mutable reference to the borrowed value.

#### Response Example
```json
{
  "example": "<T>"
}
```

## POST /generic/bundle_component_ids

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

### Method
POST

### Endpoint
/generic/bundle_component_ids

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **components** (ComponentsRegistrator<'_>) - Required - A mutable reference to the components registrator.

### Request Example
```json
{
  "components": "<ComponentsRegistrator<'_>>"
}
```

### Response
#### Success Response (200)
- **impl Iterator<Item = ComponentId>** - An iterator over component IDs.

#### Response Example
```json
{
  "example": "<Iterator<Item = ComponentId>>"
}
```

## GET /generic/bundle_get_component_ids

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

### Method
GET

### Endpoint
/generic/bundle_get_component_ids

### Parameters
#### Path Parameters
None

#### Query Parameters
- **components** (Components) - Required - The components to check.

#### Request Body
None

### Request Example
```json
{
  "components": "<Components>"
}
```

### Response
#### Success Response (200)
- **impl Iterator<Item = Option<ComponentId>>** - An iterator over optional component IDs.

#### Response Example
```json
{
  "example": "<Iterator<Item = Option<ComponentId>>>"
}
```

## POST /generic/from_components

### Description
Creates a `Bundle` from components using a context and a function to provide components.

### Method
POST

### Endpoint
/generic/from_components

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **ctx** (T) - Required - The context for component creation.
- **func** (F) - Required - A function that provides components.

### Request Example
```json
{
  "ctx": "<T>",
  "func": "<F>"
}
```

### Response
#### Success Response (200)
- **C** - The created `Bundle`.

#### Response Example
```json
{
  "example": "<C>"
}
```

## unsafe POST /generic/clone_to_uninit

### Description
🔬 This is a nightly-only experimental API. Performs copy-assignment from `self` to `dest`.

### Method
POST

### Endpoint
/generic/clone_to_uninit

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **dest** (*mut u8) - Required - A mutable pointer to the destination memory.

### Request Example
```json
{
  "dest": "<*mut u8>"
}
```

### Response
#### Success Response (200)
- **()** - Operation successful.

#### Response Example
```json
{
  "example": "null"
}
```

## POST /generic/into_any

### Description
Converts `Box<dyn Trait>` to `Box<dyn Any>`.

### Method
POST

### Endpoint
/generic/into_any

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **self** (Box<T>) - Required - The boxed trait object.

### Request Example
```json
{
  "self": "<Box<T>>"
}
```

### Response
#### Success Response (200)
- **Box<dyn Any>** - The converted `Box<dyn Any>`.

#### Response Example
```json
{
  "example": "<Box<dyn Any>>"
}
```

## POST /generic/into_any_rc

### Description
Converts `Rc<Trait>` to `Rc<Any>`.

### Method
POST

### Endpoint
/generic/into_any_rc

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **self** (Rc<T>) - Required - The `Rc<Trait>` object.

### Request Example
```json
{
  "self": "<Rc<T>>"
}
```

### Response
#### Success Response (200)
- **Rc<dyn Any>** - The converted `Rc<dyn Any>`.

#### Response Example
```json
{
  "example": "<Rc<dyn Any>>"
}
```

## GET /generic/as_any

### Description
Converts `&Trait` to `&Any`.

### Method
GET

### Endpoint
/generic/as_any

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body needed for this operation."
}
```

### Response
#### Success Response (200)
- **&(dyn Any + 'static)** - A reference to `Any`.

#### Response Example
```json
{
  "example": "&(dyn Any + 'static)"
}
```

## GET /generic/as_any_mut

### Description
Converts `&mut Trait` to `&mut Any`.

### Method
GET

### Endpoint
/generic/as_any_mut

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body needed for this operation."
}
```

### Response
#### Success Response (200)
- **&mut (dyn Any + 'static)** - A mutable reference to `Any`.

#### Response Example
```json
{
  "example": "&mut (dyn Any + 'static)"
}
```
```

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

### Example: Spawning with CollisionMargin in Rust

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/collision/collider/mod.rs_search=

This example demonstrates how to spawn entities with a CollisionMargin component in Bevy. It shows the setup for both 2D and 3D scenarios, illustrating how to apply a margin to capsules and triangle meshes respectively.

```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) {
#[cfg_attr(
    feature = "2d",
    doc = "    // Spawn a rigid body with a collider.
    // A margin of `0.1` is added around the shape.
    commands.spawn((
        RigidBody::Dynamic,
        Collider::capsule(2.0, 0.5),
        CollisionMargin(0.1),
    ));"
)]
#[cfg_attr(
    feature = "3d",
    doc = "    let mesh = Mesh::from(Torus::default());

    // Spawn a rigid body with a triangle mesh collider.
    // A margin of `0.1` is added around the shape.
    commands.spawn((
        RigidBody::Dynamic,
        Collider::trimesh_from_mesh(&mesh).unwrap(),
        CollisionMargin(0.1),
    ));"
)]
}
```

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

### Gravity Scale Example (Rust)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/dynamics/rigid_body/mod.rs

Shows how to spawn a dynamic rigid body with a custom gravity scale using Bevy commands. This example sets the gravity scale to 1.5, effectively doubling the gravitational pull.

```rust
#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*")]
#[cfg_attr(feature = "3d", doc = "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)));
}

```

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

### Initialize Solver Resources and Systems in Rust

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/dynamics/solver/plugin.rs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This Rust code snippet demonstrates how to initialize essential resources and systems for the Avian2D solver within a Bevy application. It sets up resources like SolverConfig, ContactSoftnessCoefficients, ContactConstraints, and ConstraintGraph. It also adds systems for updating contact softness and preparing contact constraints, ensuring they run at the correct points in the physics schedule.

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

        if app
            .world()
            .get_resource::<PhysicsLengthUnit>()
            .is_none_or(|unit| unit.0 == 1.0)
        {
            app.insert_resource(PhysicsLengthUnit(self.length_unit));
        }

        let physics = app
            .get_schedule_mut(PhysicsSchedule)
            .expect("add PhysicsSchedule first");

        physics.add_systems(update_contact_softness.before(PhysicsStepSystems::NarrowPhase));

        physics.add_systems(
            prepare_contact_constraints.in_set(SolverSystems::PrepareContactConstraints),
        );
```

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

### Creation and Conversion Implementations

Source: https://docs.rs/avian2d/0.5.0/avian2d/picking/struct.PhysicsPickable_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Documentation for From, FromWorld, and BundleFromComponents trait implementations.

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

### Description
Allows a type `T` to be converted from itself, essentially returning the argument unchanged.

#### fn from(t: T) -> T

Returns the argument unchanged.

## impl<C> BundleFromComponents for C

### Description
Enables the creation of a `Bundle` `C` from a set of components provided by a context.

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

where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,
Creates a `Bundle` `C` from components provided by `func` within the context `ctx`.

## impl<T> FromWorld for T

### Description
Allows a type `T` to be created from the `World` context, provided `T` implements `Default`.

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

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

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

### Get Iterator for Slice (Rust)

Source: https://docs.rs/avian2d/0.5.0/avian2d/spatial_query/struct.RayHits_search=u32+-%3E+bool

Returns an iterator that yields all items in the slice from start to end.

```rust
pub fn iter(&self) -> Iter<'_, T>
```

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

### Get RayCaster Global Origin

Source: https://docs.rs/avian2d/0.5.0/avian2d/spatial_query/struct.RayCaster

Retrieves the global origin point of the ray. This is the starting position of the ray in world space.

```rust
pub fn global_origin(&self) -> Vector
```

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

### HashSet Len Method Example in Rust

Source: https://docs.rs/avian2d/0.5.0/avian2d/collision/collider/struct.CollidingEntities_search=

Shows how to get the number of elements in a `HashSet` using the `len` method in Rust. This method returns the current count of elements in the set. The example initializes an empty HashSet, inserts an element, and then asserts the length at each stage.

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

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

map.insert("foo");

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

```

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

### Filter Iterator by Predicate and Get Indices

Source: https://docs.rs/avian2d/0.5.0/avian2d/data_structures/graph/struct.AllEdgeWeights

Returns an iterator adaptor that yields the indices of elements satisfying a given predicate. The indices are counted from the start of the iterator.

```rust
fn positions<P>(self, predicate: P) -> Positions<Self, P>
where
    Self: Sized,
    P: FnMut(Self::Item) -> bool,
```

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

### Spawning a Circle Collider (Rust Example)

Source: https://docs.rs/avian2d/0.5.0/avian2d/collision/collider/enum.ColliderConstructor_search=

This Rust code snippet demonstrates how to spawn an entity with a `ColliderConstructor::Circle`. It utilizes Bevy's ECS (Entity Component System) and the avian2d library. The example assumes the necessary imports and setup for a Bevy application.

```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 },
        Mesh3d(meshes.add(Cuboid::default())),
    ));
}
```

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

### Get Length of ArrayVec in Rust

Source: https://docs.rs/avian2d/0.5.0/avian2d/data_structures/struct.ArrayVec_search=u32+-%3E+bool

Illustrates how to retrieve the current number of elements in an `ArrayVec` using the `len()` method. The example shows removing an element and then checking the new length.

```rust
use arrayvec::ArrayVec;

let mut array = ArrayVec::from([1, 2, 3]);
array.pop();
assert_eq!(array.len(), 2);
```

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

### Conversion Implementations

Source: https://docs.rs/avian2d/0.5.0/avian2d/physics_transform/struct.PhysicsTransformConfig

Covers various conversion traits like `Into`, `TryFrom`, and `TryInto`.

```APIDOC
### impl<T, U> Into<U> for T
where U: From<T>

#### fn into(self) -> U

### Description
Calls `U::from(self)`. That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### impl<T, U> TryFrom<U> for T
where U: Into<T>

#### type Error = Infallible

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>

#### type Error = <U as TryFrom<T>>::Error

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.
```

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

### Get Raw Collider Shape (Rust)

Source: https://docs.rs/avian2d/0.5.0/avian2d/collision/collider/struct.Collider

Provides Rust code examples for accessing the raw, unscaled shape of a collider using `shape()` and `shape_mut()`, and the scaled shape using `shape_scaled()`.

```Rust
let collider: Collider = Collider::circle(1.0);

// Get the raw unscaled shape
let raw_shape = collider.shape();

// Get a mutable reference to the raw shape
// let mut_raw_shape = collider.shape_mut();

// Get the scaled shape (if transform is applied)
// let scaled_shape = collider.shape_scaled();
```

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

### Conversions (Into, TryFrom, TryInto)

Source: https://docs.rs/avian2d/0.5.0/avian2d/dynamics/joints/struct.DistanceLimit

Documentation for various conversion traits, including standard `Into`, `TryFrom`, and `TryInto`.

```APIDOC
## Conversions

### Description
Details various conversion mechanisms between types.

### `impl<T, U> Into<U> for T`

#### `fn into(self) -> U`
Calls `U::from(self)`. This conversion is determined by the `From<T> for U` implementation.

### `impl<T, U> TryFrom<U> for T`

#### Type `Error = Infallible`
The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`
Performs the conversion.

### `impl<T, U> TryInto<U> for T`

#### Type `Error = <U as TryFrom<T>>::Error`
The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`
Performs the conversion.

```

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

### Point Projection Example - Avian Physics (3D)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/spatial_query/system_param.rs_search=

Example demonstrating how to project a point onto the closest collider using SpatialQuery in a 3D Bevy application. It shows how to handle the Option result and print the projection details.

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

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

### Get Element Index from Reference (Rust)

Source: https://docs.rs/avian2d/0.5.0/avian2d/collision/collider/collider_hierarchy/struct.RigidBodyColliders_search=

Returns the byte index of an element reference within a slice. Returns None if the reference does not point to the start of an element. Uses pointer arithmetic, not element comparison.

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

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

### From Implementation

Source: https://docs.rs/avian2d/0.5.0/avian2d/collision/collider/struct.RegularPolygonColliderShape_search=u32+-%3E+bool

Documentation for the blanket `From<T>` implementation for `T`.

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

### Description
Blanket implementation of `From<T>` for `T` itself. Returns the argument unchanged.

### Method
`fn from(t: T) -> T`

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A
```

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

### Rust Vec Peek Mut Example

Source: https://docs.rs/avian2d/0.5.0/avian2d/dynamics/solver/struct.ContactConstraints

Demonstrates the use of `peek_mut` to get a mutable reference to the last element of a vector without removing it. It shows how to check if the vector is empty and how to modify the last element in place.

```Rust
#![feature(vec_peek_mut)]
let mut vec = Vec::new();
assert!(vec.peek_mut().is_none());

vec.push(1);
vec.push(5);
vec.push(2);
assert_eq!(vec.last(), Some(&2));
if let Some(mut val) = vec.peek_mut() {
    *val = 0;
}
assert_eq!(vec.last(), Some(&0));
```

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

### Generic Implementations (Any, Borrow, Bundle, etc.)

Source: https://docs.rs/avian2d/0.5.0/avian2d/spatial_query/struct.ShapeHits_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Documentation for generic implementations that apply to ShapeHits.

```APIDOC
## Generic Implementations Applicable to ShapeHits

### Description
This section details generic trait implementations that are automatically derived or applied to types like ShapeHits.

### Implementations

#### `impl<T> Any for T where T: 'static + ?Sized`
Provides `type_id()` for getting the `TypeId` of a type.

#### `impl<T, U> AsBindGroupShaderType<U> for T where U: ShaderType, &'a T: for<'a> Into<U>`
Allows types to be converted into shader types for bind groups.

#### `impl<T> Borrow<T> for T where T: ?Sized`
Provides immutable borrowing capabilities.

#### `impl<T> BorrowMut<T> for T where T: ?Sized`
Provides mutable borrowing capabilities.

#### `impl<C> Bundle for C where C: Component`
Enables types to be used as Bevy engine `Bundle`s, providing methods for component registration and retrieval.

#### `impl<C> BundleFromComponents for C where C: Component`
Allows creating `Bundle`s from components.

#### `impl<T> CloneToUninit for T where T: Clone`
(Nightly-only experimental) Performs copy-assignment from `self` to an uninitialized memory location.

#### `impl<T> Downcast for T where T: Any`
Provides downcasting capabilities for types that implement `Any`.
```

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

### Linear Damping Example (Rust)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/dynamics/rigid_body/mod.rs

Demonstrates spawning a dynamic rigid body with a specific linear damping value using Bevy commands. This example sets the linear damping to 0.8, causing the body to gradually slow down.

```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, LinearDamping(0.8)));
}

```

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

### clone_to_uninit

Source: https://docs.rs/avian2d/0.5.0/avian2d/schedule/enum.PhysicsSystems

Nightly-only experimental API for copy-assignment.

```APIDOC
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`.

### Method
`unsafe fn`

### Endpoint
N/A (Method within an impl block)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
None (This is an unsafe function that modifies memory directly)

#### Response Example
None
```

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

### Spawn a Rotated Rigid Body in Rust

Source: https://docs.rs/avian2d/0.5.0/avian2d/physics_transform/struct.Rotation_search=

Example demonstrating how to spawn a dynamic rigid body with a specific rotation using the Rotation::degrees constructor. This showcases a practical application of the Rotation component within a Bevy application setup.

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

fn setup(mut commands: Commands) {
    // Spawn a dynamic rigid body rotated by 90 degrees
    commands.spawn((RigidBody::Dynamic, Rotation::degrees(90.0)));
}
```

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

### Warm Start Solver System (Rust)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/dynamics/solver/plugin.rs

The `warm_start` function applies impulses from the previous simulation step to the current one, improving solver stability and performance. It prioritizes warm-starting overflow constraints.

```rust
/// Warm starts the solver by applying the impulses from the previous frame or substep.
///
/// See [`SubstepSolverSystems::WarmStart`] for more information.
fn warm_start(
    bodies: Query<(&mut SolverBody, &SolverBodyInertia)>,
    mut constraint_graph: ResMut<ConstraintGraph>,
    solver_config: Res<SolverConfig>,
    mut diagnostics: ResMut<SolverDiagnostics>,
) {
    let start = crate::utils::Instant::now();

    for constraint in constraint_graph.colors[COLOR_OVERFLOW_INDEX]
        .contact_constraints
        .iter_mut()
    {
        // ... implementation details ...
    }
}
```

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

### Example Usage of Sensor Component in Bevy (Rust)

Source: https://docs.rs/avian2d/0.5.0/avian2d/collision/collider/struct.Sensor

Demonstrates how to spawn a static rigid body with a Sensor collider in a Bevy application using avian2d. This setup allows the spawned entity to detect collisions while remaining non-physical.

```rust
use avian2d::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::circle(0.5), Sensor));
}

```

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

### From Implementation

Source: https://docs.rs/avian2d/0.5.0/avian2d/physics_transform/struct.Position

Provides a simple `from` implementation.

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

#### fn from(t: T) -> T

##### Description
Returns the argument unchanged.

##### Method
`fn`

##### Endpoint
N/A

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

##### Request Example
```rust
// let value = T::from(original_value);
```

##### Response
Returns the input value `t`.
```

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

### Iterate Over Slice in Rust

Source: https://docs.rs/avian2d/0.5.0/avian2d/dynamics/solver/struct.ContactConstraints_search=u32+-%3E+bool

The `iter` method returns an immutable iterator over the slice, yielding each element from start to end. The `iter_mut` method returns a mutable iterator, allowing modification of each element.  Examples demonstrate basic iteration and element modification.

```rust
pub fn iter(&self) -> Iter<'_, T>

// Example
let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);
```

```rust
pub fn iter_mut(&mut self) -> IterMut<'_, T>

// Example
let x = &mut [1, 2, 4];
for elem in x.iter_mut() {
    *elem += 2;
}
assert_eq!(x, &[3, 4, 6]);
```

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

### Integrating Custom Broad Phase Plugin

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/lib.rs_search=u32+-%3E+bool

Shows how to integrate a custom broad phase plugin into a Bevy application. This example demonstrates disabling the default `BroadPhasePlugin` and adding the custom plugin (`CustomBroadPhasePlugin`) when initializing `PhysicsPlugins`. This allows for a customized collision detection pipeline.

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

# struct CustomBroadPhasePlugin;
# impl Plugin for CustomBroadPhasePlugin {
#     fn build(&self, app: &mut App) {}
# }
#
fn main() {
    let mut app = App::new();

    app.add_plugins(DefaultPlugins);

    // Add PhysicsPlugins and replace default broad phase with our custom broad phase
    app.add_plugins(
        PhysicsPlugins::default()
            .build()
            .disable::<BroadPhasePlugin>()
            .add(CustomBroadPhasePlugin),
    );

    app.run();
}
```

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

### SolverSystems Enum - PreSubstep Variant Description

Source: https://docs.rs/avian2d/0.5.0/avian2d/dynamics/solver/schedule/enum.SolverSystems

Describes the 'PreSubstep' system set. This set contains systems that execute immediately before the main substepping loop begins. It can be used for any setup or checks required right before the iterative solving process starts.

```rust
/// A system set for systems running just before the substepping loop.
```

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

### Get Source Node Index from Edge in Rust

Source: https://docs.rs/avian2d/0.5.0/avian2d/data_structures/graph/struct.Edge_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides a method to retrieve the source node index from an `Edge` in Rust. This function is part of the `impl<E> Edge<E>` block and returns a `NodeIndex` representing the starting node of the edge.

```rust
pub fn source(&self) -> NodeIndex
```

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

### IslandPlugin Setup in Bevy

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/dynamics/solver/islands/mod.rs_search=std%3A%3Avec

This Rust code snippet demonstrates how to set up the `IslandPlugin` within a Bevy application. It initializes the `PhysicsIslands` resource and registers `BodyIslandNode` for `SolverBody` components. It also adds observers to manage `BodyIslandNode` based on `RigidBodyDisabled` and `Disabled` component changes, ensuring correct island association for dynamic and kinematic bodies.

```rust
use bevy::prelude::*;
use crate::dynamics::solver::solver_body::SolverBody;
use crate::dynamics::solver::islands::{IslandPlugin, BodyIslandNode};

pub struct ExampleApp;

impl Plugin for ExampleApp {
    fn build(&self, app: &mut App) {
        app.add_plugin(IslandPlugin);

        // 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,
                (
                    With<Disabled>,
                    Without<RigidBodyDisabled>,
                ),
            >,
             mut commands: Commands| {
                let Ok(rb) = rb_query.get(trigger.entity) else {
                    return;
                };
                // Logic to handle disabled bodies
            },
        );
    }
}

fn main() {
    App::new().add_plugin(ExampleApp).run();
}
```

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

### Create Custom Broad Phase Plugin (Rust)

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/lib.rs

Provides an example of creating a custom broad phase plugin for Avian physics. This involves defining a new plugin that adds a custom system to the `PhysicsSchedule`'s broad phase set.

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

pub struct CustomBroadPhasePlugin;

impl Plugin for CustomBroadPhasePlugin {
    fn build(&self, app: &mut App) {
        // Make sure the PhysicsSchedule is available
        let physics_schedule = app
            .get_schedule_mut(PhysicsSchedule)
            .expect("add PhysicsSchedule first");

        // Add the system into the broad phase system set
        physics_schedule.add_systems(collect_collision_pairs.in_set(PhysicsStepSystems::BroadPhase));
    }
}

fn collect_collision_pairs() {
    // Implementation goes here
}
```

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

### Add Physics Diagnostics Plugin to Bevy App

Source: https://docs.rs/avian2d/0.5.0/src/avian2d/diagnostics/mod.rs

Demonstrates how to add the PhysicsDiagnosticsPlugin and optionally the PhysicsDiagnosticsUiPlugin to a Bevy application. This requires enabling the 'bevy_diagnostic' and 'diagnostic_ui' features respectively. The example shows the basic setup for integrating physics diagnostics into a Bevy application.

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

```

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

### Type Conversions (Into, TryFrom, TryInto)

Source: https://docs.rs/avian2d/0.5.0/avian2d/collision/collider/struct.ColliderConstructorHierarchyConfig

Documentation for various type conversion traits, including `Into`, `TryFrom`, and `TryInto`.

```APIDOC
## Type Conversion Traits (`Into`, `TryFrom`, `TryInto`)

### Description
This section details traits related to type conversions. `Into<U> for T` allows conversion from `T` to `U` if `U` implements `From<T>`. `TryFrom<U> for T` and `TryInto<U> for T` provide fallible conversion mechanisms.

### Methods
- `Into<U> for T`:
  - `into(self) -> U`: Calls `U::from(self)`.
- `TryFrom<U> for T`:
  - `type Error = Infallible`: The type returned in the event of a conversion error.
  - `try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`: Performs the conversion.
- `TryInto<U> for T`:
  - `type Error = <U as TryFrom<T>>::Error`: The type returned in the event of a conversion error.
  - `try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`: Performs the conversion.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- `U`: The target type after successful conversion.
- `Result<T, Error>`: The result of a fallible conversion.

#### Response Example
None
```

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

### Observe CollisionStart Events with Bevy in Rust

Source: https://docs.rs/avian2d/0.5.0/avian2d/collision/collision_events/struct.CollisionStart_search=

An example demonstrating how to observe CollisionStart events using Bevy's observer pattern. This setup allows reacting to collisions by defining a system that is triggered when a CollisionStart event occurs for a specific entity.

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

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

### Get Raw Collider Shape (Rust)

Source: https://docs.rs/avian2d/0.5.0/avian2d/collision/collider/struct.Collider_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides Rust code examples for accessing the raw, unscaled shape of a collider using `shape()` and a mutable reference using `shape_mut()`. These methods are useful for advanced manipulation or inspection of the collider's geometry.

```rust
pub fn shape(&self) -> &SharedShape
pub fn shape_mut(&mut self) -> &mut SharedShape
```
Tokens:
Raw