Struct RayIntersection

pub struct RayIntersection {
    pub time_of_impact: f32,
    pub normal: Vector<f32>,
    pub feature: FeatureId,
}

Result of a successful ray cast against a shape.

This structure contains all information about where and how a ray intersects a shape, including the time of impact, surface normal, and geometric feature hit.

Fields

• time_of_impact: The t parameter where the ray hits (use with ray.point_at(t))
• normal: The surface normal at the hit point
• feature: Which geometric feature was hit (vertex, edge, or face)

Time of Impact

The time of impact is the parameter t in the ray equation origin + dir * t:

• If dir is normalized: t represents the distance traveled
• If dir is not normalized: t represents time (distance / speed)

Normal Direction

The normal behavior depends on the ray origin and solid parameter:

• Outside solid shape: Normal points outward from the surface
• Inside non-solid shape: Normal points inward (toward the interior)
• At t=0.0: Normal may be unreliable due to numerical precision

Example

use parry3d::query::{Ray, RayCast};
use parry3d::shape::Cuboid;
use nalgebra::{Point3, Vector3, Isometry3};

let cuboid = Cuboid::new(Vector3::new(1.0, 1.0, 1.0));
let ray = Ray::new(
    Point3::new(-5.0, 0.0, 0.0),
    Vector3::new(1.0, 0.0, 0.0)
);

if let Some(intersection) = cuboid.cast_ray_and_get_normal(
    &Isometry3::identity(),
    &ray,
    100.0,
    true
) {
    // Ray hits the -X face of the cuboid at x=-1.0
    assert_eq!(intersection.time_of_impact, 4.0); // Distance from -5 to -1

    // Hit point is at (-1, 0, 0) - the surface of the cuboid
    let hit_point = ray.point_at(intersection.time_of_impact);
    assert_eq!(hit_point.x, -1.0);

    // Normal points outward (in -X direction for the -X face)
    assert_eq!(intersection.normal, Vector3::new(-1.0, 0.0, 0.0));
}

Fields

time_of_impact: f32

The time of impact (parameter t) where the ray hits the shape.

The exact hit point can be computed with ray.point_at(time_of_impact). If the ray direction is normalized, this represents the distance traveled.

normal: Vector<f32>

The surface normal at the intersection point.

• Typically points outward from the shape
• May point inward if ray origin is inside a non-solid shape
• May be unreliable if time_of_impact is exactly zero

Note: This should be a unit vector but is not enforced by the type system yet.

feature: FeatureId

The geometric feature (vertex, edge, or face) that was hit.

This can be used for more detailed collision response or to identify exactly which part of the shape was struck.

Implementations

impl RayIntersection

pub fn new( time_of_impact: f32, normal: Vector<f32>, feature: FeatureId, ) -> RayIntersection

Creates a new RayIntersection.

pub fn transform_by(&self, transform: &Isometry<f32>) -> Self

Trait Implementations

impl BvhLeafCost for RayIntersection

fn cost(&self) -> f32

The cost value associated to the leaf.

impl Clone for RayIntersection

fn clone(&self) -> RayIntersection

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RayIntersection

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

Formats the value using the given formatter.

impl Copy for RayIntersection