Struct iomath::types::basic_types::TVector3

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

Fields

x: T

y: T

z: T

Implementations

impl<T> TVector3<T> where
    T: Zero<T> + Copy, 

pub fn empty() -> Self

Creates TVector3<type> whose x, y and z equal to zero

use iomath::vectors::Vector3;
 
let vector = Vector3::empty();
assert_eq!(vector, Vector3 { x: 0.0, y: 0.0, z: 0.0 });

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

Creates TVector3<type> with x, y and z

use iomath::vectors::Vector3;
 
let vector = Vector3::new(3.7, -1.3, 0.5);
assert_eq!(vector, Vector3 { x: 3.7, y: -1.3, z: 0.5 });

pub fn from_scalar(scalar: T) -> Self

Creates TVector3<type> whose x, y and z equal to scalar

use iomath::vectors::Vector3;
 
let vector = Vector3::from_scalar(8.2);
assert_eq!(vector, Vector3::new(8.2, 8.2, 8.2));

pub fn from_value_vector(value: T, vector: TVector2<T>) -> Self

Creates TVector3<type> whose x equals to value, y and z equal to TVector2<type>'s x and y

use iomath::vectors::{ Vector3, Vector2 };
 
let vector = Vector3::from_value_vector(-4.2, Vector2::new(7.3, 2.4));
assert_eq!(vector, Vector3::new(-4.2, 7.3, 2.4));

pub fn from_vector_value(vector: TVector2<T>, value: T) -> Self

Creates TVector3<type> whose x and y equal to TVector2<type>'s x and y, z equals to value

use iomath::vectors::{ Vector3, Vector2 };
 
let vector = Vector3::from_vector_value(Vector2::new(7.3, 2.4), -4.2);
assert_eq!(vector, Vector3::new(7.3, 2.4, -4.2));

Trait Implementations

impl<T> Add<T> for TVector3<T> where
    T: Add<Output = T> + Copy, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, scalar: T) -> Self::Output

Performs the + operation.

impl<T> Add<TVector3<T>> for TVector3<T> where
    T: Add<Output = T>, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<T> AddAssign<T> for TVector3<T> where
    T: AddAssign + Copy, 

fn add_assign(&mut self, scalar: T)

Performs the += operation.

impl<T> AddAssign<TVector3<T>> for TVector3<T> where
    T: AddAssign, 

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T> BitAnd<T> for TVector3<T> where
    T: BitAnd<Output = T> + Copy, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, scalar: T) -> Self::Output

Performs the & operation.

impl<T> BitAnd<TVector3<T>> for TVector3<T> where
    T: BitAnd<Output = T>, 

type Output = Self

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T> BitAndAssign<T> for TVector3<T> where
    T: BitAndAssign + Copy, 

fn bitand_assign(&mut self, scalar: T)

Performs the &= operation.

impl<T> BitAndAssign<TVector3<T>> for TVector3<T> where
    T: BitAndAssign, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T> BitOr<T> for TVector3<T> where
    T: BitOr<Output = T> + Copy, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, scalar: T) -> Self::Output

Performs the | operation.

impl<T> BitOr<TVector3<T>> for TVector3<T> where
    T: BitOr<Output = T>, 

type Output = Self

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T> BitOrAssign<T> for TVector3<T> where
    T: BitOrAssign + Copy, 

fn bitor_assign(&mut self, scalar: T)

Performs the |= operation.

impl<T> BitOrAssign<TVector3<T>> for TVector3<T> where
    T: BitOrAssign, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T> BitXor<T> for TVector3<T> where
    T: BitXor<Output = T> + Copy, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, scalar: T) -> Self::Output

Performs the ^ operation.

impl<T> BitXor<TVector3<T>> for TVector3<T> where
    T: BitXor<Output = T>, 

type Output = Self

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T> BitXorAssign<T> for TVector3<T> where
    T: BitXorAssign + Copy, 

fn bitxor_assign(&mut self, scalar: T)

Performs the ^= operation.

impl<T> BitXorAssign<TVector3<T>> for TVector3<T> where
    T: BitXorAssign, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T> Clone for TVector3<T> where
    T: Copy, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Copy for TVector3<T> where
    T: Copy, 

