Struct veloren_voxygen::scene::math::Ray

pub struct Ray<T> {
    pub origin: Vec3<T>,
    pub direction: Vec3<T>,
}

3D ray, represented by a starting point and a normalized direction vector.

Fields

origin: Vec3<T>

The ray’s starting point.

direction: Vec3<T>

The ray’s direction. Methods expect it to be normalized.

Implementations

impl<T> Ray<T>

where T: Real<Output = T> + Add,

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

Creates a Ray from a starting point and direction.

This doesn’t check if direction is normalized, because either you know it is, or it isn’t and maybe it doesn’t matter for your use case.

pub fn triangle_intersection(&self, tri: [Vec3<T>; 3]) -> Option<T>

Tests if this ray intersects the given triangle, returning the distance from the ray’s origin along its direction where the intersection lies.

If the returned value is Some(x) where x < EPSILON, then you should assume there was a line intersection, NOT a ray intersection.

This uses the Möller–Trumbore intersection algorithm.

Trait Implementations

impl<T> Clone for Ray<T>

where T: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Ray<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Ray<T>

where T: Default,

fn default() -> Ray<T>

Returns the “default value” for a type.

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

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Hash for Ray<T>

where T: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> PartialEq for Ray<T>

where T: PartialEq,

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

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

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

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

impl<T> Serialize for Ray<T>

where T: Serialize,

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<T> Copy for Ray<T>

where T: Copy,

impl<T> Eq for Ray<T>

where T: Eq,

impl<T> StructuralPartialEq for Ray<T>