Avian 2D

https://docs.rs/avian2d/latest
Admin
Avian 2D is an ECS-driven 2D physics engine for the Bevy game engine, providing rigid body dynamics,...
Tokens:518,294
Snippets:4,154
Trust Score:9.1
Update:2 months ago
Show doc for...
Tokens:
Raw
### RayCaster Usage Example

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

Demonstrates how to spawn a RayCaster and iterate through its hits.

```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.get_global_point(hit.distance),
                hit.normal,
            );
        }
    }
}
```

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

### Warm Start Solver System

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

System that applies impulses from the previous frame to warm start the solver.

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

    // Warm start overflow constraints serially. They have lower priority, so they are solved first.
    for constraint in constraint_graph.colors[COLOR_OVERFLOW_INDEX]
```

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

### Partitioning a slice

Source: https://docs.rs/avian2d/latest/avian2d/data_structures/struct.ArrayVec.html

Examples demonstrating how to find the partition point of a slice based on a predicate.

```rust
assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));
```

```rust
let a = [2, 4, 8];
assert_eq!(a.partition_point(|x| x < &100), a.len());
let a: [i32; 0] = [];
assert_eq!(a.partition_point(|x| x < &100), 0);
```

```rust
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);
```

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

### Project Point Example

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

Demonstrates how to use the project_point method to find the closest point on a collider.

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

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

### Component-based Raycasting Example

Source: https://docs.rs/avian2d/latest/avian2d/spatial_query/index.html

Demonstrates spawning a RayCaster component and iterating over RayHits results in a Bevy system.

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

fn setup(mut commands: Commands) {
    // Spawn a ray caster at the center with the rays travelling 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.get_global_point(hit.distance),
                hit.normal,
            );
        }
    }
}
```

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

### Configure a SpatialQueryFilter

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

Example demonstrating how to create a filter with a specific mask and excluded entities, then applying it to a RayCaster.

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

fn setup(mut commands: Commands) {
    let object = commands.spawn(Collider::circle(0.5)).id();

    // A query filter that has three collision layers and excludes the `object` entity
    let query_filter = SpatialQueryFilter::from_mask(0b1011).with_excluded_entities([object]);

    // Spawn a ray caster with the query filter
    commands.spawn(RayCaster::default().with_query_filter(query_filter));
}
```

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

### Configure Gravity Resource

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/integrator/struct.Gravity.html

Example of inserting the Gravity resource into a Bevy App during initialization.

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

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
         .insert_resource(Gravity(Vec2::NEG_Y * 100.0))
        .run();
}
```

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

### Depenetrate Player Example

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

Demonstrates how to use the depenetrate method to resolve overlaps for a player entity.

```rust
fn depenetrate_player(
    player: Single<(Entity, &Collider, &mut Transform)>,
    move_and_slide: MoveAndSlide,
    time: Res<Time>
) {
    let (entity, collider, mut transform) = player.into_inner();
    let filter = SpatialQueryFilter::from_excluded_entities([entity]);

    let offset = move_and_slide.depenetrate(
        collider,
        transform.translation.xy().adjust_precision(),
        transform.rotation.to_euler(EulerRot::XYZ).2.adjust_precision(),
        &DepenetrationConfig::default(),
        &filter,
    );
    transform.translation += offset.f32().extend(0.0);
}
```

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

### Compute Contact Manifolds Example

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

Demonstrates how to compute contact manifolds between a sphere and a cuboid collider.

```rust
# #[cfg(feature = "2d")]
# use avian2d::{collision::collider::contact_query::contact_manifolds, prelude::*};
# #[cfg(feature = "3d")]
use avian3d::{collision::collider::contact_query::contact_manifolds, prelude::*};
use bevy::prelude::*;

# #[cfg(all(feature = "3d", feature = "f32"))]
# {
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);
# }
```

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

### Spawn Entity with Rotation

Source: https://docs.rs/avian2d/latest/src/avian2d/physics_transform/transform.rs.html

Example of spawning a rigid body with an initial rotation.

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

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

### Configure SubstepCount resource

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/solver/schedule/struct.SubstepCount.html

Example of inserting the SubstepCount resource into a Bevy App to override the default value.

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

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

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

### Spawn RigidBody with Rotation

Source: https://docs.rs/avian2d/latest/avian2d/physics_transform/struct.Rotation.html

Example of spawning a dynamic rigid body with an initial 90-degree rotation.

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

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

### XpbdConstraint Implementation for PrismaticJoint

