Struct bevy_xpbd_2d::constraints::penetration::PenetrationConstraint

pub struct PenetrationConstraint {

    pub entity1: Entity,
    pub entity2: Entity,
    pub collider_entity1: Entity,
    pub collider_entity2: Entity,
    pub contact: ContactData,
    pub manifold_index: usize,
    pub r1: Vector,
    pub r2: Vector,
    pub normal_lagrange: Scalar,
    pub tangent_lagrange: Scalar,
    pub compliance: Scalar,
    pub friction: Friction,
    pub restitution: Restitution,
}

A constraint between two bodies that prevents overlap with a given compliance.

A compliance of 0.0 resembles a constraint with infinite stiffness, so the bodies should not have any overlap.

Fields

entity1: Entity

First entity in the constraint.

entity2: Entity

Second entity in the constraint.

collider_entity1: Entity

The entity of the collider of the first body.

collider_entity2: Entity

The entity of the collider of the second body.

contact: ContactData

Data associated with the contact.

manifold_index: usize

The index of the contact in the manifold.

r1: Vector

Vector from the first entity’s center of mass to the contact point in local coordinates.

r2: Vector

Vector from the second entity’s center of mass to the contact point in local coordinates.

normal_lagrange: Scalar

Lagrange multiplier for the normal force.

tangent_lagrange: Scalar

Lagrange multiplier for the tangential force.

compliance: Scalar

The constraint’s compliance, the inverse of stiffness, has the unit meters / Newton.

friction: Friction

The effective friction of the contact.

restitution: Restitution

The effective restitution of the contact.

Implementations

impl PenetrationConstraint

pub fn new( body1: &RigidBodyQueryItem<'_>, body2: &RigidBodyQueryItem<'_>, collider_entity1: Entity, collider_entity2: Entity, contact: ContactData, manifold_index: usize ) -> Self

Creates a new PenetrationConstraint with the given bodies and contact data.

The manifold_index is the index of the contact in a ContactManifold.

Trait Implementations

impl Clone for PenetrationConstraint

fn clone(&self) -> PenetrationConstraint

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PenetrationConstraint

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl MapEntities for PenetrationConstraint

fn map_entities<M: EntityMapper>(&mut self, entity_mapper: &mut M)

Updates all [Entity] references stored inside using entity_mapper.

impl PartialEq for PenetrationConstraint

fn eq(&self, other: &PenetrationConstraint) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PositionConstraint for PenetrationConstraint

fn apply_positional_correction( &self, body1: &mut RigidBodyQueryItem<'_>, body2: &mut RigidBodyQueryItem<'_>, delta_lagrange: Scalar, direction: Vector, r1: Vector, r2: Vector ) -> Vector

Applies a positional correction to two bodies.

fn compute_generalized_inverse_mass( &self, body: &RigidBodyQueryItem<'_>, r: Vector, n: Vector ) -> Scalar

Computes the generalized inverse mass of a body when applying a positional correction at point r along the vector n.

fn get_delta_rot( _rot: Rotation, inverse_inertia: Scalar, r: Vector, p: Vector ) -> Rotation

Computes the update in rotation when applying a positional correction p at point r.

fn compute_force( &self, lagrange: Scalar, direction: Vector, dt: Scalar ) -> Vector

Computes the force acting along the constraint using the equation f = lambda * n / h^2

impl XpbdConstraint<2> for PenetrationConstraint

fn solve(&mut self, bodies: [&mut RigidBodyQueryItem<'_>; 2], dt: Scalar)

Solves overlap between two bodies.

fn entities(&self) -> [Entity; 2]

The entities participating in the constraint.

fn clear_lagrange_multipliers(&mut self)

Sets the constraint’s Lagrange multipliers to 0.

fn compute_lagrange_update( &self, lagrange: Scalar, c: Scalar, gradients: &[Vector], inverse_masses: &[Scalar], compliance: Scalar, dt: Scalar ) -> Scalar

Computes how much a constraint’s Lagrange multiplier changes when projecting the constraint for all participating particles.

impl Copy for PenetrationConstraint

impl StructuralPartialEq for PenetrationConstraint