Struct cgmath::Vector3

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

Fields

x: S

y: S

z: S

Implementations

impl<S> Vector3<S>

pub fn new(x: S, y: S, z: S) -> Vector3<S>

Construct a new vector, using the provided values.

impl<S: Copy + Neg<Output = S>> Vector3<S>

pub fn neg_self(&mut self)

Negate this vector in-place (multiply by -1).

impl<S: NumCast + Copy> Vector3<S>

pub fn cast<T: NumCast>(&self) -> Vector3<T>

Component-wise casting to another type

impl<S: BaseNum> Vector3<S>

Operations specific to numeric three-dimensional vectors.

pub fn unit_x() -> Vector3<S>

A unit vector in the x direction.

pub fn unit_y() -> Vector3<S>

A unit vector in the y direction.

pub fn unit_z() -> Vector3<S>

A unit vector in the w direction.

pub fn cross(self, other: Vector3<S>) -> Vector3<S>

Returns the cross product of the vector and other.

pub fn cross_self(&mut self, other: Vector3<S>)

Calculates the cross product of the vector and other, then stores the result in self.

pub fn extend(self, w: S) -> Vector4<S>

Create a Vector4, using the x, y and z values from this vector, and the provided w.

pub fn truncate(self) -> Vector2<S>

Create a Vector2, dropping the z value.

Trait Implementations

impl<'a, 'b, S: BaseNum> Add<&'a Vector3<S>> for &'b Point3<S>

type Output = Point3<S>

The resulting type after applying the + operator.