Source: https://docs.rs/avian2d/latest/src/avian2d/dynamics/solver/xpbd/joints/prismatic.rs.html

Handles the preparation, solving, and warm starting logic for prismatic joint constraints.

```rust
impl XpbdConstraint<2> for PrismaticJoint {
    type SolverData = PrismaticJointSolverData;

    fn prepare(
        &mut self,
        bodies: [&RigidBodyQueryReadOnlyItem; 2],
        solver_data: &mut PrismaticJointSolverData,
    ) {
        let [body1, body2] = bodies;

        let Some(local_anchor1) = self.local_anchor1() else {
            return;
        };
        let Some(local_anchor2) = self.local_anchor2() else {
            return;
        };
        let Some(local_basis1) = self.local_basis1() else {
            return;
        };
        let Some(local_basis2) = self.local_basis2() else {
            return;
        };

        // Prepare the point-to-point constraint.
        solver_data.angle_constraint.prepare(
            body1.rotation,
            body2.rotation,
            local_basis1,
            local_basis2,
        );

        // Prepare the prismatic joint.
        solver_data.world_r1 = body1.rotation * (local_anchor1 - body1.center_of_mass.0);
        solver_data.world_r2 = body2.rotation * (local_anchor2 - body2.center_of_mass.0);
        solver_data.center_difference = (body2.position.0 - body1.position.0)
            + (body2.rotation * body2.center_of_mass.0 - body1.rotation * body1.center_of_mass.0);
        solver_data.free_axis1 = *body1.rotation * local_basis1 * self.slider_axis;
    }

    fn solve(
        &mut self,
        bodies: [&mut SolverBody; 2],
        inertias: [&SolverBodyInertia; 2],
        solver_data: &mut PrismaticJointSolverData,
        dt: Scalar,
    ) {
        let [body1, body2] = bodies;

        // Solve the angular constraint.
        solver_data
            .angle_constraint
            .solve([body1, body2], inertias, self.angle_compliance, dt);

        // Solve motors before limits to give limits higher priority.
        self.apply_motor(body1, body2, inertias[0], inertias[1], solver_data, dt);

        // Constrain the relative positions of the bodies, only allowing translation along one free axis.
        self.constrain_positions(body1, body2, inertias[0], inertias[1], solver_data, dt);
    }

    fn warm_start_motors(
        &self,
        bodies: [&mut SolverBody; 2],
        inertias: [&SolverBodyInertia; 2],
        solver_data: &mut PrismaticJointSolverData,
        _dt: Scalar,
        warm_start_coefficient: Scalar,
    ) {
        if !self.motor.enabled {
            return;
        }

        let [body1, body2] = bodies;
        let [inertia1, inertia2] = inertias;

        let inv_mass1 = inertia1.effective_inv_mass();
        let inv_mass2 = inertia2.effective_inv_mass();
```

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

### Configure Spring-Damper Motor

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/joints/struct.LinearMotor.html

Example of initializing a PrismaticJoint with a Spring-Damper motor model for stable position control.

```rust
PrismaticJoint::new(entity1, entity2)
    .with_motor(
        LinearMotor::new(MotorModel::SpringDamper {
            frequency: 2.0,
            damping_ratio: 1.0,
        })
        .with_target_position(target_position)
    )
```

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

### ColliderConstructor Usage Example

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

Example of spawning an entity with a ColliderConstructor component.

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

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

### Initialize Test App

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

Sets up a minimal Bevy App instance with physics plugins for testing purposes.

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

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

### Break Joint System Example

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

Example system for breaking a joint when forces exceed a threshold.

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

