Struct Dir 

pub struct Dir<T: Scalar, const N: usize, S: Space>(/* private fields */);

A direction in N-dimensional space, represented by a unit vector.

The API of this type is fairly limited to ensure it always contains a unit vector.

Implementations

impl<T: Scalar, const N: usize, S: Space> Dir<T, N, S>

pub fn from_vec(v: Vector<T, N, S>) -> Self

where T: Float,

Returns the direction of the given vector. If v is the null vector, this function panics.

pub fn from_unit_vec_unchecked(v: Vector<T, N, S>) -> Self

Returns the wrapped input vector, assuming it is normalized.

pub fn to_unit_vec(&self) -> Vector<T, N, S>

Returns the unit vector that represents this direction.

pub fn to_point(&self) -> Point<T, N, S>

Returns the point corresponding to this unit vector (a point on the unit sphere).

pub fn in_space<Target: Space>(self) -> Dir<T, N, Target>

Reinterprets this direction as being in the space Target instead of S. Before calling this, make sure this operation makes semantic sense and don’t just use it to get rid of compiler errors.

pub fn to_f32(self) -> Dir<f32, N, S>

where T: NumCast,

Casts self to using f32 as scalar.

pub fn to_f64(self) -> Dir<f64, N, S>

where T: NumCast,

Casts self to using f64 as scalar.

pub fn as_bytes(&self) -> &[u8]

Returns a byte slice of the unit vector representing this direction. Useful to pass to graphics APIs.

pub fn to_array(self) -> [T; N]

Returns the components of this unit vector as arary.

impl<T: Scalar, S: Space> Dir<T, 2, S>

pub fn new(x: T, y: T) -> Self

where T: Float,

Creates a Dir by normalizing the vector specified by the given coordinates.

pub const fn new_unchecked(x: T, y: T) -> Self

Creates a Dir without checking that the given values form a unit vector.

pub fn unit_x() -> Self

Returns (1, 0, 0).

pub fn unit_y() -> Self

Returns (0, 1, 0).

pub fn x(&self) -> T

Returns the x coordinate.

pub fn y(&self) -> T

Returns the y coordinate.

impl<T: Scalar, S: Space> Dir<T, 3, S>

pub fn new(x: T, y: T, z: T) -> Self

where T: Float,

Creates a Dir by normalizing the vector specified by the given coordinates.

pub const fn new_unchecked(x: T, y: T, z: T) -> Self

Creates a Dir without checking that the given values form a unit vector.

pub fn unit_x() -> Self

Returns (1, 0, 0).

pub fn unit_y() -> Self

Returns (0, 1, 0).

pub fn unit_z() -> Self

Returns (0, 0, 1).

pub fn x(&self) -> T

Returns the x coordinate.

pub fn y(&self) -> T

Returns the y coordinate.

pub fn z(&self) -> T

Returns the z coordinate.

Trait Implementations

impl<T: Scalar, const N: usize, S: Space> Clone for Dir<T, N, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Scalar, const N: usize, S: Space> Div<T> for Dir<T, N, S>

type Output = Vector<T, N, S>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Float, S: Space> From<Dir<T, 3, S>> for SphericalDir<T, S>

fn from(src: Dir3<T, S>) -> Self

Converts to this type from the input type.

impl<T: Scalar, const N: usize, S: Space> From<Dir<T, N, S>> for [T; N]

fn from(src: Dir<T, N, S>) -> Self

Converts to this type from the input type.

impl<T: Float, const N: usize, S: Space> From<Dir<T, N, S>> for Vector<T, N, S>

fn from(src: Dir<T, N, S>) -> Self

Converts to this type from the input type.

impl<T: Float, const N: usize, S: Space> From<Vector<T, N, S>> for Dir<T, N, S>

If the null vector is passed, this function panics.

fn from(v: Vector<T, N, S>) -> Self

Converts to this type from the input type.

impl<T: Scalar + Hash, const N: usize, S: Space> Hash for Dir<T, N, S>

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

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: Scalar, const N: usize, S: Space> Index<usize> for Dir<T, N, S>

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Scalar, const C: usize, const R: usize, Src: Space, Dst: Space> Mul<Dir<T, C, Src>> for &Matrix<T, C, R, Src, Dst>

See Matrix::transform.

type Output = Vector<T, R, Dst>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<T, C, Src>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<f32, N, S>> for f32

type Output = Vector<f32, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<f32, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<f64, N, S>> for f64

type Output = Vector<f64, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<f64, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<i128, N, S>> for i128

type Output = Vector<i128, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<i128, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<i16, N, S>> for i16

type Output = Vector<i16, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<i16, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<i32, N, S>> for i32

type Output = Vector<i32, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<i32, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<i64, N, S>> for i64

type Output = Vector<i64, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<i64, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<i8, N, S>> for i8

type Output = Vector<i8, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<i8, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<u128, N, S>> for u128

type Output = Vector<u128, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<u128, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<u16, N, S>> for u16

type Output = Vector<u16, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<u16, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<u32, N, S>> for u32

type Output = Vector<u32, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<u32, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<u64, N, S>> for u64

type Output = Vector<u64, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<u64, N, S>) -> Self::Output

Performs the * operation.

impl<const N: usize, S: Space> Mul<Dir<u8, N, S>> for u8

type Output = Vector<u8, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: Dir<u8, N, S>) -> Self::Output

Performs the * operation.

impl<T: Scalar, const N: usize, S: Space> Mul<T> for Dir<T, N, S>

type Output = Vector<T, N, S>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: Scalar + Neg, const N: usize, S: Space> Neg for Dir<T, N, S>

where <T as Neg>::Output: Scalar,

type Output = Dir<<T as Neg>::Output, N, S>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Scalar, const N: usize, S: Space> PartialEq for Dir<T, N, S>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Scalar + Zeroable, const N: usize, S: Space> Zeroable for Dir<T, N, S>

fn zeroed() -> Self

Calls zeroed.

impl<T: Scalar, const N: usize, S: Space> Copy for Dir<T, N, S>

impl<T: Scalar + Pod, const N: usize, S: Space> Pod for Dir<T, N, S>