Struct rgx::math::algebra::Vector3D

#[repr(C)]
pub struct Vector3D<S = f32, U = ()> {
    pub x: S,
    pub y: S,
    pub z: S,
    /* private fields */
}

3D vector.

Fields

x: S

y: S

z: S

Implementations

impl<S, U> Vector3D<S, U>

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

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

Extend vector to four dimensions.

Trait Implementations

impl<S, U> Add<Vector3D<S, U>> for Vector3D<S, U>where S: Add<Output = S> + Copy,

type Output = Vector3D<S, U>

The resulting type after applying the + operator.

fn add(self, other: Vector3D<S, U>) -> Self

Performs the + operation.

impl<S: Clone, U: Clone> Clone for Vector3D<S, U>

fn clone(&self) -> Vector3D<S, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug, U: Debug> Debug for Vector3D<S, U>

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

Formats the value using the given formatter.

impl<T: Copy> From<[T; 3]> for Vector3D<T>

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

Converts to this type from the input type.

impl<S: Zero, U: Copy> From<Vector2D<S, U>> for Vector3D<S, U>

fn from(other: Vector2D<S, U>) -> Self

Converts to this type from the input type.

impl<S, U: Copy> From<Vector3D<S, U>> for Vector2D<S, U>

fn from(other: Vector3D<S, U>) -> Self

Converts to this type from the input type.

impl From<Vector3D<f32, ()>> for Vector4D<f32>

fn from(other: Vector3D<f32>) -> Self

Converts to this type from the input type.

impl<S: Hash, U: Hash> Hash for Vector3D<S, U>

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 Mul<Vector3D<f32, ()>> for Transform3D<f32>

Transform a Vector3D with a Transform3D.

use rgx::math::*;
let m = Transform3D::from_translation(Vector3D::new(8., 8., 0.));
let v = Vector3D::new(1., 1., 0.);

assert_eq!(m * v, Vector3D::new(9., 9., 0.));

type Output = Vector3D<f32, ()>

The resulting type after applying the * operator.

fn mul(self, vec: Vector3D<f32>) -> Vector3D<f32>

Performs the * operation.

impl<S: PartialEq, U: PartialEq> PartialEq<Vector3D<S, U>> for Vector3D<S, U>

fn eq(&self, other: &Vector3D<S, U>) -> 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: Copy, U: Copy> Copy for Vector3D<S, U>

impl<S: Eq, U: Eq> Eq for Vector3D<S, U>

impl<S, U> StructuralEq for Vector3D<S, U>

impl<S, U> StructuralPartialEq for Vector3D<S, U>