impl<T> Debug for TVector3<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Div<T> for TVector3<T> where
    T: Div<Output = T> + Copy, 

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div<TVector3<T>> for TVector3<T> where
    T: Div<Output = T>, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, other: Self) -> Self::Output

Performs the / operation.

impl<T> DivAssign<T> for TVector3<T> where
    T: DivAssign + Copy, 

fn div_assign(&mut self, scalar: T)

Performs the /= operation.

impl<T> DivAssign<TVector3<T>> for TVector3<T> where
    T: DivAssign, 

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T> From<TQuaternion<T>> for TVector3<T>

fn from(quat: TQuaternion<T>) -> Self

Performs the conversion.

impl<T> From<TVector2<T>> for TVector3<T> where
    T: Zero<T>, 

fn from(vector: TVector2<T>) -> Self

Performs the conversion.

impl<T> From<TVector3<T>> for TVector2<T>

fn from(vector: TVector3<T>) -> Self

Performs the conversion.

impl<T> From<TVector3<T>> for TVector4<T> where
    T: Zero<T>, 

fn from(vector: TVector3<T>) -> Self

Performs the conversion.

impl<T> From<TVector4<T>> for TVector3<T>

fn from(vector: TVector4<T>) -> Self

Performs the conversion.

impl<T> Index<usize> for TVector3<T>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T> IndexMut<usize> for TVector3<T>

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

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

impl<T> Mul<T> for TVector3<T> where
    T: Mul<Output = T> + Copy, 

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<TVector3<T>> for TVector3<T> where
    T: Mul<Output = T>, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self::Output

Performs the * operation.

impl<T> MulAssign<T> for TVector3<T> where
    T: MulAssign + Copy, 

fn mul_assign(&mut self, scalar: T)

Performs the *= operation.

impl<T> MulAssign<TVector3<T>> for TVector3<T> where
    T: MulAssign, 

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T> Neg for TVector3<T> where
    T: Neg<Output = T>, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> PartialEq<TVector3<T>> for TVector3<T> where
    T: PartialEq, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> Rem<T> for TVector3<T> where
    T: Rem<Output = T> + Copy, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, scalar: T) -> Self::Output

Performs the % operation.

impl<T> Rem<TVector3<T>> for TVector3<T> where
    T: Rem<Output = T>, 

type Output = Self

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<T> RemAssign<T> for TVector3<T> where
    T: RemAssign + Copy, 

fn rem_assign(&mut self, scalar: T)

Performs the %= operation.

impl<T> RemAssign<TVector3<T>> for TVector3<T> where
    T: RemAssign, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<T> Shl<T> for TVector3<T> where
    T: Shl<Output = T> + Copy, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, scalar: T) -> Self::Output

Performs the << operation.

impl<T> Shl<TVector3<T>> for TVector3<T> where
    T: Shl<Output = T>, 

type Output = Self

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<T> ShlAssign<T> for TVector3<T> where
    T: ShlAssign + Copy, 

fn shl_assign(&mut self, scalar: T)

Performs the <<= operation.

impl<T> ShlAssign<TVector3<T>> for TVector3<T> where
    T: ShlAssign, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<T> Shr<T> for TVector3<T> where
    T: Shr<Output = T> + Copy, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, scalar: T) -> Self::Output

Performs the >> operation.

impl<T> Shr<TVector3<T>> for TVector3<T> where
    T: Shr<Output = T>, 

type Output = Self

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<T> ShrAssign<T> for TVector3<T> where
    T: ShrAssign + Copy, 

fn shr_assign(&mut self, scalar: T)

Performs the >>= operation.

impl<T> ShrAssign<TVector3<T>> for TVector3<T> where
    T: ShrAssign, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<T> Sub<T> for TVector3<T> where
    T: Sub<Output = T> + Copy, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, scalar: T) -> Self::Output

Performs the - operation.

impl<T> Sub<TVector3<T>> for TVector3<T> where
    T: Sub<Output = T>, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<T> SubAssign<T> for TVector3<T> where
    T: SubAssign + Copy, 

fn sub_assign(&mut self, scalar: T)

Performs the -= operation.

impl<T> SubAssign<TVector3<T>> for TVector3<T> where
    T: SubAssign, 

fn sub_assign(&mut self, other: Self)

Performs the -= operation.