Struct Ray 

pub struct Ray {
    pub origin: Vec3,
    pub direction: Vec3,
}

A half-line: an origin and a direction.

direction is expected to be normalised. Ray::new guarantees it; the struct literal — kept public because a ray is plain data — does not.

Fields

origin: Vec3

Origin point.

direction: Vec3

Direction vector (should be normalized).

Implementations

impl Ray

pub fn new(origin: Vec3, direction: Vec3) -> Ray

Creates a ray, normalising direction.

pub fn at(&self, distance: f32) -> Vec3

The point distance along the ray.

pub fn inv_direction(&self) -> Vec3

The component-wise reciprocal of the direction, as the slab test wants it.

A zero component yields an infinity, which Aabb::intersect_ray handles correctly: a ray parallel to a slab simply never leaves it.

pub fn intersect_aabb(&self, aabb: &Aabb) -> Option<f32>

Distance to the near face of aabb, or None if the ray misses it.

Negative when the origin is already inside or past the box. Hoist Ray::inv_direction and call Aabb::intersect_ray directly when testing one ray against many boxes.

pub fn intersect_plane(&self, point: Vec3, normal: Vec3) -> Option<f32>

Distance to the plane through point with normal normal, or None when the ray is parallel to it or the plane lies behind the origin.

normal need not be normalised — it only appears in a ratio.

pub fn distance_to_point(&self, point: Vec3) -> f32

Perpendicular distance from point to the ray.

Measured from the half-line: a point behind the origin is measured from the origin itself, not from the line the ray extends backwards along.

pub fn closest_param_on_line( &self, origin: Vec3, direction: Vec3, ) -> Option<f32>

How far along the line origin + t * direction its closest approach to this ray sits, or None if the two are parallel.

The classic closest-approach of two skew lines. direction must be normalised. Note this parameterises the other line, not the ray — which is what a caller dragging along an axis wants to know.

pub fn closest_point_on_segment(&self, a: Vec3, b: Vec3) -> Vec3

The point on segment a..b closest to this ray.

Falls back to the midpoint when the segment is parallel to the ray or degenerate — every point on it is then equally close, and a caller hit-testing a handle wants an answer rather than an absence.

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for Ray

fn borrow_decode<__D>(decoder: &mut __D) -> Result<Ray, DecodeError>

where __D: BorrowDecoder<'__de, Context = __Context>,

Attempt to decode this type with the given BorrowDecode.

impl Clone for Ray

fn clone(&self) -> Ray

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ray

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for Ray

fn decode<__D>(decoder: &mut __D) -> Result<Ray, DecodeError>

where __D: Decoder<Context = __Context>,

Attempt to decode this type with the given Decode.

impl<'de> Deserialize<'de> for Ray

fn deserialize<__D>( __deserializer: __D, ) -> Result<Ray, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for Ray

fn encode<__E>(&self, encoder: &mut __E) -> Result<(), EncodeError>

where __E: Encoder,

Encode a given type.

impl PartialEq for Ray

fn eq(&self, other: &Ray) -> 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 Serialize for Ray

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Ray

impl StructuralPartialEq for Ray