Struct glam::f32::Vec3A

#[repr(C)]pub struct Vec3A(_);

A 3-dimensional vector with SIMD support.

This type uses 16 byte aligned SIMD vector4 types for storage on supported platforms for better performance than the Vec3 type.

It is possible to convert between Vec3 and Vec3A types using From trait implementations.

Implementations

impl Vec3A

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

Creates a new Vec3A.

pub fn zero() -> Self

Creates a new Vec3A with all elements set to 0.0.

pub fn one() -> Self

Creates a new Vec3A with all elements set to 1.0.

pub fn unit_x() -> Self

Creates a new Vec3A with values [x: 1.0, y: 0.0, z: 0.0].

pub fn unit_y() -> Self

Creates a new Vec3A with values [x: 0.0, y: 1.0, z: 0.0].

pub fn unit_z() -> Self

Creates a new Vec3A with values [x: 0.0, y: 0.0, z: 1.0].

pub fn splat(v: f32) -> Self

Creates a new Vec3A with all elements set to v.

pub fn extend(self, w: f32) -> Vec4

Creates a new Vec4 from self and the given w value.

pub fn truncate(self) -> Vec2

Creates a Vec2 from the first three elements of self, removing z.

pub fn x(self) -> f32

Returns element x.

pub fn y(self) -> f32

Returns element y.

pub fn z(self) -> f32

Returns element z.

pub fn x_mut(&mut self) -> &mut f32

Returns a mutable reference to element x.

pub fn y_mut(&mut self) -> &mut f32

Returns a mutable reference to element y.

pub fn z_mut(&mut self) -> &mut f32

Returns a mutable reference to element z.

pub fn set_x(&mut self, x: f32)

Sets element x.

pub fn set_y(&mut self, y: f32)

Sets element y.

pub fn set_z(&mut self, z: f32)

Sets element z.

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

Computes the dot product of self and other.

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

Computes the cross product of self and other.

pub fn length(self) -> f32

Computes the length of self.

pub fn length_squared(self) -> f32

Computes the squared length of self.

This is generally faster than Vec3A::length() as it avoids a square root operation.

pub fn length_reciprocal(self) -> f32

Computes 1.0 / Vec3A::length().

For valid results, self must not be of length zero.

pub fn normalize(self) -> Self

Returns self normalized to length 1.0.

For valid results, self must not be of length zero.

pub fn min(self, other: Self) -> Self

Returns the vertical minimum of self and other.

In other words, this computes [x: min(x1, x2), y: min(y1, y2), z: min(z1, z2)], taking the minimum of each element individually.

pub fn max(self, other: Self) -> Self

Returns the vertical maximum of self and other.

In other words, this computes [x: max(x1, x2), y: max(y1, y2), z: max(z1, z2)], taking the maximum of each element individually.

pub fn min_element(self) -> f32

Returns the horizontal minimum of self's elements.

In other words, this computes min(x, y, z).

pub fn max_element(self) -> f32

Returns the horizontal maximum of self's elements.

In other words, this computes max(x, y, z).

pub fn cmpeq(self, other: Self) -> Vec3AMask

Performs a vertical == comparison between self and other, returning a Vec3AMask of the results.

In other words, this computes [x1 == x2, y1 == y2, z1 == z2, w1 == w2].

pub fn cmpne(self, other: Self) -> Vec3AMask

Performs a vertical != comparison between self and other, returning a Vec3AMask of the results.

In other words, this computes [x1 != x2, y1 != y2, z1 != z2, w1 != w2].

pub fn cmpge(self, other: Self) -> Vec3AMask

Performs a vertical >= comparison between self and other, returning a Vec3AMask of the results.

In other words, this computes [x1 >= x2, y1 >= y2, z1 >= z2, w1 >= w2].

pub fn cmpgt(self, other: Self) -> Vec3AMask

Performs a vertical > comparison between self and other, returning a Vec3AMask of the results.

In other words, this computes [x1 > x2, y1 > y2, z1 > z2, w1 > w2].

pub fn cmple(self, other: Self) -> Vec3AMask

Performs a vertical <= comparison between self and other, returning a Vec3AMask of the results.

In other words, this computes [x1 <= x2, y1 <= y2, z1 <= z2, w1 <= w2].

pub fn cmplt(self, other: Self) -> Vec3AMask

Performs a vertical < comparison between self and other, returning a Vec3AMask of the results.

In other words, this computes [x1 < x2, y1 < y2, z1 < z2, w1 < w2].

pub fn from_slice_unaligned(slice: &[f32]) -> Self

Creates a new Vec3A from the first four values in slice.

Panics

