Struct Contact

pub struct Contact {
    pub point1: Point<f32>,
    pub point2: Point<f32>,
    pub normal1: Unit<Vector<f32>>,
    pub normal2: Unit<Vector<f32>>,
    pub dist: f32,
}

Geometric description of a contact between two shapes.

A contact represents the point(s) where two shapes touch or penetrate. This structure contains all the information needed to resolve collisions: contact points, surface normals, and penetration depth.

Contact States

A Contact can represent different collision states:

• Touching (dist ≈ 0.0): Shapes are just barely in contact
• Penetrating (dist < 0.0): Shapes are overlapping (negative distance = penetration depth)
• Separated (dist > 0.0): Shapes are close but not touching (rarely used; see closest_points instead)

Coordinate Systems

Contact data can be expressed in different coordinate systems:

• World space: Both shapes’ transformations applied; normal2 = -normal1
• Local space: Relative to one shape’s coordinate system

Use Cases

• Physics simulation: Compute collision response forces
• Collision resolution: Push objects apart when penetrating
• Trigger detection: Detect when objects touch without resolving

Example

use parry3d::query::contact;
use parry3d::shape::Ball;
use nalgebra::{Isometry3, Vector3};

let ball1 = Ball::new(1.0);
let ball2 = Ball::new(1.0);

// Overlapping balls (centers 1.5 units apart, combined radii = 2.0)
let pos1 = Isometry3::translation(0.0, 0.0, 0.0);
let pos2 = Isometry3::translation(1.5, 0.0, 0.0);

if let Ok(Some(contact)) = contact(&pos1, &ball1, &pos2, &ball2, 0.0) {
    // Penetration depth (negative distance)
    assert!(contact.dist < 0.0);
    println!("Penetration: {}", -contact.dist); // 0.5 units

    // Normal points from shape 1 toward shape 2
    println!("Normal: {:?}", contact.normal1);

    // Contact points are on each shape's surface
    println!("Point on ball1: {:?}", contact.point1);
    println!("Point on ball2: {:?}", contact.point2);
}

Fields

point1: Point<f32>

Position of the contact point on the first shape’s surface.

This is the point on shape 1 that is closest to (or penetrating into) shape 2. Expressed in the same coordinate system as the contact (world or local space).

point2: Point<f32>

Position of the contact point on the second shape’s surface.

This is the point on shape 2 that is closest to (or penetrating into) shape 1. When shapes are penetrating, this point may be inside shape 1.

normal1: Unit<Vector<f32>>

Contact normal pointing outward from the first shape.

This unit vector points from shape 1 toward shape 2, perpendicular to the contact surface. Used to compute separation direction and collision response forces for shape 1.

normal2: Unit<Vector<f32>>

Contact normal pointing outward from the second shape.

In world space, this is always equal to -normal1. In local space coordinates, it may differ due to different shape orientations.

dist: f32

Signed distance between the two contact points.

• Positive: Shapes are separated (distance between surfaces)
• Zero: Shapes are exactly touching
• Negative: Shapes are penetrating (absolute value = penetration depth)

For collision resolution, use -dist as the penetration depth when dist < 0.0.

Implementations

impl Contact

pub fn new( point1: Point<f32>, point2: Point<f32>, normal1: Unit<Vector<f32>>, normal2: Unit<Vector<f32>>, dist: f32, ) -> Self

Creates a new contact with the given parameters.

Arguments

• point1 - Contact point on the first shape’s surface
• point2 - Contact point on the second shape’s surface
• normal1 - Unit normal pointing outward from shape 1
• normal2 - Unit normal pointing outward from shape 2
• dist - Signed distance (negative = penetration depth)

Example

use parry3d::query::Contact;
use nalgebra::{Point3, Unit, Vector3};

// Create a contact representing two spheres touching
let point1 = Point3::new(1.0, 0.0, 0.0);
let point2 = Point3::new(2.0, 0.0, 0.0);
let normal1 = Unit::new_normalize(Vector3::new(1.0, 0.0, 0.0));
let normal2 = Unit::new_normalize(Vector3::new(-1.0, 0.0, 0.0));

let contact = Contact::new(point1, point2, normal1, normal2, 0.0);
assert_eq!(contact.dist, 0.0); // Touching, not penetrating

impl Contact

pub fn flip(&mut self)

Swaps the points and normals of this contact.

pub fn flipped(self) -> Self

Returns a new contact containing the swapped points and normals of self.

pub fn transform_by_mut(&mut self, pos1: &Isometry<f32>, pos2: &Isometry<f32>)

Transform the points and normals from this contact by the given transformations.

pub fn transform1_by_mut(&mut self, pos: &Isometry<f32>)

Transform self.point1 and self.normal1 by the pos.

Trait Implementations

impl Clone for Contact

fn clone(&self) -> Contact

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Contact

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

Formats the value using the given formatter.

impl PartialEq for Contact

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Contact

impl StructuralPartialEq for Contact