Struct ContactConstraint 

pub struct ContactConstraint {
    pub body_a: BodyHandle,
    pub body_b: BodyHandle,
    pub contact_point: Vec2,
    pub normal: Vec2,
    pub penetration: f32,
    pub restitution: f32,
    pub friction: f32,
    pub baumgarte: f32,
    pub slop: f32,
    pub cached_normal: f32,
    pub cached_tangent: f32,
    /* private fields */
}

Contact constraint: normal impulse (non-penetration) + friction impulse.

Uses Baumgarte stabilization and warm-starting of cached impulses.

Fields

body_a: BodyHandle

body_b: BodyHandle

contact_point: Vec2

Contact point in world space.

normal: Vec2

Contact normal (from A to B).

penetration: f32

Penetration depth (positive = overlap).

restitution: f32

Restitution (bounciness).

friction: f32

Friction coefficient.

baumgarte: f32

Baumgarte bias factor.

slop: f32

Penetration slop — small overlaps are allowed.

cached_normal: f32

Warm-started normal impulse.

cached_tangent: f32

Warm-started friction impulse.

Implementations

impl ContactConstraint

pub fn new( body_a: BodyHandle, body_b: BodyHandle, contact_point: Vec2, normal: Vec2, penetration: f32, restitution: f32, friction: f32, ) -> Self

pub fn solve_contact( &mut self, bodies: &mut HashMap<BodyHandle, BodyState>, dt: f32, )

Solve both normal and friction in one call, handling warm-starting.

Trait Implementations

impl Clone for ContactConstraint

fn clone(&self) -> ContactConstraint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Constraint for ContactConstraint

fn prepare(&mut self, bodies: &HashMap<BodyHandle, BodyState>, dt: f32)

Prepare the constraint for the current step (pre-compute cached values).

fn compute_cdot(&self, bodies: &HashMap<BodyHandle, BodyState>) -> f32

Compute the velocity constraint violation (Cdot = J * v).

fn compute_c(&self, _bodies: &HashMap<BodyHandle, BodyState>) -> f32

Compute the position constraint violation (C).

fn effective_mass(&self, bodies: &HashMap<BodyHandle, BodyState>) -> f32

Compute effective constraint mass (1 / (J M^-1 J^T)).

fn bias(&self, _bodies: &HashMap<BodyHandle, BodyState>, _dt: f32) -> f32

Baumgarte position bias.

fn apply_impulse( &self, bodies: &mut HashMap<BodyHandle, BodyState>, lambda: f32, )

Apply the corrective impulse to body states.

fn solve_velocity( &mut self, bodies: &mut HashMap<BodyHandle, BodyState>, dt: f32, )

Solve velocity constraint (one iteration).

fn impulse_bounds(&self) -> (f32, f32)

Whether this constraint has an upper/lower impulse clamp.

fn accumulated_impulse(&self) -> f32

Accumulated impulse for warm starting.

fn reset_accumulated(&mut self)

fn add_accumulated(&mut self, d: f32)

fn body_handles(&self) -> Vec<BodyHandle>

Bodies involved in this constraint.

fn get_compliance(&self) -> f32

XPBD compliance (inverse stiffness). 0 = rigid.

fn solve_position( &mut self, bodies: &mut HashMap<BodyHandle, BodyState>, dt: f32, )

Solve position constraint using XPBD (one sub-step).

impl Debug for ContactConstraint

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

Formats the value using the given formatter.