# #[cfg(feature = "f32")]
fn break_joints(
    mut commands: Commands,
```

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

### Warm Start Internal Logic

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

Internal function to apply warm starting to contact constraints, handling body dominance and retrieving solver bodies.

```rust
fn warm_start_internal(
    bodies: &Query<(&mut SolverBody, &SolverBodyInertia)>,
    constraint: &mut ContactConstraint,
    warm_start_coefficient: Scalar,
) {
    debug_assert!(!constraint.points.is_empty());

    let mut dummy_body1 = SolverBody::DUMMY;
    let mut dummy_body2 = SolverBody::DUMMY;

    let (mut body1, mut inertia1) = (&mut dummy_body1, &SolverBodyInertia::DUMMY);
    let (mut body2, mut inertia2) = (&mut dummy_body2, &SolverBodyInertia::DUMMY);

    // Get the solver bodies for the two colliding entities.
    if let Ok((body, inertia)) = unsafe { bodies.get_unchecked(constraint.body1) } {
        body1 = body.into_inner();
        inertia1 = inertia;
    }
    if let Ok((body, inertia)) = unsafe { bodies.get_unchecked(constraint.body2) } {
        body2 = body.into_inner();
        inertia2 = inertia;
    }

    // If a body has a higher dominance, it is treated as a static or kinematic body.
    match constraint.relative_dominance.cmp(&0) {
        Ordering::Greater => inertia1 = &SolverBodyInertia::DUMMY,
        Ordering::Less => inertia2 = &SolverBodyInertia::DUMMY,
        _ => {}
    }

    constraint.warm_start(body1, body2, inertia1, inertia2, warm_start_coefficient);
}
```

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

### Character Controller Movement Logic

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

Example of how to handle movement and collision response using the character controller.

```rust
    ///         velocity * time.delta_secs().adjust_precision(),
    ///         config.skin_width,
    ///         &filter,
    ///     );
    ///     if let Some(hit) = hit {
    ///         // We collided with something on the way. Advance as much as possible.
    ///     #[cfg_attr(
    ///         feature = "2d",
    ///         doc = "         transform.translation += (velocity.normalize_or_zero() * hit.distance).extend(0.0).f32();"
    ///     )]
    ///     #[cfg_attr(
    ///         feature = "3d",
    ///         doc = "         transform.translation += (velocity.normalize_or_zero() * hit.distance).f32();"
    ///     )]
    ///         // Then project the velocity to make sure it no longer points towards the contact plane.
    ///         controller.velocity =
    ///             MoveAndSlide::project_velocity(velocity, &[Dir::new_unchecked(hit.normal1.f32())])
    ///     } else {
    ///         // We traveled the full distance without colliding.
    ///     #[cfg_attr(
    ///         feature = "2d",
    ///         doc = "         transform.translation += velocity.extend(0.0).f32();"
    ///     )]
    ///     #[cfg_attr(
    ///         feature = "3d",
    ///         doc = "         transform.translation += velocity.f32();"
    ///     )]
    ///     }
    /// }
```

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

### Warm Start Impulse Application

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

Applies warm start impulses to bodies based on the contact points and normal/tangent directions, with conditional logic for 2D and 3D features.

```rust
for point in self.points.iter() {
            // Fixed anchors
            let r1 = point.anchor1;
            let r2 = point.anchor2;

            let tangent_impulse = point
                .tangent_part
                .as_ref()
                .map_or(default(), |part| part.impulse);

            #[cfg(feature = "2d")]
            let p = warm_start_coefficient
                * (point.normal_part.impulse * self.normal
                    + tangent_impulse * tangent_directions[0]);
            #[cfg(feature = "3d")]
            let p = warm_start_coefficient
                * (point.normal_part.impulse * self.normal
                    + tangent_impulse.x * tangent_directions[0]
                    + tangent_impulse.y * tangent_directions[1]);

            body1.linear_velocity -= p * inv_mass1;
            body1.angular_velocity -= inv_angular_inertia1 * cross(r1, p);

            body2.linear_velocity += p * inv_mass2;
            body2.angular_velocity += inv_angular_inertia2 * cross(r2, p);
        }
    }
```

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

### edges_capacity

Source: https://docs.rs/avian2d/latest/avian2d/collision/contact_types/type.ContactGraphInternal.html

Get edge capacity.

```APIDOC
## pub fn edges_capacity(&self) -> usize

