Struct bvh::ray::Ray

pub struct Ray<T: BHValue, const D: usize> {
    pub origin: Point<T, D>,
    pub direction: SVector<T, D>,
    pub inv_direction: SVector<T, D>,
}

A struct which defines a ray and some of its cached values.

Fields

origin: Point<T, D>

The ray origin.

direction: SVector<T, D>

The ray direction.

inv_direction: SVector<T, D>

Inverse (1/x) ray direction. Cached for use in Aabb intersections.

Implementations

impl<T: BHValue, const D: usize> Ray<T, D>

pub fn new(origin: Point<T, D>, direction: SVector<T, D>) -> Ray<T, D>

where T: One + ComplexField,

Creates a new Ray from an origin and a direction. direction will be normalized.

Examples

use bvh::ray::Ray;
use nalgebra::{Point3,Vector3};

let origin = Point3::new(0.0,0.0,0.0);
let direction = Vector3::new(1.0,0.0,0.0);
let ray = Ray::new(origin, direction);

assert_eq!(ray.origin, origin);
assert_eq!(ray.direction, direction);

pub fn intersects_aabb(&self, aabb: &Aabb<T, D>) -> bool

where T: ClosedSub + ClosedMul + Zero + PartialOrd + SimdPartialOrd,

Tests the intersection of a Ray with an Aabb using the optimized algorithm from this paper.

Examples

use bvh::aabb::Aabb;
use bvh::ray::Ray;
use nalgebra::{Point3,Vector3};

let origin = Point3::new(0.0,0.0,0.0);
let direction = Vector3::new(1.0,0.0,0.0);
let ray = Ray::new(origin, direction);

let point1 = Point3::new(99.9,-1.0,-1.0);
let point2 = Point3::new(100.1,1.0,1.0);
let aabb = Aabb::with_bounds(point1, point2);

assert!(ray.intersects_aabb(&aabb));

pub fn intersects_triangle( &self, a: &Point<T, D>, b: &Point<T, D>, c: &Point<T, D> ) -> Intersection<T>

where T: ClosedAdd + ClosedSub + ClosedMul + Zero + One + Float,

Implementation of the Möller-Trumbore triangle/ray intersection algorithm. Returns the distance to the intersection, as well as the u and v coordinates of the intersection. The distance is set to +INFINITY if the ray does not intersect the triangle, or hits it from behind.

Trait Implementations

impl<T: Clone + BHValue, const D: usize> Clone for Ray<T, D>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + BHValue, const D: usize> Debug for Ray<T, D>

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

Formats the value using the given formatter.

impl<T: Copy + BHValue, const D: usize> Copy for Ray<T, D>