[−][src]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`[src]

`pub fn new(x: f32, y: f32, z: f32) -> Self`[src]

Creates a new Vec3A.

`pub const fn zero() -> Self`[src]

Creates a Vec3A with all elements set to 0.0.

`pub const fn one() -> Self`[src]

Creates a Vec3A with all elements set to 1.0.

`pub const fn unit_x() -> Self`[src]

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

`pub const fn unit_y() -> Self`[src]

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

`pub const fn unit_z() -> Self`[src]

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

`pub fn splat(v: f32) -> Self`[src]

Creates a Vec3A with all elements set to v.

`pub fn extend(self, w: f32) -> Vec4`[src]

Creates a Vec4 from self and the given w value.

`pub fn truncate(self) -> Vec2`[src]

Creates a Vec2 from the x and y elements of self, discarding z.

Truncation may also be performed by using self.xy() or Vec2::from().

`pub fn x(self) -> f32`[src]

Returns element x.

`pub fn y(self) -> f32`[src]

Returns element y.

`pub fn z(self) -> f32`[src]

Returns element z.

`pub fn x_mut(&mut self) -> &mut f32`[src]

Returns a mutable reference to element x.

`pub fn y_mut(&mut self) -> &mut f32`[src]

Returns a mutable reference to element y.

`pub fn z_mut(&mut self) -> &mut f32`[src]

Returns a mutable reference to element z.

`pub fn set_x(&mut self, x: f32)`[src]

Sets element x.

`pub fn set_y(&mut self, y: f32)`[src]

Sets element y.

`pub fn set_z(&mut self, z: f32)`[src]

Sets element z.

`pub fn dot(self, other: Self) -> f32`[src]

Computes the dot product of self and other.

`pub fn cross(self, other: Self) -> Self`[src]

Computes the cross product of self and other.

`pub fn length(self) -> f32`[src]

Computes the length of self.

`pub fn length_squared(self) -> f32`[src]

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`[src]

👎 Deprecated since 0.9.5:

please use Vec3A::length_recip instead

`pub fn length_recip(self) -> f32`[src]

Computes 1.0 / Vec3A::length().

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

`pub fn distance(self, other: Vec3A) -> f32`[src]

Computes the Euclidean distance between two points in space.

`pub fn distance_squared(self, other: Vec3A) -> f32`[src]

Compute the squared euclidean distance between two points in space.

`pub fn normalize(self) -> Self`[src]

Returns self normalized to length 1.0.

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

`pub fn min(self, other: Self) -> Self`[src]

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`[src]

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`[src]

Returns the horizontal minimum of self's elements.

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

`pub fn max_element(self) -> f32`[src]

Returns the horizontal maximum of self's elements.

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

`pub fn cmpeq(self, other: Self) -> Vec3AMask`[src]

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`[src]

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`[src]

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`[src]

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`[src]

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`[src]

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`[src]

Creates a 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])`[src]

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`[src]

Returns a Vec3A containing the absolute value of each element of self.

`pub fn round(self) -> Self`[src]

Returns a Vec3A containing the nearest integer to a number for each element of self. Round half-way cases away from 0.0.

`pub fn floor(self) -> Self`[src]

Returns a Vec3A containing the largest integer less than or equal to a number for each element of self.

`pub fn ceil(self) -> Self`[src]

Returns a Vec3A containing the smallest integer greater than or equal to a number for each element of self.

`pub fn is_nan(self) -> Vec3AMask`[src]

Performs is_nan() on each element of self, returning a Vec3AMask of the results.

In other words, this computes [x.is_nan(), y.is_nan(), z.is_nan()].

`pub fn sign(self) -> Self`[src]

👎 Deprecated since 0.9.5:

please use Vec3A::signum instead

`pub fn signum(self) -> Self`[src]

Returns a Vec3A 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
NAN if the number is NAN

`pub fn reciprocal(self) -> Self`[src]

👎 Deprecated since 0.9.5:

please use Vec3A::recip instead

`pub fn recip(self) -> Self`[src]

Returns a Vec3A containing the reciprocal 1.0/n of each element of self.

`pub fn lerp(self, other: Self, s: f32) -> Self`[src]

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`[src]

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`[src]

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`[src]

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`[src]

`type Output = Self`

The resulting type after applying the + operator.

`fn add(self, other: Self) -> Self`[src]

`impl AddAssign<Vec3A> for Vec3A`[src]

`fn add_assign(&mut self, other: Self)`[src]

`impl AsMut<[f32; 3]> for Vec3A`[src]

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

`impl AsRef<[f32; 3]> for Vec3A`[src]

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

`impl Clone for Vec3A`[src]

`fn clone(&self) -> Vec3A`[src]

`fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Copy for Vec3A`[src]

`impl Debug for Vec3A`[src]

`fn fmt(&self, fmt: &mut Formatter<'_>) -> Result`[src]

`impl Default for Vec3A`[src]

`fn default() -> Self`[src]

`impl Display for Vec3A`[src]

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

`impl Div<Vec3A> for Vec3A`[src]

`type Output = Self`

The resulting type after applying the / operator.

`fn div(self, other: Self) -> Self`[src]

`impl Div<Vec3A> for f32`[src]

`type Output = Vec3A`

The resulting type after applying the / operator.

`fn div(self, other: Vec3A) -> Vec3A`[src]

`impl Div<f32> for Vec3A`[src]

`type Output = Self`

The resulting type after applying the / operator.

`fn div(self, other: f32) -> Self`[src]

`impl DivAssign<Vec3A> for Vec3A`[src]

`fn div_assign(&mut self, other: Self)`[src]

`impl DivAssign<f32> for Vec3A`[src]

`fn div_assign(&mut self, other: f32)`[src]

`impl From<[f32; 3]> for Vec3A`[src]

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

`impl From<(f32, f32, f32)> for Vec3A`[src]

`fn from(t: (f32, f32, f32)) -> Self`[src]

`impl From<Vec3> for Vec3A`[src]

`fn from(v: Vec3) -> Self`[src]

`impl From<Vec3A> for Vec3`[src]

`fn from(v: Vec3A) -> Self`[src]

`impl From<Vec3A> for __m128`[src]

`fn from(t: Vec3A) -> Self`[src]

`impl From<Vec3A> for (f32, f32, f32)`[src]

`fn from(v: Vec3A) -> Self`[src]

`impl From<Vec3A> for [f32; 3]`[src]

`fn from(v: Vec3A) -> Self`[src]

`impl From<Vec3A> for Vec2`[src]

`fn from(v: Vec3A) -> Self`[src]

Creates a Vec2 from the x and y elements of the Vec3A, discarding z.

`impl From<Vec4> for Vec3A`[src]

`fn from(v: Vec4) -> Self`[src]

Creates a Vec3 from the x, y and z elements of the Vec4, discarding z.

On architectures where SIMD is supported such as SSE2 on x86_64 this conversion is a noop.

`impl From<__m128> for Vec3A`[src]

`fn from(t: __m128) -> Self`[src]

`impl Index<usize> for Vec3A`[src]

`type Output = f32`

The returned type after indexing.

`fn index(&self, index: usize) -> &Self::Output`[src]