Struct citro3d::math::FVec

pub struct FVec<const N: usize>(/* private fields */);

A vector of f32s.

Layout

Note that this matches the PICA layout so is actually WZYX, this means using it in vertex data as an attribute it will be reversed

It is guaranteed to have the same layout as citro3d_sys::C3D_FVec in memory

Implementations

impl<const N: usize> FVec<N>

pub fn x(self) -> f32

The vector’s x component (also called the i component of ijk[r]).

pub fn y(self) -> f32

The vector’s y component (also called the j component of ijk[r]).

pub fn z(self) -> f32

The vector’s i component (also called the k component of ijk[r]).

impl FVec<4>

pub fn w(self) -> f32

The vector’s w component (also called r for the real component of ijk[r]).

pub fn from_raw(raw: C3D_FVec) -> Self

Wrap a raw citro3d_sys::C3D_FVec

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

Create a new FVec4 from its components.

Example

let v = FVec4::new(1.0, 2.0, 3.0, 4.0);

pub fn splat(v: f32) -> Self

Create a new FVec4, setting each component to v.

Example

let v = FVec4::splat(1.0);
assert_abs_diff_eq!(v, FVec4::new(1.0, 1.0, 1.0, 1.0));

pub fn perspective_divide(self) -> Self

Divide the vector’s XYZ components by its W component.

Example

let v = FVec4::new(2.0, 4.0, 6.0, 2.0);
assert_abs_diff_eq!(v.perspective_divide(), FVec4::new(1.0, 2.0, 3.0, 1.0));

pub fn dot(self, rhs: Self) -> f32

The dot product of two vectors.

Example

let v1 = FVec4::new(1.0, 2.0, 3.0, 4.0);
let v2 = FVec4::new(1.0, 0.5, 1.0, 0.5);
assert_abs_diff_eq!(v1.dot(v2), 7.0);

pub fn magnitude(self) -> f32

The magnitude of the vector.

Example

let v = FVec4::splat(1.0);
assert_abs_diff_eq!(v.magnitude(), 2.0);

pub fn normalize(self) -> Self

Normalize the vector to a magnitude of 1.0.

Example

let v = FVec4::new(1.0, 2.0, 2.0, 4.0);
assert_abs_diff_eq!(v.normalize(), FVec4::new(0.2, 0.4, 0.4, 0.8));

impl FVec<3>

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

Create a new FVec3 from its components.

Example

let v = FVec3::new(1.0, 2.0, 3.0);

pub fn splat(v: f32) -> Self

Create a new FVec3, setting each component to the given v.

Example

let v = FVec3::splat(1.0);

pub fn distance(self, rhs: Self) -> f32

The distance between two points in 3D space.

Example

let l = FVec3::new(1.0, 3.0, 4.0);
let r = FVec3::new(0.0, 1.0, 2.0);

assert_abs_diff_eq!(l.distance(r), 3.0);

pub fn cross(self, rhs: Self) -> Self

The cross product of two 3D vectors.

Example

let l = FVec3::new(1.0, 0.0, 0.0);
let r = FVec3::new(0.0, 1.0, 0.0);
assert_abs_diff_eq!(l.cross(r), FVec3::new(0.0, 0.0, 1.0));

pub fn dot(self, rhs: Self) -> f32

The dot product of two vectors.

Example

let l = FVec3::new(1.0, 2.0, 3.0);
let r = FVec3::new(3.0, 2.0, 1.0);
assert_abs_diff_eq!(l.dot(r), 10.0);

pub fn magnitude(self) -> f32

The magnitude of the vector.

Example

let v = FVec3::splat(3.0f32.sqrt());
assert_abs_diff_eq!(v.magnitude(), 3.0);

pub fn normalize(self) -> Self

Normalize the vector to a magnitude of 1.0.

Example

let v = FVec3::splat(1.0);
assert_abs_diff_eq!(v.normalize(), FVec3::splat(1.0 / 3.0_f32.sqrt()));

Trait Implementations

impl<const N: usize> Clone for FVec<N>

fn clone(&self) -> FVec<N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for FVec<N>

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

Formats the value using the given formatter.

impl<const N: usize> Div<f32> for FVec<N>

where FVec<N>: Mul<f32>,

type Output = <FVec<N> as Mul<f32>>::Output

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl From<FVec<3>> for Vec3

Available on crate feature glam only.

fn from(value: FVec3) -> Self

Converts to this type from the input type.

impl From<FVec<4>> for Uniform

fn from(value: FVec4) -> Self

Converts to this type from the input type.

impl From<FVec<4>> for Vec4

Available on crate feature glam only.

fn from(value: FVec4) -> Self

Converts to this type from the input type.

impl Mul<FVec<3>> for &Matrix4

type Output = FVec<4>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<FVec<4>> for &Matrix4

type Output = FVec<4>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: usize> PartialEq for FVec<N>

fn eq(&self, other: &Self) -> 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<const N: usize> Copy for FVec<N>

impl<const N: usize> Eq for FVec<N>