Struct cgmath::Vector3 [−] [src]

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

Fields

`x`
`y`
`z`

Methods

`impl<S> Vector3<S>`

`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>`

`fn neg_self(&mut self)`

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

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

`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.

`fn unit_x() -> Vector3<S>`

A unit vector in the x direction.

`fn unit_y() -> Vector3<S>`

A unit vector in the y direction.

`fn unit_z() -> Vector3<S>`

A unit vector in the w direction.

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

Returns the cross product of the vector and other.

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

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

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

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

`fn truncate(&self) -> Vector2<S>`

Create a Vector2, dropping the z value.

Trait Implementations

`impl<S: Zero + BaseNum> Zero for Vector3<S>`

`fn zero() -> Vector3<S>`

`fn is_zero(&self) -> bool`

`impl<S: One + BaseNum> One for Vector3<S>`

`fn one() -> Vector3<S>`

`impl<S> FixedArray<[S; 3]> for Vector3<S>`

`fn into_fixed(self) -> [S; 3]`

`fn as_fixed<'a>(&'a self) -> &'a [S; 3]`

`fn as_mut_fixed<'a>(&'a mut self) -> &'a mut [S; 3]`

`fn from_fixed(_v: [S; 3]) -> Vector3<S>`

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

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

`impl<S: Copy> Index<usize> for Vector3<S>`

`type Output = S`

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

`impl<S: Copy> IndexMut<usize> for Vector3<S>`

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

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

`fn map<F>(&mut self, op: F) -> Vector3<S> where F: FnMut(S) -> S`

`fn ptr<'a>(&'a self) -> &'a Element`

`fn mut_ptr<'a>(&'a mut self) -> &'a mut Element`

`fn swap_elems(&mut self, i: usize, j: usize)`

`fn replace_elem(&mut self, i: usize, src: Element) -> Element`

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

`fn from_value(s: S) -> Vector3<S>`

`fn add_s(&self, s: S) -> Vector3<S>`

`fn sub_s(&self, s: S) -> Vector3<S>`

`fn mul_s(&self, s: S) -> Vector3<S>`

`fn div_s(&self, s: S) -> Vector3<S>`

`fn rem_s(&self, s: S) -> Vector3<S>`

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

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

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

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

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

`fn add_self_s(&mut self, s: S)`

`fn sub_self_s(&mut self, s: S)`

`fn mul_self_s(&mut self, s: S)`

`fn div_self_s(&mut self, s: S)`

`fn rem_self_s(&mut self, s: S)`

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

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

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

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

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

`fn comp_add(&self) -> S`

`fn comp_mul(&self) -> S`

`fn comp_min(&self) -> S`

`fn comp_max(&self) -> S`

`fn dot(&self, v: &Self) -> S`

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

`type Output = Vector3<S>`

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

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

`type Output = Vector3<S>`

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

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

`type Output = Vector3<S>`

`fn neg(self) -> Vector3<S>`

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

`type Output = Vector3<S>`

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

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

`type Output = Vector3<S>`

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

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

`type Output = Vector3<S>`

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

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

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

`fn approx_epsilon(_hack: Option<Self>) -> T`

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

`impl<S: BaseFloat + Rand> Rand for Vector3<S>`

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

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

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

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

`fn length2(&self) -> S`

`fn length(&self) -> S`

`fn normalize(&self) -> Self`

`fn normalize_to(&self, length: S) -> Self`

`fn lerp(&self, other: &Self, amount: S) -> Self`

`fn normalize_self(&mut self)`

`fn normalize_self_to(&mut self, length: S)`

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

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

`fn fmt(&self, f: &mut Formatter) -> Result`

Derived Implementations

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

`fn decode<D: Decoder>(arg_0: &mut D) -> Result<Vector3<S>, D::Error>`

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

`fn encode<S: Encoder>(&self, arg_0: &mut S) -> Result<(), S::Error>`

`impl<S: Hash> Hash for Vector3<S>`

`fn hash<H: Hasher>(&self, arg_0: &mut __H)`

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher`

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

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

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

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

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

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

`fn eq(&self, __arg_0: &Vector3<S>) -> bool`

`fn ne(&self, __arg_0: &Vector3<S>) -> bool`