Struct Vector3 

pub struct Vector3<T> {
    pub x: T,
    pub y: T,
    pub z: T,
}

A vector of three components x, y, and z.

Fields

x: T

The first component.

y: T

The second component.

z: T

The third component.

Implementations

impl<T> Vector3<T>

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

Constructs a vector from its three components.

pub fn from_array(array: [T; 3]) -> Self

Constructs a vector from an array [x, y, z].

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

Returns the components as an array [x, y, z].

pub fn with_x(self, x: T) -> Self

Returns a copy of self with the x component replaced.

pub fn with_y(self, y: T) -> Self

Returns a copy of self with the y component replaced.

pub fn with_z(self, z: T) -> Self

Returns a copy of self with the z component replaced.

pub fn map<U, F: FnMut(T) -> U>(self, f: F) -> Vector3<U>

Applies f to every component, returning the resulting vector.

pub fn zip_map<U, R, F: FnMut(T, U) -> R>( self, rhs: Vector3<U>, f: F, ) -> Vector3<R>

Combines self and rhs component-wise through f.

impl<T: Copy> Vector3<T>

pub const fn splat(value: T) -> Self

Constructs a vector with all three components set to value.

pub fn from_slice(slice: &[T]) -> Self

Constructs a vector from the first three elements of a slice.

Panics

Panics if slice has fewer than three elements.

impl<T: Add<Output = T>> Vector3<T>

pub fn element_sum(self) -> T

Returns the sum of the three components, x + y + z.

impl<T: Add<Output = T> + Sub<Output = T> + Copy> Vector3<T>

pub fn lerp<S: Scalar>(self, rhs: Self, t: S) -> Self

where T: Mul<S, Output = T>,

Linearly interpolates from self toward rhs by the factor t.

t == 0 yields self, t == 1 yields rhs.

impl<V: Scalar> Vector3<V>

pub const ZERO: Self

The zero vector, (0, 0, 0).

pub const ONE: Self

The vector with every component set to one, (1, 1, 1).

pub const X: Self

The unit vector along the x axis, (1, 0, 0).

pub const Y: Self

The unit vector along the y axis, (0, 1, 0).

pub const Z: Self

The unit vector along the z axis, (0, 0, 1).

pub fn dot(self, rhs: Self) -> V

Returns the dot product self · rhs.

pub fn cross(self, rhs: Self) -> Self

Returns the cross product self × rhs.

pub fn norm_squared(self) -> V

Returns the squared Euclidean norm self · self.

Cheaper than norm and sufficient whenever only relative magnitudes are compared.

pub fn norm(self) -> V

Returns the Euclidean norm (length) of the vector.

pub fn normalize(self) -> Self

Returns self rescaled to unit length.

Yields a non-finite vector when the norm is zero or non-finite; use try_normalize or normalize_or_zero to handle those cases.

pub fn try_normalize(self) -> Option<Self>

Returns self rescaled to unit length, or None if the result would not be finite (e.g. for the zero vector).

pub fn normalize_or_zero(self) -> Self

Returns self rescaled to unit length, or the zero vector if the result would not be finite.

pub fn is_normalized(self) -> bool

Returns true if the vector is of unit length within a small tolerance (2.0e-4).

pub fn angle_between(self, rhs: Self) -> V

Returns the unsigned angle between self and rhs, in radians within [0, π].

The computation is numerically stable across the whole range, including near-parallel and near-antiparallel inputs.

pub fn project_onto(self, onto: Self) -> Self

Returns the vector projection of self onto onto.

pub fn reject_from(self, from: Self) -> Self

Returns the component of self orthogonal to from.

pub fn reflect(self, normal: Self) -> Self

Reflects self across the plane through the origin with unit normal normal.

pub fn recip(self) -> Self

Returns the component-wise reciprocal (1/x, 1/y, 1/z).

pub fn element_product(self) -> V

Returns the product of the three components, x * y * z.

pub fn abs(self) -> Self

Returns the component-wise absolute value.

pub fn min(self, rhs: Self) -> Self

Returns the component-wise minimum of self and rhs.

pub fn max(self, rhs: Self) -> Self

Returns the component-wise maximum of self and rhs.

pub fn clamp(self, min: Self, max: Self) -> Self

Restricts every component to the interval [min, max].

Panics

Panics if any component of min exceeds the corresponding component of max.

pub fn min_element(self) -> V

Returns the smallest of the three components.

pub fn max_element(self) -> V

Returns the largest of the three components.

pub fn floor(self) -> Self

Returns the component-wise floor.

pub fn ceil(self) -> Self

Returns the component-wise ceiling.

