Struct glam::f32::Vec3A[−][src]

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

Expand description

A 3-dimensional vector with SIMD support.

This type is 16 byte aligned. A SIMD vector type is used 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 const ZERO: Self`[src]

All zeroes.

`pub const ONE: Self`[src]

All ones.

`pub const X: Self`[src]

[1, 0, 0]: a unit-length vector pointing along the positive X axis.

`pub const Y: Self`[src]

[0, 1, 0]: a unit-length vector pointing along the positive Y axis.

`pub const Z: Self`[src]

[0, 0, 1]: a unit-length vector pointing along the positive Z axis.

`pub const AXES: [Self; 3]`[src]

The unit axes.

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

Creates a new 3D vector.

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

Creates a 4D vector 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 cross(self, other: Self) -> Self`[src]

Computes the cross product of self and other.

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

[x, y, z]

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

Creates a vector with all elements set to v.

`pub fn select(mask: BVec3A, if_true: Vec3A, if_false: Vec3A) -> Vec3A`[src]

Creates a vector from the elements in if_true and if_false, selecting which to use for each element of self.

A true element in the mask uses the corresponding element from if_true, and false uses the element from if_false.

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

Computes the dot product of self and other.

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

Returns a vector containing the mininum values for each element of self and other.

In other words this computes [self.x.max(other.x), self.y.max(other.y), ..].

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

Returns a vector containing the maximum values for each element of self and other.

In other words this computes [self.x.max(other.x), self.y.max(other.y), ..].

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

Component-wise clamping of values, similar to f32::clamp.

Each element in min must be less-or-equal to the corresponing element in max.

If the glam-assert feature is enabled, the function will panic if the contract is not met, otherwise the behavior is undefined.

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

Returns the horizontal minimum of self.

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

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

Returns the horizontal maximum of self.

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

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

Returns a vector mask containing the result of a == comparison for each element of self and other.

In other words, this computes [self.x == other.x, self.y == other.y, ..] for all elements.

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

Returns a vector mask containing the result of a != comparison for each element of self and other.

In other words this computes [self.x != other.x, self.y != other.y, ..] for all elements.

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

Returns a vector mask containing the result of a >= comparison for each element of self and other.

In other words this computes [self.x >= other.x, self.y >= other.y, ..] for all elements.

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

Returns a vector mask containing the result of a > comparison for each element of self and other.

In other words this computes [self.x > other.x, self.y > other.y, ..] for all elements.

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

Returns a vector mask containing the result of a <= comparison for each element of self and other.

In other words this computes [self.x <= other.x, self.y <= other.y, ..] for all elements.

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

Returns a vector mask containing the result of a < comparison for each element of self and other.

In other words this computes [self.x < other.x, self.y < other.y, ..] for all elements.

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

Creates a vector from the first N values in slice.

Panics

Panics if slice is less than N elements long.

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

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

Panics

Panics if slice is less than N elements long.

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

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

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

Returns a vector 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 is_finite(self) -> bool`[src]

Returns true if, and only if, all elements are finite. If any element is either NaN, positive or negative infinity, this will return false.

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

Returns true if any elements are NaN.

`pub fn is_nan_mask(self) -> BVec3A`[src]

Performs is_nan on each element of self, returning a vector mask of the results.

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

`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 faster than length() as it avoids a square root operation.

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

Computes 1.0 / length().

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

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

Computes the Euclidean distance between two points in space.

`pub fn distance_squared(self, other: Self) -> 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, nor very close to zero.

`pub fn try_normalize(self) -> Option<Self>`[src]

Returns self normalized to length 1.0 if possible, else returns None.

In particular, if the input is zero (or very close to zero), or non-finite, the result of this operation will be None.

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

Returns self normalized to length 1.0 if possible, else returns zero.

In particular, if the input is zero (or very close to zero), or non-finite, the result of this operation will be zero.

`pub fn is_normalized(self) -> bool`[src]

Returns whether self is length 1.0 or not.

Uses a precision threshold of 1e-6.

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

Returns a vector 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 vector containing the largest integer less than or equal to a number for each element of self.

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

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

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

Returns a vector containing e^self (the exponential function) for each element of self.

`pub fn powf(self, n: f32) -> Self`[src]

Returns a vector containing each element of self raised to the power of n.

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

Returns a vector 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 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 vectors 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 see comparing floating point numbers.

`pub fn clamp_length(self, min: f32, max: f32) -> Self`[src]

Returns a vector with a length no less than min and no more than max

`pub fn clamp_length_max(self, max: f32) -> Self`[src]

Returns a vector with a length no more than max

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

Returns a vector with a length no less than min

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

Returns the angle (in radians) between two vectors.

The input vectors do not need to be unit length however they must be non-zero.

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

Returns somes vector that is orthogonal to the given one.

The input vector must be finite and non-zero.

The output vector is not necessarily unit-length. For that use Self::any_orthonormal_vector instead.

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

Returns any unit-length vector that is orthogonal to the given one. The input vector must be finite and non-zero.

`pub fn any_orthonormal_pair(&self) -> (Self, Self)`[src]

Given a unit-length vector return two other vectors that together form an orthonormal basis. That is, all three vectors are orthogonal to each other and are normalized.

`pub fn as_f64(&self) -> DVec3`[src]

Casts all elements of self to f64.

`pub fn as_i32(&self) -> IVec3`[src]

Casts all elements of self to i32.

`pub fn as_u32(&self) -> UVec3`[src]

Casts all elements of self to u32.

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]

Performs the + operation. Read more

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

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

Performs the += operation. Read more

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

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

Performs the conversion.

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

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

Performs the conversion.

`impl Clone for Vec3A`[src]

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

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

`impl Debug for Vec3A`[src]

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

Formats the value using the given formatter. Read more

`impl Default for Vec3A`[src]

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

Returns the “default value” for a type. Read more

`impl Deref for Vec3A`[src]

`type Target = XYZ<f32>`

The resulting type after dereferencing.

`fn deref(&self) -> &Self::Target`[src]

Dereferences the value.

`impl DerefMut for Vec3A`[src]

`fn deref_mut(&mut self) -> &mut Self::Target`[src]

Mutably dereferences the value.

`impl Display for Vec3A`[src]

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

Formats the value using the given formatter. Read more

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

`type Output = Self`

The resulting type after applying the / operator.

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

Performs the / operation. Read more

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

`type Output = Self`

The resulting type after applying the / operator.

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

Performs the / operation. Read more

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

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

Performs the /= operation. Read more

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

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

Performs the /= operation. Read more

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

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

Performs the conversion.

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

`fn from((v, z): (Vec2, f32)) -> Self`[src]

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

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

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

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

Performs the conversion.

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

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

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

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]

Performs the conversion.

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

`type Output = f32`

The returned type after indexing.

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

Performs the indexing (container[index]) operation. Read more

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