Struct ark_api::Ray3

pub struct Ray3 {
    pub origin: Vec3,
    pub dir: Vec3,
}

A ray in 3-dimensional space: a line through space with a starting point and a direction.

Any point on the ray can be found through the formula origin + t * dir, where t is a non-negative floating point value, which represents the distance along the ray.

Fields

origin: Vec3

Start of the ray

dir: Vec3

Direction of the ray, normalized

Implementations

impl Ray3

pub const ZERO: Ray3 = Self{ origin: Vec3::ZERO, dir: Vec3::ZERO,}

An invalid ray, starting at the origin and going nowhere.

pub fn from_origin_dir(origin: Vec3, dir: Vec3) -> Ray3

dir should be normalized

pub fn normalize(&self) -> Ray3

Get normalized ray (where dir.len() == 1).

pub fn offset_along_ray(&self, t: f32) -> Ray3

Returns a new ray that has had its origin moved a given distance forwards along the ray.

If the ray direction is normalized then the t parameter corresponds to the world space distance it moves.

pub fn is_finite(&self) -> bool

True if every value is finite

pub fn point_along(&self, t: f32) -> Vec3

pub fn closest_points(&self, other: &Ray3) -> (Vec3, Vec3)

Returns the line segment where self and other are the closest to each other. If the rays are parallel then non-finite points are returned.

pub fn closest_ts(&self, other: &Ray3) -> (f32, f32)

Returns the distance along both rays which together form line segment where self and other are the closest to each other. If the rays are parallel then non-finite values are returned.

pub fn intersects_plane(&self, plane: Plane3) -> Vec3

Returns the point where the ray intersects the plane. Returns non-finite result of the ray and plane are parallel.

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

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

Returns the point along the ray that is closest to the given point. The returned point may be “behind” the ray origin.

Trait Implementations

impl Clone for Ray3

fn clone(&self) -> Ray3

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Ray3

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

Formats the value using the given formatter.

impl Default for Ray3

fn default() -> Ray3

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Ray3

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

Deserialize this value from the given Serde deserializer.

impl Mul<Ray3> for Affine3A

type Output = Ray3

The resulting type after applying the * operator.

fn mul(self, rhs: Ray3) -> Ray3

Performs the * operation.

impl Mul<Ray3> for IsoTransform

type Output = Ray3

The resulting type after applying the * operator.

fn mul(self, rhs: Ray3) -> Ray3

Performs the * operation.

impl Mul<Ray3> for Mat4

type Output = Ray3

The resulting type after applying the * operator.

fn mul(self, rhs: Ray3) -> Ray3

Performs the * operation.

impl PartialEq<Ray3> for Ray3

fn eq(&self, other: &Ray3) -> 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<'a_, C_> Readable<'a_, C_> for Ray3 where
    C_: Context, 

fn read_from<R_>(_reader_: &mut R_) -> Result<Ray3, <C_ as Context>::Error> where
    R_: Reader<'a_, C_>, 

fn minimum_bytes_needed() -> usize

fn read_from_buffer_with_ctx(
    context: C,
    buffer: &'a [u8]
) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_with_ctx(
    context: C,
    buffer: &'a [u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_buffer_copying_data_with_ctx(
    context: C,
    buffer: &[u8]
) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_copying_data_with_ctx(
    context: C,
    buffer: &[u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_with_length_from_buffer_copying_data_with_ctx_mut(
    context: &mut C,
    buffer: &[u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_stream_unbuffered_with_ctx<S>(
    context: C,
    stream: S
) -> Result<Self, <C as Context>::Error> where
    S: Read, 

fn read_from_stream_buffered_with_ctx<S>(
    context: C,
    stream: S
) -> Result<Self, <C as Context>::Error> where
    S: Read, 

fn read_from_file_with_ctx(
    context: C,
    path: impl AsRef<Path>
) -> Result<Self, <C as Context>::Error>

impl Serialize for Ray3

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<C_> Writable<C_> for Ray3 where
    C_: Context, 

fn write_to<T_>(&self, _writer_: &mut T_) -> Result<(), <C_ as Context>::Error> where
    T_: Writer<C_> + ?Sized, 

fn write_to_buffer_with_ctx(
    &self,
    context: C,
    buffer: &mut [u8]
) -> Result<(), <C as Context>::Error>

fn write_to_buffer_with_ctx_mut(
    &self,
    context: &mut C,
    buffer: &mut [u8]
) -> Result<(), <C as Context>::Error>

fn write_to_vec_with_ctx(
    &self,
    context: C
) -> Result<Vec<u8, Global>, <C as Context>::Error>

fn write_to_vec_with_ctx_mut(
    &self,
    context: &mut C
) -> Result<Vec<u8, Global>, <C as Context>::Error>

fn write_to_stream_with_ctx<S>(
    &self,
    context: C,
    stream: S
) -> Result<(), <C as Context>::Error> where
    S: Write, 

fn write_to_file_with_ctx(
    &self,
    context: C,
    path: impl AsRef<Path>
) -> Result<(), <C as Context>::Error>

fn bytes_needed(&self) -> Result<usize, <C as Context>::Error>

impl Copy for Ray3

impl StructuralPartialEq for Ray3