### Description
Returns the current edge capacity of the graph.
```

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

### Create Test Application

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

Helper functions to initialize Bevy applications with physics and serialization plugins for testing.

```rust
fn create_test_app() -> App {
        let mut app = App::new();
        app.add_plugins((
            MinimalPlugins,
            AssetPlugin::default(),
            #[cfg(feature = "bevy_scene")]
            WorldSerializationPlugin,
            MeshPlugin,
            PhysicsPlugins::default(),
        ));

        app
    }

    #[cfg(all(feature = "collider-from-mesh", feature = "bevy_scene"))]
    fn create_gltf_test_app() -> App {
        use bevy::{diagnostic::DiagnosticsPlugin, winit::WinitPlugin};

        // Todo: it would be best to disable all rendering-related plugins,
```

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

### nodes_capacity

Source: https://docs.rs/avian2d/latest/avian2d/collision/contact_types/type.ContactGraphInternal.html

Get node capacity.

```APIDOC
## pub fn nodes_capacity(&self) -> usize

### Description
Returns the current node capacity of the graph.
```

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

### Configure PhysicsGizmos in Bevy App

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

Example showing how to enable the PhysicsDebugPlugin and override default gizmo colors using insert_gizmo_config.

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

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

### get

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/solver/islands/struct.PhysicsIslands.html

Retrieves a reference to a PhysicsIsland by its ID.

```APIDOC
## pub fn get(&self, island_id: IslandId) -> Option<&PhysicsIsland>

### Description
Returns a reference to the `PhysicsIsland` with the given ID.
```

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

### Create test application

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

Helper function to initialize a Bevy App with necessary physics plugins for testing.

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

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

### starts_with

Source: https://docs.rs/avian2d/latest/avian2d/data_structures/struct.ArrayVec.html

Checks if the slice starts with the given prefix.

```APIDOC
## pub fn starts_with(&self, needle: &[T]) -> bool

### Description
Returns `true` if `needle` is a prefix of the slice or equal to the slice.
```

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

### get

Source: https://docs.rs/avian2d/latest/src/avian2d/collision/contact_types/contact_graph.rs.html

Retrieves both the ContactEdge and ContactPair between two entities.

```APIDOC
## fn get(&self, entity1: Entity, entity2: Entity) -> Option<(&ContactEdge, &ContactPair)>

### Description
Returns the ContactEdge and ContactPair between two entities if they exist.

### Parameters
- **entity1** (Entity) - The first entity.
- **entity2** (Entity) - The second entity.
```

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

### Create PhysicsGizmos configurations

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

Static methods to initialize a PhysicsGizmos configuration with specific features enabled.

```rust
pub fn contact_points(color: Color) -> Self {
    Self {
        contact_point_color: Some(color),
        ..Self::none()
    }
}
```

```rust
pub fn contact_normals(color: Color) -> Self {
    Self {
        contact_normal_color: Some(color),
        ..Self::none()
    }
}
```

```rust
pub fn joints(anchor_color: Option<Color>, separation_color: Option<Color>) -> Self {
    Self {
        joint_anchor_color: anchor_color,
        joint_separation_color: separation_color,
        ..Self::none()
    }
}
```

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

### get()

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

Retrieves the Entity ID of the related entity.

```APIDOC
### fn get(&self) -> Entity

#### Description
Gets the `Entity` ID of the related entity.
```

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

### Prepare and solve point constraints

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/solver/xpbd/joints/struct.PointConstraintShared.html

Methods for initializing the constraint with body data and performing the solver step.

```rust
pub fn prepare( &mut self, bodies: [&RigidBodyQueryReadOnlyItem<'_, '_>; 2], local_anchor1: Vector, local_anchor2: Vector, )
```

```rust
pub fn solve( &mut self, bodies: [&mut SolverBody; 2], inertias: [&SolverBodyInertia; 2], compliance: Scalar, dt: Scalar, )
```

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

### collision_started

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

Returns true if a collision started during the current frame.

```APIDOC
## pub fn collision_started(&self) -> bool

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

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

### Setup physics diagnostics UI node

Source: https://docs.rs/avian2d/latest/src/avian2d/diagnostics/ui.rs.html

Initializes the main UI node for physics diagnostics, setting its position, layout, and visibility based on settings.

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

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

### Slice iteration

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

Iterate over all items in a slice from start to end.

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

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

### Configure Physics Plugin Systems

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

The build method registers resources and configures the system sets for the physics engine.

```rust
impl Plugin for PhysicsSchedulePlugin {
    fn build(&self, app: &mut App) {
        // Register types with generics.
        app.register_type::<Time<Physics>>();

        app.init_resource::<Time<Physics>>()
            .insert_resource(Time::new_with(Substeps))
            .init_resource::<SubstepCount>()
            .init_resource::<LastPhysicsTick>();

        // TODO: Where should this be initialized?
        app.init_resource::<PhysicsLengthUnit>();

        // Configure higher level system sets for the given schedule
        let schedule = self.schedule;

        app.configure_sets(
            schedule,
            (
                PhysicsSystems::First,
                PhysicsSystems::Prepare,
                PhysicsSystems::StepSimulation,
                PhysicsSystems::Writeback,
                PhysicsSystems::Last,
            )
                .chain()
                .before(TransformSystems::Propagate),
        );

        // Set up the physics schedule, the schedule that advances the physics simulation
        app.edit_schedule(PhysicsSchedule, |schedule| {
            schedule
                .set_executor(SingleThreadedExecutor::new())
                .set_build_settings(ScheduleBuildSettings {
                    ambiguity_detection: LogLevel::Error,
                    ..default()
                });

            schedule.configure_sets(
                (
                    PhysicsStepSystems::First,
                    PhysicsStepSystems::BroadPhase,
                    PhysicsStepSystems::NarrowPhase,
                    PhysicsStepSystems::Solver,
                    PhysicsStepSystems::Sleeping,
                    PhysicsStepSystems::Finalize,
                    PhysicsStepSystems::Last,
                )
                    .chain(),
            );
        });

        app.add_systems(
            schedule,
            run_physics_schedule.in_set(PhysicsSystems::StepSimulation),
        );

        app.add_systems(
            PhysicsSchedule,
            update_last_physics_tick.after(PhysicsStepSystems::Last),
        );

        #[cfg(debug_assertions)]
        app.add_systems(
            schedule,
            assert_components_finite.in_set(PhysicsSystems::First),
        );
    }
}
```

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

### Get HashSet hasher

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

Access the BuildHasher used by the set.

```rust
use hashbrown::HashSet;
use hashbrown::DefaultHashBuilder;

let hasher = DefaultHashBuilder::default();
let set: HashSet<i32> = HashSet::with_hasher(hasher);
let hasher: &DefaultHashBuilder = set.hasher();
```

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

### PhysicsGizmos::all

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

Creates a PhysicsGizmos configuration with all rendering options enabled.

```APIDOC
## PhysicsGizmos::all()

### Description
Creates a new PhysicsGizmos configuration instance where all available debug rendering options are enabled.

### Signature
`pub fn all() -> Self`
```

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

### get

Source: https://docs.rs/avian2d/latest/avian2d/collision/contact_types/struct.ContactGraph.html

Retrieves the contact edge and pair between two entities.

```APIDOC
### pub fn get(&self, entity1: Entity, entity2: Entity) -> Option<(&ContactEdge, &ContactPair)>

Returns the `ContactEdge` and `ContactPair` between two entities. If the pair does not exist, `None` is returned.
```

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

### Initialize and Compute Softness Coefficients

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

Use SoftnessParameters::new to create a configuration and compute_coefficients to derive the coefficients required for the solver.

```rust
impl SoftnessParameters {
    /// Creates a new [`SoftnessParameters`] configuration based on
    /// a given damping ratio and a frequency in Hertz.
    ///
    /// The damping ratio (zeta ζ) controls the amount of oscillation,
    /// and the frequency controls the constraint's cycles per second.
    #[inline]
    pub fn new(damping_ratio: Scalar, frequency_hz: Scalar) -> Self {
        Self {
            double_damping_ratio: 2.0 * damping_ratio,
            angular_frequency: TAU * frequency_hz,
        }
    }

    /// Returns the damping ratio that controls the amount of oscillation.
    #[inline]
    pub fn damping_ratio(self) -> Scalar {
        self.double_damping_ratio * 0.5
    }

    /// Returns the frequency that controls the rate of oscillation.
    #[inline]
    pub fn frequency(self) -> Scalar {
        self.angular_frequency / TAU
    }

    /// Returns the angular frequency that controls the rate of oscillation.
    /// This is the [`frequency`](Self::frequency) multiplied by `2.0 * PI`.
    #[inline]
    pub const fn angular_frequency(self) -> Scalar {
        self.angular_frequency
    }

    /// Computes [`SoftnessCoefficients`] based on the parameters in `self` and the time step.
    #[inline]
    pub fn compute_coefficients(self, delta_secs: Scalar) -> SoftnessCoefficients {
        // Largely based on Erin Catto's Solver2D and Box2D: https://box2d.org/posts/2024/02/solver2d#soft-constraints
        // See /docs/soft_constraint.md for in-depth explanation and derivation.

        // Expressions shared by computations.
        let a1 = self.double_damping_ratio + self.angular_frequency * delta_secs;
        let a2 = self.angular_frequency * delta_secs * a1;
        let a3 = 1.0 / (1.0 + a2);

        // The coefficients used for soft constraints.
        SoftnessCoefficients {
            bias: self.angular_frequency / a1,
            impulse_scale: a3,
            mass_scale: a2 * a3,
        }
    }
}
```

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

### Register and Configure XPBD Solver Plugin

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

The plugin implementation registers required components for joints and schedules systems for preparation, warm starting, solving, and velocity projection.

```rust
use core::cmp::Ordering;

use super::joints::*;
use crate::{
    dynamics::{
        joints::EntityConstraint,
        solver::{
            SolverConfig,
            schedule::SubstepSolverSystems,
            solver_body::{SolverBody, SolverBodyInertia},
            xpbd::{XpbdConstraint, XpbdConstraintSolverData},
        },
    },
    prelude::*,
};
use bevy::{ecs::component::Mutable, prelude::*};

/// A plugin for a joint solver using Extended Position-Based Dynamics (XPBD).
pub struct XpbdSolverPlugin;

impl Plugin for XpbdSolverPlugin {
    fn build(&self, app: &mut App) {
        app.register_required_components::<FixedJoint, FixedJointSolverData>();
        app.register_required_components::<RevoluteJoint, RevoluteJointSolverData>();
        #[cfg(feature = "3d")]
        app.register_required_components::<SphericalJoint, SphericalJointSolverData>();
        app.register_required_components::<PrismaticJoint, PrismaticJointSolverData>();
        app.register_required_components::<DistanceJoint, DistanceJointSolverData>();

        // Configure scheduling.
        app.configure_sets(
            SubstepSchedule,
            (
                XpbdSolverSystems::SolveConstraints,
                XpbdSolverSystems::SolveUserConstraints,
                XpbdSolverSystems::VelocityProjection,
            )
                .chain()
                .after(SubstepSolverSystems::Relax)
                .before(SubstepSolverSystems::Damping),
        );

        // Prepare joints before the substepping loop.
        app.add_systems(
            PhysicsSchedule,
            (
                prepare_xpbd_joint::<FixedJoint>,
                prepare_xpbd_joint::<RevoluteJoint>,
                #[cfg(feature = "3d")]
                prepare_xpbd_joint::<SphericalJoint>,
                prepare_xpbd_joint::<PrismaticJoint>,
                prepare_xpbd_joint::<DistanceJoint>,
            )
                .chain()
                .in_set(SolverSystems::PrepareJoints),
        );

        // Warm start motor constraints.
        // These are chained to avoid ambiguity, and marked ambiguous_with the contact
        // warm start since motor and contact warm starting are independent operations
        // that both add to body velocities.
        app.add_systems(
            SubstepSchedule,
            (
                warm_start_xpbd_motors::<RevoluteJoint>,
                warm_start_xpbd_motors::<PrismaticJoint>,
            )
                .chain()
                .ambiguous_with_all()
                .in_set(SubstepSolverSystems::WarmStart),
        );

        // Solve joints with XPBD.
        app.add_systems(
            SubstepSchedule,
            (
                |mut query: Query<
                    (
                        &SolverBody,
                        &mut PreSolveDeltaPosition,
                        &mut PreSolveDeltaRotation,
                    ),
                    Without<RigidBodyDisabled>,
                >| {
                    for (body, mut pre_solve_delta_position, mut pre_solve_delta_rotation) in
                        &mut query
                    {
                        // Store the previous delta translation and rotation for XPBD velocity updates.
                        pre_solve_delta_position.0 = body.delta_position;
                        pre_solve_delta_rotation.0 = body.delta_rotation;
                    }
                },
                solve_xpbd_joint::<FixedJoint>,
                solve_xpbd_joint::<RevoluteJoint>,
                #[cfg(feature = "3d")]
                solve_xpbd_joint::<SphericalJoint>,
                solve_xpbd_joint::<PrismaticJoint>,
                solve_xpbd_joint::<DistanceJoint>,
            )
                .chain()
                .in_set(XpbdSolverSystems::SolveConstraints),
        );

        // Perform XPBD velocity updates after constraint solving.
        app.add_systems(
            SubstepSchedule,
            (project_linear_velocity, project_angular_velocity)
                .chain()
                .in_set(XpbdSolverSystems::VelocityProjection),
        );

        // Write back the forces applied by the XPBD joints.
        app.add_systems(
            PhysicsSchedule,
            (
                writeback_joint_forces::<FixedJoint>,
                writeback_joint_forces::<RevoluteJoint>,
                #[cfg(feature = "3d")]
                writeback_joint_forces::<SphericalJoint>,
                writeback_joint_forces::<PrismaticJoint>,
```

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

### from_rotation_arc_2d

Source: https://docs.rs/avian2d/latest/avian2d/math/type.Quaternion.html

Gets the minimal rotation for transforming a 2D vector to another.

```APIDOC
## pub fn from_rotation_arc_2d(from: Vec2, to: Vec2) -> Quat

### Description
Gets the minimal rotation for transforming `from` to `to` in 2D space. The resulting rotation is around the z axis and will rotate at most 180 degrees.
```

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

### Configuring Rigid Body Mass Properties

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

Examples of how to spawn dynamic rigid bodies with automatic mass calculation, manual overrides, and child entity exclusion.

```APIDOC
## Configuring Mass Properties

### Automatic Calculation
By default, mass properties are computed from attached colliders based on shape and density.

```rust
commands.spawn((
    RigidBody::Dynamic,
    Collider::capsule(0.5, 1.5),
    ColliderDensity(2.0),
));
```

### Manual Overrides
Use `Mass`, `AngularInertia`, and `CenterOfMass` components to override values computed from colliders.

```rust
commands.spawn((
    RigidBody::Dynamic,
    Collider::capsule(0.5, 1.5),
    Mass(5.0),
    CenterOfMass::new(0.0, -0.5),
));
```

### Excluding Child Entities
Use `NoAutoMass`, `NoAutoAngularInertia`, and `NoAutoCenterOfMass` to prevent child colliders from contributing to the parent's total mass properties.

```rust
commands.spawn((
    RigidBody::Dynamic,
    Collider::capsule(0.5, 1.5),
    Mass(10.0),
    CenterOfMass::new(0.0, -0.5),
    NoAutoMass,
    NoAutoCenterOfMass,
))
.with_child((
    Collider::circle(1.0),
    Mass(5.0),
));
```
```

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

### from_rotation_arc_colinear

Source: https://docs.rs/avian2d/latest/avian2d/math/type.Quaternion.html

Gets the minimal rotation for transforming a vector to be colinear with another.

```APIDOC
## pub fn from_rotation_arc_colinear(from: Vec3, to: Vec3) -> Quat

### Description
Gets the minimal rotation for transforming `from` so that it is colinear with `to` or `-to`. The rotation is in the plane spanned by the two vectors and will rotate at most 90 degrees.
```

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

### get()

Source: https://docs.rs/avian2d/latest/avian2d/collision/contact_types/struct.Collisions.html

Retrieves a touching contact pair between two specific entities.

```APIDOC
### pub fn get(&self, entity1: Entity, entity2: Entity) -> Option<&ContactPair>

Returns a touching contact pair between two entities. If the pair does not exist, `None` is returned.
```

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

### Initialize PhysicsPlugins

Source: https://docs.rs/avian2d/latest/avian2d/index.html

Add the PhysicsPlugins group to your Bevy App to enable the physics engine.

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

fn main() {
    App::new()
        .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
        // ...your other plugins, systems and resources
        .run();
}
```

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

### Retrieve a value with get

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

Obtain a reference to an existing value in the set.

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

map.insert("foo");

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

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

### prepare

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/solver/xpbd/joints/struct.PointConstraintShared.html

Prepares the constraint with the given bodies and local anchor points.

```APIDOC
## pub fn prepare(&mut self, bodies: [&RigidBodyQueryReadOnlyItem<'_, '_>; 2], local_anchor1: Vector, local_anchor2: Vector)

### Description
Prepares the constraint with the given bodies and local anchor points.

### Parameters
- **bodies** ([&RigidBodyQueryReadOnlyItem<'_, '_>; 2]) - The two rigid bodies involved in the constraint.
- **local_anchor1** (Vector) - The local anchor point on the first body.
- **local_anchor2** (Vector) - The local anchor point on the second body.
```

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

### Get HashSet length

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

Retrieve the current number of elements in the set.

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

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

map.insert("foo");

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

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

### Initialize MassPropertyPlugin

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

Creates a new plugin instance with a custom schedule, defaulting to FixedPostUpdate.

```rust
impl MassPropertyPlugin {
    /// Creates a [`MassPropertyPlugin`] with the schedule that is used for running the [`PhysicsSchedule`].
    ///
    /// The default schedule is `FixedPostUpdate`.
    pub fn new(schedule: impl ScheduleLabel) -> Self {
        Self {
            schedule: schedule.intern(),
        }
    }
}

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

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

### index_of_name(name: &str)

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

Gets the index of the field with the given name.

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

### Description
Gets the index of the field with the given name.
```

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

### name_at(index: usize)

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

Gets the name of the field with index `index`.

```APIDOC
## fn name_at(&self, index: usize) -> Option<&str>

### Description
Gets the name of the field with index `index`.
```

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

### Enabling and Configuring Physics Debug Rendering

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

Demonstrates how to add the PhysicsDebugPlugin to a Bevy app and configure debug rendering globally and per-entity.

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

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

### RayCaster Methods

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

Methods for initializing and configuring a RayCaster instance.

```APIDOC
## pub fn new(origin: Vector, direction: Dir) -> Self
Creates a new RayCaster with a given origin and direction.

## pub fn from_ray(ray: Ray2d) -> Self
Creates a new RayCaster from a ray.

## pub fn with_origin(self, origin: Vector) -> Self
Sets the ray origin.

## pub fn with_direction(self, direction: Dir) -> Self
Sets the ray direction.

## pub fn with_solidness(self, solid: bool) -> Self
Controls how the ray behaves when the ray origin is inside of a collider.

## pub fn with_ignore_self(self, ignore: bool) -> Self
Sets if the ray caster should ignore hits against its own Collider.

## pub fn with_max_distance(self, max_distance: Scalar) -> Self
Sets the maximum distance the ray can travel.

## pub fn with_max_hits(self, max_hits: u32) -> Self
Sets the maximum number of allowed hits.

## pub fn with_query_filter(self, query_filter: SpatialQueryFilter) -> Self
Sets the ray caster’s query filter.
```

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

### create_island_with

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/solver/islands/struct.PhysicsIslands.html

Creates a new PhysicsIsland, calling the provided initialization function before adding it to the list.

```APIDOC
## pub fn create_island_with<F>(&mut self, init: F) -> IslandId

### Description
Creates a new `PhysicsIsland`, calling the given `init` function before pushing the island to the list.
```

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

### Manual Depenetration Example

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

Shows how to manually resolve intersections using depenetrate_intersections.

```rust
use bevy::prelude::*;
use avian2d::{prelude::*, character_controller::move_and_slide::DepenetrationConfig, math::{AdjustPrecision as _, AsF32 as _}};
```

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

### Define Collision Layers

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

Examples of initializing CollisionLayers using enums or LayerMasks.

```rust
let layers = CollisionLayers::new(
    GameLayer::Player,
    [GameLayer::Default, GameLayer::Enemy, GameLayer::Ground],
);
```

```rust
// Belongs to the first layer and interacts with all layers.
let layers = CollisionLayers::new(LayerMask(0b0001), LayerMask::ALL);
```

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

### Order Camera Systems for Smooth Movement

Source: https://docs.rs/avian2d/latest/avian2d/index.html

Ensure camera systems run after physics but before transform propagation to prevent stuttering.

```rust
app.add_systems(
    PostUpdate,
    camera_follow_player.before(TransformSystems::Propagate),
);
```

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

### Spawn a RigidBody

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/rigid_body/enum.RigidBody.html

Example of spawning a dynamic rigid body with a collider and transform.

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

fn setup(mut commands: Commands) {
    // Spawn a dynamic rigid body and specify its position.
    commands.spawn((
        RigidBody::Dynamic,
        Collider::capsule(0.5, 1.5),
        Transform::from_xyz(0.0, 3.0, 0.0),
    ));
}
```

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

### Configuring SweptCcd in Bevy

Source: https://docs.rs/avian2d/latest/avian2d/dynamics/ccd/struct.SweptCcd.html

Example showing how to spawn rigid bodies with different SweptCcd configurations to handle translational and rotational motion.

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

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(),
        LinearVelocity(Vec2::X * 100.0),
        Collider::circle(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)`
        LinearVelocity(Vec2::X * 100.0),
        Collider::circle(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,
        AngularVelocity(100.0),
        Collider::rectangle(0.2, 10.0),
    ));

    // Spawn another thin, long object, this time not rotating.
    // The second ball should now hit this.
    commands.spawn((
        RigidBody::Static,
        Collider::rectangle(0.2, 10.0),
        Transform::from_xyz(15.0, 0.0, 0.0),
    ));
}
```

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

### Toggling ColliderDisabled

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

Examples of adding and removing the component to control collider state.

```rust
#[derive(Component)]
pub struct Character;

/// Disables colliders for all rigid body characters, for example during cutscenes.
fn disable_character_colliders(
    mut commands: Commands,
    query: Query<Entity, (With<RigidBody>, With<Character>)>,
) {
    for entity in &query {
        commands.entity(entity).insert(ColliderDisabled);
    }
}

/// Enables colliders for all rigid body characters.
fn enable_character_colliders(
    mut commands: Commands,
    query: Query<Entity, (With<RigidBody>, With<Character>)>,
) {
    for entity in &query {
        commands.entity(entity).remove::<ColliderDisabled>();
    }
}
```

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

### Register Custom Constraint Systems

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

Add the constraint preparation and solving systems to the appropriate physics schedules.

```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),
);
```
Tokens:
Raw