Struct theon::query::Ray

pub struct Ray<S> where
    S: EuclideanSpace,  {
    pub origin: S,
    pub direction: Unit<Vector<S>>,
}

Ray or half-line.

Describes a decomposed line with an origin or initial point and a direction. Rays extend infinitely from their origin. The origin $P_0$ and the point $P_0 + \hat{u}$ (where $\hat{u}$ is the direction of the ray) form a half-line originating from $P_0$.

Fields

origin: S

The origin or initial point of the ray.

direction: Unit<Vector<S>>

The unit direction in which the ray extends from its origin.

Implementations

impl<S> Ray<S> where
    S: EuclideanSpace, 

pub fn into_line(self) -> Line<S>

pub fn reverse(self) -> Self

Reverses the direction of the ray.

Reversing a ray yields its opposite, with the same origin and the opposing half-line.

Trait Implementations

impl<S: Clone> Clone for Ray<S> where
    S: EuclideanSpace, 

fn clone(&self) -> Ray<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Ray<S> where
    S: Debug + EuclideanSpace,
    Vector<S>: Debug, 

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

Formats the value using the given formatter.

impl<S> Default for Ray<S> where
    S: EuclideanSpace, 

fn default() -> Self

Returns the “default value” for a type.

impl<S> Intersection<Aabb<S>> for Ray<S> where
    S: EuclideanSpace,
    Aabb<S>: Intersection<Ray<S>>, 

Symmetrical intersection.

type Output = <Aabb<S> as Intersection<Ray<S>>>::Output

fn intersection(&self, other: &Aabb<S>) -> Option<Self::Output>

impl<S> Intersection<Plane<S>> for Ray<S> where
    S: EuclideanSpace,
    Plane<S>: Intersection<Ray<S>>, 

Symmetrical intersection.

type Output = <Plane<S> as Intersection<Ray<S>>>::Output

fn intersection(&self, other: &Plane<S>) -> Option<Self::Output>

impl<S> Intersection<Ray<S>> for Aabb<S> where
    S: EuclideanSpace,
    Scalar<S>: Bounded + Infinite + IntrinsicOrd + Signed, 

Intersection of an axis-aligned bounding box and a ray.

type Output = (<<S as EuclideanSpace>::CoordinateSpace as VectorSpace>::Scalar, <<S as EuclideanSpace>::CoordinateSpace as VectorSpace>::Scalar)

The minimum and maximum times of impact of the intersection.

The times of impact $t_{min}$ and $t_{max}$ describe the distance along the half-line from the ray’s origin at which the intersection occurs.

fn intersection(&self, ray: &Ray<S>) -> Option<Self::Output>

Determines the minimum and maximum times of impact of a Ray intersection with an Aabb.

Given a ray formed by an origin $P_0$ and a unit direction $\hat{u}$, the nearest point of intersection is $P_0 + t_{min}\hat{u}$.

Examples

Determine the point of impact between a ray and axis-aligned bounding box:

use nalgebra::Point2;
use theon::space::{EuclideanSpace, VectorSpace};
use theon::query::{Aabb, Intersection, Ray, Unit};

type E2 = Point2<f64>;

let aabb = Aabb::<E2> {
    origin: EuclideanSpace::from_xy(1.0, -1.0),
    extent: VectorSpace::from_xy(2.0, 2.0),
};
let ray = Ray::<E2> {
    origin: EuclideanSpace::origin(),
    direction: Unit::x(),
};
let (min, _) = ray.intersection(&aabb).unwrap();
let point = ray.origin + (ray.direction.get() * min);

impl<S> Intersection<Ray<S>> for Plane<S> where
    S: EuclideanSpace + FiniteDimensional,
    <S as FiniteDimensional>::N: Cmp<U2, Output = Greater>,
    Scalar<S>: Signed, 

Intersection of a plane and a ray.

type Output = PlaneRay<S>

The time of impact of a point intersection or the ray if it lies within the plane.

The time of impact $t$ describes the distance along the half-line from the ray’s origin at which the intersection occurs.

fn intersection(&self, ray: &Ray<S>) -> Option<Self::Output>

Determines if a ray intersects a plane at a point or lies within the plane. Computes the time of impact of a Ray for a point intersection.

Given a ray formed by an origin $P_0$ and a unit direction $\hat{u}$, the point of intersection with the plane is $P_0 + t\hat{u}$.

impl<S> Neg for Ray<S> where
    S: EuclideanSpace, 

type Output = Ray<S>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<S: PartialEq> PartialEq<Ray<S>> for Ray<S> where
    S: EuclideanSpace, 

fn eq(&self, other: &Ray<S>) -> bool

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

fn ne(&self, other: &Ray<S>) -> bool

This method tests for !=.

impl<S: Copy> Copy for Ray<S> where
    S: EuclideanSpace, 

impl<S> StructuralPartialEq for Ray<S> where
    S: EuclideanSpace,