Panics if slice is less than three elements long.

pub fn write_to_slice_unaligned(self, slice: &mut [f32])

Writes the elements of self to the first three elements in slice.

Panics

Panics if slice is less than three elements long.

pub fn abs(self) -> Self

Returns a new Vec3A containing the absolute value of each element of the original Vec3A.

pub fn round(self) -> Self

pub fn floor(self) -> Self

pub fn ceil(self) -> Self

pub fn sign(self) -> Self

Returns a new Vec4 with elements representing the sign of self.

• 1.0 if the number is positive, +0.0 or INFINITY
• -1.0 if the number is negative, -0.0 or NEG_INFINITY

pub fn reciprocal(self) -> Self

Computes the reciprocal 1.0/n of each element, returning the results in a new Vec3A.

pub fn lerp(self, other: Self, s: f32) -> Self

Performs a linear interpolation between self and other based on the value s.

When s is 0.0, the result will be equal to self. When s is 1.0, the result will be equal to other.

pub fn is_normalized(self) -> bool

Returns whether self of length 1.0 or not.

Uses a precision threshold of 1e-6.

pub fn abs_diff_eq(self, other: Self, max_abs_diff: f32) -> bool

Returns true if the absolute difference of all elements between self and other is less than or equal to max_abs_diff.

This can be used to compare if two Vec3A's contain similar elements. It works best when comparing with a known value. The max_abs_diff that should be used used depends on the values being compared against.

For more on floating point comparisons see https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/

pub fn angle_between(self, other: Self) -> f32

Returns the angle between two vectors, in radians.

The vectors do not need to be unit length, but this function does perform a sqrt.

Trait Implementations

impl Add<Vec3A> for Vec3A

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Vec3A> for Vec3A

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl AsMut<[f32; 3]> for Vec3A

fn as_mut(&mut self) -> &mut [f32; 3]

Performs the conversion.

impl AsRef<[f32; 3]> for Vec3A

fn as_ref(&self) -> &[f32; 3]

Performs the conversion.

impl Clone for Vec3A

fn clone(&self) -> Vec3A

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Vec3A

impl Debug for Vec3A

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

Formats the value using the given formatter.

impl Default for Vec3A

fn default() -> Self

Returns the "default value" for a type.

impl Display for Vec3A

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

Formats the value using the given formatter.

impl Div<Vec3A> for Vec3A

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Vec3A> for f32

type Output = Vec3A

The resulting type after applying the / operator.

fn div(self, other: Vec3A) -> Vec3A

Performs the / operation.

impl Div<f32> for Vec3A

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<Vec3A> for Vec3A

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl DivAssign<f32> for Vec3A

fn div_assign(&mut self, other: f32)

Performs the /= operation.

impl From<[f32; 3]> for Vec3A

fn from(a: [f32; 3]) -> Self

Performs the conversion.

impl From<(f32, f32, f32)> for Vec3A

fn from(t: (f32, f32, f32)) -> Self

Performs the conversion.

impl From<Vec3> for Vec3A

fn from(v: Vec3) -> Self

Performs the conversion.

impl From<Vec3A> for Vec3

fn from(v: Vec3A) -> Self

Performs the conversion.

impl From<Vec3A> for __m128

fn from(t: Vec3A) -> Self

Performs the conversion.

impl From<Vec3A> for (f32, f32, f32)

fn from(v: Vec3A) -> Self

Performs the conversion.

impl From<Vec3A> for [f32; 3]

fn from(v: Vec3A) -> Self

Performs the conversion.

impl From<__m128> for Vec3A

fn from(t: __m128) -> Self

Performs the conversion.

impl Index<usize> for Vec3A

type Output = f32

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Vec3A

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

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

impl Mul<Vec3A> for Mat3

type Output = Vec3A

The resulting type after applying the * operator.

fn mul(self, other: Vec3A) -> Vec3A

Performs the * operation.

impl Mul<Vec3A> for Quat

type Output = Vec3A

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Vec3A> for Vec3A

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Vec3A> for f32

type Output = Vec3A

The resulting type after applying the * operator.

fn mul(self, other: Vec3A) -> Vec3A

Performs the * operation.

impl Mul<f32> for Vec3A

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<Vec3A> for Vec3A

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl MulAssign<f32> for Vec3A

fn mul_assign(&mut self, other: f32)

Performs the *= operation.

impl Neg for Vec3A

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq<Vec3A> for Vec3A

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 PartialOrd<Vec3A> for Vec3A

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub<Vec3A> for Vec3A

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<Vec3A> for Vec3A

fn sub_assign(&mut self, other: Self)

Performs the -= operation.