Struct micromath::vector::Vector3d

pub struct Vector3d<C: Component> {
    pub x: C,
    pub y: C,
    pub z: C,
}

Available on crate feature vector only.

3-dimensional vector

Fields

x: C

X component

y: C

Y component

z: C

Z component

Implementations

impl<C> Vector3d<C>where C: Component,

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

Return a 3-element array containing the coordinates

Trait Implementations

impl<C> Add for Vector3d<C>where C: Component,

type Output = Vector3d<C>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<C> AddAssign for Vector3d<C>where C: Component,

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<C: Clone + Component> Clone for Vector3d<C>

fn clone(&self) -> Vector3d<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug + Component> Debug for Vector3d<C>

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

Formats the value using the given formatter.

impl<C: Default + Component> Default for Vector3d<C>

fn default() -> Vector3d<C>

Returns the “default value” for a type.

impl<C> From<(C, C, C)> for Vector3d<C>where C: Component,

fn from(vector: (C, C, C)) -> Self

Converts to this type from the input type.

impl<C> From<Vector3d<C>> for Quaternionwhere C: Component + Into<f32>,

fn from(v: Vector3d<C>) -> Quaternion

Converts to this type from the input type.

impl From<Vector3d<F32>> for F32x3

fn from(vector: Vector3d<F32>) -> F32x3

Converts to this type from the input type.

impl From<Vector3d<i16>> for F32x3

fn from(vector: I16x3) -> F32x3

Converts to this type from the input type.

impl From<Vector3d<i8>> for F32x3

fn from(vector: I8x3) -> F32x3

Converts to this type from the input type.

impl From<Vector3d<u16>> for F32x3

fn from(vector: U16x3) -> F32x3

Converts to this type from the input type.

impl From<Vector3d<u8>> for F32x3

fn from(vector: U8x3) -> F32x3

Converts to this type from the input type.

impl<C> FromIterator<C> for Vector3d<C>where C: Component,

fn from_iter<T>(into_iter: T) -> Selfwhere T: IntoIterator<Item = C>,

Creates a value from an iterator.

impl<C> Index<usize> for Vector3d<C>where C: Component,

type Output = C

The returned type after indexing.

fn index(&self, i: usize) -> &C

Performs the indexing (container[index]) operation.

impl<C> Mul<C> for Vector3d<C>where C: Component,

Multiply vector by a scalar component

type Output = Vector3d<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> Mul<Vector3d<C>> for Quaternionwhere C: Component + Into<f32>,

type Output = Vector3d<f32>

The resulting type after applying the * operator.

fn mul(self, v: Vector3d<C>) -> F32x3

Performs the * operation.

impl<C> Mul for Vector3d<C>where C: Component,

Compute the cross product of two vectors

type Output = Vector3d<C>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<C> MulAssign<C> for Vector3d<C>where C: Component,

fn mul_assign(&mut self, rhs: C)

Performs the *= operation.

impl<C: PartialEq + Component> PartialEq for Vector3d<C>

fn eq(&self, other: &Vector3d<C>) -> 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<C> Sub for Vector3d<C>where C: Component,

type Output = Vector3d<C>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<C> SubAssign for Vector3d<C>where C: Component,

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<C> Vector<C> for Vector3d<C>where C: Component,

const AXES: usize = 3usize

Number of axes

fn get(self, index: usize) -> Option<C>

Get the component value for a particular index

fn dot(self, rhs: Self) -> C

Compute the dot product of two vectors

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

Instantiate a vector from a slice of components.

fn iter(&self) -> Iter<'_, Self, C>

Iterate over the components of this vector

impl<C: Copy + Component> Copy for Vector3d<C>

impl<C: Component> StructuralPartialEq for Vector3d<C>