fn add(self, v: &'a Vector3<S>) -> Point3<S>

Performs the + operation.

impl<'a, 'b, S: BaseNum> Add<&'a Vector3<S>> for &'b Vector3<S>

type Output = Vector3<S>

The resulting type after applying the + operator.

fn add(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<&'a Vector3<S>> for Point3<S>

type Output = Point3<S>

The resulting type after applying the + operator.

fn add(self, v: &'a Vector3<S>) -> Point3<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<&'a Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the + operator.

fn add(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<S> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the + operator.

fn add(self, scalar: S) -> Vector3<S>

Performs the + operation.

impl<S: BaseNum> Add<S> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the + operator.

fn add(self, scalar: S) -> Vector3<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<Vector3<S>> for &'a Point3<S>

type Output = Point3<S>

The resulting type after applying the + operator.

fn add(self, v: Vector3<S>) -> Point3<S>

Performs the + operation.

impl<'a, S: BaseNum> Add<Vector3<S>> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the + operator.

fn add(self, other: Vector3<S>) -> Vector3<S>

Performs the + operation.

impl<S: BaseNum> Add<Vector3<S>> for Point3<S>

type Output = Point3<S>

The resulting type after applying the + operator.

fn add(self, v: Vector3<S>) -> Point3<S>

Performs the + operation.

impl<S: BaseNum> Add<Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the + operator.

fn add(self, other: Vector3<S>) -> Vector3<S>

Performs the + operation.

impl<S: BaseFloat> ApproxEq for Vector3<S>

type Epsilon = S

fn approx_eq_eps(&self, other: &Vector3<S>, epsilon: &S) -> bool

fn approx_epsilon() -> Self::Epsilon

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

impl<S: Copy> Array for Vector3<S>

type Element = S

fn sum(self) -> Swhere S: Add<Output = S>,

The sum of the elements of the array.

fn product(self) -> Swhere S: Mul<Output = S>,

The product of the elements of the array.

fn min(self) -> Swhere S: PartialOrd,

The minimum element of the array.

fn max(self) -> Swhere S: PartialOrd,

The maximum element of the array.

fn as_ptr(&self) -> *const Self::Element

Get the pointer to the first element of the array.

fn as_mut_ptr(&mut self) -> *mut Self::Element

Get a mutable pointer to the first element of the array.

fn swap_elements(&mut self, i: usize, j: usize)

Swap the elements at indices i and j in-place.

impl<S> AsMut<[S; 3]> for Vector3<S>

fn as_mut(&mut self) -> &mut [S; 3]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S> AsMut<(S, S, S)> for Vector3<S>

fn as_mut(&mut self) -> &mut (S, S, S)

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S> AsRef<[S; 3]> for Vector3<S>

fn as_ref(&self) -> &[S; 3]

Converts this type into a shared reference of the (usually inferred) input type.

impl<S> AsRef<(S, S, S)> for Vector3<S>

fn as_ref(&self) -> &(S, S, S)

Converts this type into a shared reference of the (usually inferred) input type.

impl<S: Clone> Clone for Vector3<S>

fn clone(&self) -> Vector3<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: BaseNum> Debug for Vector3<S>

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

Formats the value using the given formatter.

impl<S: Decodable> Decodable for Vector3<S>

fn decode<__D: Decoder>(d: &mut __D) -> Result<Vector3<S>, __D::Error>

Deserialize a value using a Decoder.

impl<'a, 'b, S: BaseNum> Div<&'a Vector3<S>> for &'b Vector3<S>

type Output = Vector3<S>

The resulting type after applying the / operator.

fn div(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the / operation.

impl<'a, S: BaseNum> Div<&'a Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the / operator.

fn div(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the / operation.

impl<'a, S: BaseNum> Div<S> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the / operator.

fn div(self, scalar: S) -> Vector3<S>

Performs the / operation.

impl<S: BaseNum> Div<S> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the / operator.

fn div(self, scalar: S) -> Vector3<S>

Performs the / operation.

impl<'a, S: BaseNum> Div<Vector3<S>> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the / operator.

fn div(self, other: Vector3<S>) -> Vector3<S>

Performs the / operation.

impl<S: BaseNum> Div<Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the / operator.

fn div(self, other: Vector3<S>) -> Vector3<S>

Performs the / operation.

impl<S: Encodable> Encodable for Vector3<S>

fn encode<__S: Encoder>(&self, s: &mut __S) -> Result<(), __S::Error>

Serialize a value using an Encoder.

impl<S: BaseFloat> EuclideanVector for Vector3<S>

fn angle(self, other: Vector3<S>) -> Rad<S>

The angle between the vector and other, in radians.

fn is_perpendicular(self, other: Self) -> bool

Returns true if the vector is perpendicular (at right angles) to the other vector.

fn length2(self) -> Self::Scalar

Returns the squared length of the vector. This does not perform an expensive square root operation like in the length method and can therefore be more efficient for comparing the lengths of two vectors.

fn length(self) -> Self::Scalar

The norm of the vector.

fn normalize(self) -> Self

Returns a vector with the same direction, but with a length (or norm) of 1.

fn normalize_to(self, length: Self::Scalar) -> Self

Returns a vector with the same direction and a given length.

fn lerp(self, other: Self, amount: Self::Scalar) -> Self

Returns the result of linarly interpolating the length of the vector towards the length of other by the specified amount.

fn normalize_self(&mut self)

Normalises the vector to a length of 1.

fn normalize_self_to(&mut self, length: Self::Scalar)

Normalizes the vector to length.

fn lerp_self(&mut self, other: Self, amount: Self::Scalar)

Linearly interpolates the length of the vector towards the length of other by the specified amount.

impl<'a, S> From<&'a [S; 3]> for &'a Vector3<S>

fn from(v: &'a [S; 3]) -> &'a Vector3<S>

Converts to this type from the input type.

impl<'a, S> From<&'a (S, S, S)> for &'a Vector3<S>

fn from(v: &'a (S, S, S)) -> &'a Vector3<S>

Converts to this type from the input type.

impl<'a, S> From<&'a mut [S; 3]> for &'a mut Vector3<S>

fn from(v: &'a mut [S; 3]) -> &'a mut Vector3<S>

Converts to this type from the input type.

impl<'a, S> From<&'a mut (S, S, S)> for &'a mut Vector3<S>

fn from(v: &'a mut (S, S, S)) -> &'a mut Vector3<S>

Converts to this type from the input type.

impl<S: Clone> From<[S; 3]> for Vector3<S>

fn from(v: [S; 3]) -> Vector3<S>

Converts to this type from the input type.

impl<S> From<(S, S, S)> for Vector3<S>

fn from(v: (S, S, S)) -> Vector3<S>

Converts to this type from the input type.

impl<S: Hash> Hash for Vector3<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<S> Index<Range<usize>> for Vector3<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: Range<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<RangeFrom<usize>> for Vector3<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: RangeFrom<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<RangeFull> for Vector3<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: RangeFull) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<RangeTo<usize>> for Vector3<S>

type Output = [S]

The returned type after indexing.

fn index<'a>(&'a self, i: RangeTo<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<usize> for Vector3<S>

type Output = S

The returned type after indexing.

fn index<'a>(&'a self, i: usize) -> &'a S

Performs the indexing (container[index]) operation.

impl<S> IndexMut<Range<usize>> for Vector3<S>

fn index_mut<'a>(&'a mut self, i: Range<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<RangeFrom<usize>> for Vector3<S>

fn index_mut<'a>(&'a mut self, i: RangeFrom<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<RangeFull> for Vector3<S>

fn index_mut<'a>(&'a mut self, i: RangeFull) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<RangeTo<usize>> for Vector3<S>

fn index_mut<'a>(&'a mut self, i: RangeTo<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<usize> for Vector3<S>

fn index_mut<'a>(&'a mut self, i: usize) -> &'a mut S

Performs the mutable indexing (container[index]) operation.

impl<S> Into<[S; 3]> for Vector3<S>

fn into(self) -> [S; 3]

Converts this type into the (usually inferred) input type.

impl<S> Into<(S, S, S)> for Vector3<S>

fn into(self) -> (S, S, S)

Converts this type into the (usually inferred) input type.

impl<'a, 'b, S: BaseFloat> Mul<&'a Vector3<S>> for &'b Matrix3<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, v: &'a Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<'a, 'b, S: BaseNum> Mul<&'a Vector3<S>> for &'b Vector3<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<'a, S: BaseNum> Mul<&'a Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<'a, 'b, S: BaseFloat> Mul<&'b Vector3<S>> for &'a Quaternion<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, vec: &'b Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<'a, S: BaseNum> Mul<S> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, scalar: S) -> Vector3<S>

Performs the * operation.

impl<S: BaseNum> Mul<S> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, scalar: S) -> Vector3<S>

Performs the * operation.

impl<'a, S: BaseFloat> Mul<Vector3<S>> for &'a Matrix3<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, v: Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<'a, S: BaseNum> Mul<Vector3<S>> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, other: Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<S: BaseNum> Mul<Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, other: Vector3<S>) -> Vector3<S>

Performs the * operation.

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

type Output = Vector3<S>

The resulting type after applying the - operator.

fn neg(self) -> Vector3<S>

Performs the unary - operation.

impl<S: PartialEq> PartialEq<Vector3<S>> for Vector3<S>

fn eq(&self, other: &Vector3<S>) -> 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<S: BaseFloat + Rand> Rand for Vector3<S>

fn rand<R: Rng>(rng: &mut R) -> Vector3<S>

Generates a random instance of this type using the specified source of randomness.

impl<'a, 'b, S: BaseNum> Rem<&'a Vector3<S>> for &'b Vector3<S>

type Output = Vector3<S>

The resulting type after applying the % operator.

fn rem(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the % operation.

impl<'a, S: BaseNum> Rem<&'a Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the % operator.

fn rem(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the % operation.

impl<'a, S: BaseNum> Rem<S> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the % operator.

fn rem(self, scalar: S) -> Vector3<S>

Performs the % operation.

impl<S: BaseNum> Rem<S> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the % operator.

fn rem(self, scalar: S) -> Vector3<S>

Performs the % operation.

impl<'a, S: BaseNum> Rem<Vector3<S>> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the % operator.

fn rem(self, other: Vector3<S>) -> Vector3<S>

Performs the % operation.

impl<S: BaseNum> Rem<Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the % operator.

fn rem(self, other: Vector3<S>) -> Vector3<S>

Performs the % operation.

impl<'a, 'b, S: BaseNum> Sub<&'a Vector3<S>> for &'b Vector3<S>

type Output = Vector3<S>

The resulting type after applying the - operator.

fn sub(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the - operation.

impl<'a, S: BaseNum> Sub<&'a Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the - operator.

fn sub(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the - operation.

impl<'a, S: BaseNum> Sub<S> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the - operator.

fn sub(self, scalar: S) -> Vector3<S>

Performs the - operation.

impl<S: BaseNum> Sub<S> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the - operator.

fn sub(self, scalar: S) -> Vector3<S>

Performs the - operation.

impl<'a, S: BaseNum> Sub<Vector3<S>> for &'a Vector3<S>

type Output = Vector3<S>

The resulting type after applying the - operator.

fn sub(self, other: Vector3<S>) -> Vector3<S>

Performs the - operation.

impl<S: BaseNum> Sub<Vector3<S>> for Vector3<S>

type Output = Vector3<S>

The resulting type after applying the - operator.

fn sub(self, other: Vector3<S>) -> Vector3<S>

Performs the - operation.

impl<S: BaseNum> Vector for Vector3<S>

type Scalar = S

The associated scalar.

fn from_value(scalar: S) -> Vector3<S>

Construct a vector from a single value, replicating it.

fn add_s(self, scalar: S) -> Vector3<S>

Add a scalar to this vector, returning a new vector.

fn sub_s(self, scalar: S) -> Vector3<S>

Subtract a scalar from this vector, returning a new vector.

fn mul_s(self, scalar: S) -> Vector3<S>

Multiply this vector by a scalar, returning a new vector.

fn div_s(self, scalar: S) -> Vector3<S>

Divide this vector by a scalar, returning a new vector.

fn rem_s(self, scalar: S) -> Vector3<S>

Take the remainder of this vector by a scalar, returning a new vector.

fn add_v(self, v: Vector3<S>) -> Vector3<S>

Add this vector to another, returning a new vector.

fn sub_v(self, v: Vector3<S>) -> Vector3<S>

Subtract another vector from this one, returning a new vector.

fn mul_v(self, v: Vector3<S>) -> Vector3<S>

Multiply this vector by another, returning a new vector.

fn div_v(self, v: Vector3<S>) -> Vector3<S>

Divide this vector by another, returning a new vector.

fn rem_v(self, v: Vector3<S>) -> Vector3<S>

Take the remainder of this vector by another, returning a new scalar.

fn add_self_s(&mut self, scalar: S)

Add a scalar to this vector in-place.

fn sub_self_s(&mut self, scalar: S)

Subtract a scalar from this vector, in-place.

fn mul_self_s(&mut self, scalar: S)

Multiply this vector by a scalar, in-place.

fn div_self_s(&mut self, scalar: S)

Divide this vector by a scalar, in-place.

fn rem_self_s(&mut self, scalar: S)

Take the remainder of this vector by a scalar, in-place.

fn add_self_v(&mut self, v: Vector3<S>)

Add another vector to this one, in-place.

fn sub_self_v(&mut self, v: Vector3<S>)

Subtract another vector from this one, in-place.

fn mul_self_v(&mut self, v: Vector3<S>)

Multiply this matrix by another, in-place.

fn div_self_v(&mut self, v: Vector3<S>)

Divide this matrix by anothor, in-place.

fn rem_self_v(&mut self, v: Vector3<S>)

Take the remainder of this vector by another, in-place.

fn dot(self, other: Vector3<S>) -> S

Vector dot product

fn zero() -> Self

The zero vector (with all components set to zero)

fn one() -> Self

The identity vector (with all components set to one)

impl<S: Copy> Copy for Vector3<S>

impl<S: Eq> Eq for Vector3<S>

impl<S> StructuralEq for Vector3<S>

impl<S> StructuralPartialEq for Vector3<S>