pub fn round(self) -> Self

Returns the component-wise nearest integer, rounding halves away from zero.

pub fn round_ties_even(self) -> Self

Returns the component-wise nearest integer, rounding halves to even.

pub fn trunc(self) -> Self

Returns the component-wise truncation toward zero.

pub fn fract(self) -> Self

Returns the component-wise fractional part.

pub fn copysign(self, sign: Self) -> Self

Returns a vector with the magnitudes of self and the component-wise signs of sign.

pub fn signum(self) -> Self

Returns the component-wise sign, each 1, -1, or NaN.

pub fn rem_euclid(self, rhs: Self) -> Self

Returns the component-wise least nonnegative remainder against rhs.

pub fn is_finite(self) -> bool

Returns true if every component is finite.

pub fn is_infinite(self) -> bool

Returns true if any component is positive or negative infinity.

pub fn is_nan(self) -> bool

Returns true if any component is NaN.

Trait Implementations

impl<T: Add<Output = T>> Add for Vector3<T>

fn add(self, rhs: Self) -> Self

Returns the component-wise sum of self and rhs.

type Output = Vector3<T>

The resulting type after applying the + operator.

impl<T: Add<Output = T>> Add<Vector3<T>> for Point3<T>

fn add(self, rhs: Vector3<T>) -> Self

Translates the point by the displacement rhs.

type Output = Point3<T>

The resulting type after applying the + operator.

impl<T: AddAssign> AddAssign for Vector3<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: AddAssign> AddAssign<Vector3<T>> for Point3<T>

fn add_assign(&mut self, rhs: Vector3<T>)

Performs the += operation.

impl<T: Clone> Clone for Vector3<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Vector3<T>

impl<T: Debug> Debug for Vector3<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Vector3<T>

fn default() -> Self

Returns the zero vector.

impl<T, S: Scalar> Div<S> for Vector3<T>

where T: Div<S, Output = T>,

fn div(self, rhs: S) -> Self

Divides every component by the scalar rhs, preserving the element’s unit.

type Output = Vector3<T>

The resulting type after applying the / operator.

impl<T, S: Scalar> DivAssign<S> for Vector3<T>

where T: DivAssign<S>,

fn div_assign(&mut self, rhs: S)

Performs the /= operation.

impl<T> Index<usize> for Vector3<T>

fn index(&self, index: usize) -> &T

Returns the component at index, where 0, 1, and 2 map to x, y, and z.

Panics

Panics if index is greater than 2.

type Output = T

The returned type after indexing.

impl<T> IndexMut<usize> for Vector3<T>

fn index_mut(&mut self, index: usize) -> &mut T

Returns the component at index, where 0, 1, and 2 map to x, y, and z.

Panics

Panics if index is greater than 2.

impl<T, S: Scalar> Mul<S> for Vector3<T>

where T: Mul<S, Output = T>,

fn mul(self, rhs: S) -> Self

Scales every component by the scalar rhs, preserving the element’s unit.

type Output = Vector3<T>

The resulting type after applying the * operator.

impl<V: Scalar> Mul<Vector3<V>> for Matrix3<V>

fn mul(self, rhs: Vector3<V>) -> Vector3<V>

Applies the matrix to the vector, returning self * rhs.

type Output = Vector3<V>

The resulting type after applying the * operator.

impl<T, S: Scalar> MulAssign<S> for Vector3<T>

where T: MulAssign<S>,

fn mul_assign(&mut self, rhs: S)

Performs the *= operation.

impl<T: Neg<Output = T>> Neg for Vector3<T>

fn neg(self) -> Self

Returns the component-wise negation of self.

type Output = Vector3<T>

The resulting type after applying the - operator.

impl<T: PartialEq> PartialEq for Vector3<T>

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: Sub<Output = T>> Sub for Vector3<T>

fn sub(self, rhs: Self) -> Self

Returns the component-wise difference of self and rhs.

type Output = Vector3<T>

The resulting type after applying the - operator.

impl<T: Sub<Output = T>> Sub<Vector3<T>> for Point3<T>

fn sub(self, rhs: Vector3<T>) -> Self

Translates the point by the negated displacement rhs.

type Output = Point3<T>

The resulting type after applying the - operator.

impl<T: SubAssign> SubAssign for Vector3<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: SubAssign> SubAssign<Vector3<T>> for Point3<T>

fn sub_assign(&mut self, rhs: Vector3<T>)

Performs the -= operation.

impl<T: Add<Output = T> + Default + Copy> Sum for Vector3<T>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, T: Add<Output = T> + Default + Copy> Sum<&'a Vector3<T>> for Vector3<T>

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.