Struct fyrox_core::math::ray::Ray

pub struct Ray {
    pub origin: Vector3<f32>,
    pub dir: Vector3<f32>,
}

Fields

origin: Vector3<f32>

dir: Vector3<f32>

Implementations

impl Ray

pub fn from_two_points(begin: Vector3<f32>, end: Vector3<f32>) -> Self

Creates ray from two points. May fail if begin == end.

pub fn new(origin: Vector3<f32>, dir: Vector3<f32>) -> Self

pub fn sphere_intersection_points(
    &self,
    position: &Vector3<f32>,
    radius: f32
) -> Option<[Vector3<f32>; 2]>

Checks intersection with sphere. Returns two intersection points or none if there was no intersection.

pub fn sphere_intersection(
    &self,
    position: &Vector3<f32>,
    radius: f32
) -> Option<IntersectionResult>

pub fn is_intersect_sphere(&self, position: &Vector3<f32>, radius: f32) -> bool

Checks intersection with sphere.

pub fn project_point(&self, point: &Vector3<f32>) -> f32

Returns t factor (at pt=o+d*t equation) for projection of given point at ray

pub fn get_point(&self, t: f32) -> Vector3<f32>

Returns point on ray which defined by pt=o+d*t equation.

pub fn box_intersection(
    &self,
    min: &Vector3<f32>,
    max: &Vector3<f32>
) -> Option<IntersectionResult>

pub fn box_intersection_points(
    &self,
    min: &Vector3<f32>,
    max: &Vector3<f32>
) -> Option<[Vector3<f32>; 2]>

pub fn aabb_intersection(
    &self,
    aabb: &AxisAlignedBoundingBox
) -> Option<IntersectionResult>

pub fn aabb_intersection_points(
    &self,
    aabb: &AxisAlignedBoundingBox
) -> Option<[Vector3<f32>; 2]>

pub fn plane_intersection(&self, plane: &Plane) -> f32

Solves plane equation in order to find ray equation parameter. There is no intersection if result < 0.

pub fn plane_intersection_point(&self, plane: &Plane) -> Option<Vector3<f32>>

pub fn triangle_intersection(
    &self,
    vertices: &[Vector3<f32>; 3]
) -> Option<(f32, Vector3<f32>)>

pub fn triangle_intersection_point(
    &self,
    vertices: &[Vector3<f32>; 3]
) -> Option<Vector3<f32>>

pub fn cylinder_intersection(
    &self,
    pa: &Vector3<f32>,
    pb: &Vector3<f32>,
    r: f32,
    kind: CylinderKind
) -> Option<IntersectionResult>

Generic ray-cylinder intersection test.

https://mrl.nyu.edu/~dzorin/rend05/lecture2.pdf

Infinite cylinder oriented along line pa + va * t: sqr_len(q - pa - dot(va, q - pa) * va) - r ^ 2 = 0 where q - point on cylinder, substitute q with ray p + v * t: sqr_len(p - pa + vt - dot(va, p - pa + vt) * va) - r ^ 2 = 0 reduce to A * t * t + B * t + C = 0 (quadratic equation), where: A = sqr_len(v - dot(v, va) * va) B = 2 * dot(v - dot(v, va) * va, dp - dot(dp, va) * va) C = sqr_len(dp - dot(dp, va) * va) - r ^ 2 where dp = p - pa to find intersection points we have to solve quadratic equation to get root which will be t parameter of ray equation.

pub fn try_eval_points(
    &self,
    result: Option<IntersectionResult>
) -> Option<[Vector3<f32>; 2]>

pub fn capsule_intersection(
    &self,
    pa: &Vector3<f32>,
    pb: &Vector3<f32>,
    radius: f32
) -> Option<[Vector3<f32>; 2]>

pub fn transform(&self, mat: Matrix4<f32>) -> Self

Transforms ray using given matrix. This method is useful when you need to transform ray into some object space to simplify calculations. For example you may have mesh with lots of triangles, and in one way you would take all vertices, transform them into world space by some matrix, then do intersection test in world space. This works, but too inefficient, much more faster would be to put ray into object space and do intersection test in object space. This removes vertex*matrix multiplication and significantly improves performance.

Trait Implementations

impl Clone for Ray

fn clone(&self) -> Ray

Returns a copy 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

Formats the value using the given formatter.

impl Default for Ray

fn default() -> Self

Returns the “default value” for a type.

impl Copy for Ray