pub struct Vec4(/* private fields */);Expand description
A 4-dimensional vector.
SIMD vector types are used for storage on supported platforms.
This type is 16 byte aligned.
Implementations§
source§impl Vec4
impl Vec4
sourcepub const NEG_INFINITY: Self = _
pub const NEG_INFINITY: Self = _
All f32::NEG_INFINITY.
sourcepub fn select(mask: BVec4A, if_true: Self, if_false: Self) -> Self
pub fn select(mask: BVec4A, if_true: Self, if_false: Self) -> Self
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.
sourcepub const fn from_array(a: [f32; 4]) -> Self
pub const fn from_array(a: [f32; 4]) -> Self
Creates a new vector from an array.
sourcepub const fn from_slice(slice: &[f32]) -> Self
pub const fn from_slice(slice: &[f32]) -> Self
Creates a vector from the first 4 values in slice.
Panics
Panics if slice is less than 4 elements long.
sourcepub fn write_to_slice(self, slice: &mut [f32])
pub fn write_to_slice(self, slice: &mut [f32])
Writes the elements of self to the first 4 elements in slice.
Panics
Panics if slice is less than 4 elements long.
sourcepub fn truncate(self) -> Vec3
pub fn truncate(self) -> Vec3
Creates a 3D vector from the x, y and z elements of self, discarding w.
Truncation to Vec3 may also be performed by using self.xyz().
To truncate to Vec3A use Vec3A::from().
sourcepub fn dot_into_vec(self, rhs: Self) -> Self
pub fn dot_into_vec(self, rhs: Self) -> Self
Returns a vector where every component is the dot product of self and rhs.
sourcepub fn min(self, rhs: Self) -> Self
pub fn min(self, rhs: Self) -> Self
Returns a vector containing the minimum values for each element of self and rhs.
In other words this computes [self.x.min(rhs.x), self.y.min(rhs.y), ..].
sourcepub fn max(self, rhs: Self) -> Self
pub fn max(self, rhs: Self) -> Self
Returns a vector containing the maximum values for each element of self and rhs.
In other words this computes [self.x.max(rhs.x), self.y.max(rhs.y), ..].
sourcepub fn clamp(self, min: Self, max: Self) -> Self
pub fn clamp(self, min: Self, max: Self) -> Self
Component-wise clamping of values, similar to f32::clamp.
Each element in min must be less-or-equal to the corresponding element in max.
Panics
Will panic if min is greater than max when glam_assert is enabled.
sourcepub fn min_element(self) -> f32
pub fn min_element(self) -> f32
Returns the horizontal minimum of self.
In other words this computes min(x, y, ..).
sourcepub fn max_element(self) -> f32
pub fn max_element(self) -> f32
Returns the horizontal maximum of self.
In other words this computes max(x, y, ..).
sourcepub fn cmpeq(self, rhs: Self) -> BVec4A
pub fn cmpeq(self, rhs: Self) -> BVec4A
Returns a vector mask containing the result of a == comparison for each element of
self and rhs.
In other words, this computes [self.x == rhs.x, self.y == rhs.y, ..] for all
elements.
sourcepub fn cmpne(self, rhs: Self) -> BVec4A
pub fn cmpne(self, rhs: Self) -> BVec4A
Returns a vector mask containing the result of a != comparison for each element of
self and rhs.
In other words this computes [self.x != rhs.x, self.y != rhs.y, ..] for all
elements.
sourcepub fn cmpge(self, rhs: Self) -> BVec4A
pub fn cmpge(self, rhs: Self) -> BVec4A
Returns a vector mask containing the result of a >= comparison for each element of
self and rhs.
In other words this computes [self.x >= rhs.x, self.y >= rhs.y, ..] for all
elements.
sourcepub fn cmpgt(self, rhs: Self) -> BVec4A
pub fn cmpgt(self, rhs: Self) -> BVec4A
Returns a vector mask containing the result of a > comparison for each element of
self and rhs.
In other words this computes [self.x > rhs.x, self.y > rhs.y, ..] for all
elements.
sourcepub fn cmple(self, rhs: Self) -> BVec4A
pub fn cmple(self, rhs: Self) -> BVec4A
Returns a vector mask containing the result of a <= comparison for each element of
self and rhs.
In other words this computes [self.x <= rhs.x, self.y <= rhs.y, ..] for all
elements.
sourcepub fn cmplt(self, rhs: Self) -> BVec4A
pub fn cmplt(self, rhs: Self) -> BVec4A
Returns a vector mask containing the result of a < comparison for each element of
self and rhs.
In other words this computes [self.x < rhs.x, self.y < rhs.y, ..] for all
elements.
sourcepub fn abs(self) -> Self
pub fn abs(self) -> Self
Returns a vector containing the absolute value of each element of self.
sourcepub fn signum(self) -> Self
pub fn signum(self) -> Self
Returns a vector with elements representing the sign of self.
1.0if the number is positive,+0.0orINFINITY-1.0if the number is negative,-0.0orNEG_INFINITYNANif the number isNAN
sourcepub fn copysign(self, rhs: Self) -> Self
pub fn copysign(self, rhs: Self) -> Self
Returns a vector with signs of rhs and the magnitudes of self.
sourcepub fn is_negative_bitmask(self) -> u32
pub fn is_negative_bitmask(self) -> u32
Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of self.
A negative element results in a 1 bit and a positive element in a 0 bit. Element x goes
into the first lowest bit, element y into the second, etc.
sourcepub fn is_finite(self) -> bool
pub fn is_finite(self) -> bool
Returns true if, and only if, all elements are finite. If any element is either
NaN, positive or negative infinity, this will return false.
sourcepub fn is_nan_mask(self) -> BVec4A
pub fn is_nan_mask(self) -> BVec4A
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()].
sourcepub fn length_squared(self) -> f32
pub fn length_squared(self) -> f32
Computes the squared length of self.
This is faster than length() as it avoids a square root operation.
sourcepub fn length_recip(self) -> f32
pub fn length_recip(self) -> f32
Computes 1.0 / length().
For valid results, self must not be of length zero.
sourcepub fn distance(self, rhs: Self) -> f32
pub fn distance(self, rhs: Self) -> f32
Computes the Euclidean distance between two points in space.
sourcepub fn distance_squared(self, rhs: Self) -> f32
pub fn distance_squared(self, rhs: Self) -> f32
Compute the squared euclidean distance between two points in space.
sourcepub fn div_euclid(self, rhs: Self) -> Self
pub fn div_euclid(self, rhs: Self) -> Self
Returns the element-wise quotient of [Euclidean division] of self by rhs.
sourcepub fn rem_euclid(self, rhs: Self) -> Self
pub fn rem_euclid(self, rhs: Self) -> Self
Returns the element-wise remainder of Euclidean division of self by rhs.
sourcepub fn normalize(self) -> Self
pub fn normalize(self) -> Self
Returns self normalized to length 1.0.
For valid results, self must not be of length zero, nor very close to zero.
See also Self::try_normalize() and Self::normalize_or_zero().
Panics
Will panic if self is zero length when glam_assert is enabled.
sourcepub fn try_normalize(self) -> Option<Self>
pub fn try_normalize(self) -> Option<Self>
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.
See also Self::normalize_or_zero().
sourcepub fn normalize_or_zero(self) -> Self
pub fn normalize_or_zero(self) -> Self
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.
See also Self::try_normalize().
sourcepub fn is_normalized(self) -> bool
pub fn is_normalized(self) -> bool
Returns whether self is length 1.0 or not.
Uses a precision threshold of 1e-6.
sourcepub fn project_onto(self, rhs: Self) -> Self
pub fn project_onto(self, rhs: Self) -> Self
Returns the vector projection of self onto rhs.
rhs must be of non-zero length.
Panics
Will panic if rhs is zero length when glam_assert is enabled.
sourcepub fn reject_from(self, rhs: Self) -> Self
pub fn reject_from(self, rhs: Self) -> Self
Returns the vector rejection of self from rhs.
The vector rejection is the vector perpendicular to the projection of self onto
rhs, in rhs words the result of self - self.project_onto(rhs).
rhs must be of non-zero length.
Panics
Will panic if rhs has a length of zero when glam_assert is enabled.
sourcepub fn project_onto_normalized(self, rhs: Self) -> Self
pub fn project_onto_normalized(self, rhs: Self) -> Self
Returns the vector projection of self onto rhs.
rhs must be normalized.
Panics
Will panic if rhs is not normalized when glam_assert is enabled.
sourcepub fn reject_from_normalized(self, rhs: Self) -> Self
pub fn reject_from_normalized(self, rhs: Self) -> Self
Returns the vector rejection of self from rhs.
The vector rejection is the vector perpendicular to the projection of self onto
rhs, in rhs words the result of self - self.project_onto(rhs).
rhs must be normalized.
Panics
Will panic if rhs is not normalized when glam_assert is enabled.
sourcepub fn round(self) -> Self
pub fn round(self) -> Self
Returns a vector containing the nearest integer to a number for each element of self.
Round half-way cases away from 0.0.
sourcepub fn floor(self) -> Self
pub fn floor(self) -> Self
Returns a vector containing the largest integer less than or equal to a number for each
element of self.
sourcepub fn ceil(self) -> Self
pub fn ceil(self) -> Self
Returns a vector containing the smallest integer greater than or equal to a number for
each element of self.
sourcepub fn trunc(self) -> Self
pub fn trunc(self) -> Self
Returns a vector containing the integer part each element of self. This means numbers are
always truncated towards zero.
sourcepub fn fract(self) -> Self
pub fn fract(self) -> Self
Returns a vector containing the fractional part of the vector, e.g. self - self.floor().
Note that this is fast but not precise for large numbers.
sourcepub fn exp(self) -> Self
pub fn exp(self) -> Self
Returns a vector containing e^self (the exponential function) for each element of
self.
sourcepub fn powf(self, n: f32) -> Self
pub fn powf(self, n: f32) -> Self
Returns a vector containing each element of self raised to the power of n.
sourcepub fn recip(self) -> Self
pub fn recip(self) -> Self
Returns a vector containing the reciprocal 1.0/n of each element of self.
sourcepub fn lerp(self, rhs: Self, s: f32) -> Self
pub fn lerp(self, rhs: Self, s: f32) -> Self
Performs a linear interpolation between self and rhs 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 rhs. When s is outside of range [0, 1], the result is linearly
extrapolated.
sourcepub fn abs_diff_eq(self, rhs: Self, max_abs_diff: f32) -> bool
pub fn abs_diff_eq(self, rhs: Self, max_abs_diff: f32) -> bool
Returns true if the absolute difference of all elements between self and rhs 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.
sourcepub fn clamp_length(self, min: f32, max: f32) -> Self
pub fn clamp_length(self, min: f32, max: f32) -> Self
Returns a vector with a length no less than min and no more than max
Panics
Will panic if min is greater than max when glam_assert is enabled.
sourcepub fn clamp_length_max(self, max: f32) -> Self
pub fn clamp_length_max(self, max: f32) -> Self
Returns a vector with a length no more than max
sourcepub fn clamp_length_min(self, min: f32) -> Self
pub fn clamp_length_min(self, min: f32) -> Self
Returns a vector with a length no less than min
sourcepub fn mul_add(self, a: Self, b: Self) -> Self
pub fn mul_add(self, a: Self, b: Self) -> Self
Fused multiply-add. Computes (self * a) + b element-wise with only one rounding
error, yielding a more accurate result than an unfused multiply-add.
Using mul_add may be more performant than an unfused multiply-add if the target
architecture has a dedicated fma CPU instruction. However, this is not always true,
and will be heavily dependant on designing algorithms with specific target hardware in
mind.
sourcepub fn as_i16vec4(&self) -> I16Vec4
pub fn as_i16vec4(&self) -> I16Vec4
Casts all elements of self to i16.
sourcepub fn as_u16vec4(&self) -> U16Vec4
pub fn as_u16vec4(&self) -> U16Vec4
Casts all elements of self to u16.
sourcepub fn as_i64vec4(&self) -> I64Vec4
pub fn as_i64vec4(&self) -> I64Vec4
Casts all elements of self to i64.
sourcepub fn as_u64vec4(&self) -> U64Vec4
pub fn as_u64vec4(&self) -> U64Vec4
Casts all elements of self to u64.
Trait Implementations§
source§impl AddAssign<f32> for Vec4
impl AddAssign<f32> for Vec4
source§fn add_assign(&mut self, rhs: f32)
fn add_assign(&mut self, rhs: f32)
+= operation. Read moresource§impl AddAssign for Vec4
impl AddAssign for Vec4
source§fn add_assign(&mut self, rhs: Self)
fn add_assign(&mut self, rhs: Self)
+= operation. Read moresource§impl DivAssign<f32> for Vec4
impl DivAssign<f32> for Vec4
source§fn div_assign(&mut self, rhs: f32)
fn div_assign(&mut self, rhs: f32)
/= operation. Read moresource§impl DivAssign for Vec4
impl DivAssign for Vec4
source§fn div_assign(&mut self, rhs: Self)
fn div_assign(&mut self, rhs: Self)
/= operation. Read moresource§impl MulAssign<f32> for Vec4
impl MulAssign<f32> for Vec4
source§fn mul_assign(&mut self, rhs: f32)
fn mul_assign(&mut self, rhs: f32)
*= operation. Read moresource§impl MulAssign for Vec4
impl MulAssign for Vec4
source§fn mul_assign(&mut self, rhs: Self)
fn mul_assign(&mut self, rhs: Self)
*= operation. Read moresource§impl RemAssign<f32> for Vec4
impl RemAssign<f32> for Vec4
source§fn rem_assign(&mut self, rhs: f32)
fn rem_assign(&mut self, rhs: f32)
%= operation. Read moresource§impl RemAssign for Vec4
impl RemAssign for Vec4
source§fn rem_assign(&mut self, rhs: Self)
fn rem_assign(&mut self, rhs: Self)
%= operation. Read moresource§impl SubAssign<f32> for Vec4
impl SubAssign<f32> for Vec4
source§fn sub_assign(&mut self, rhs: f32)
fn sub_assign(&mut self, rhs: f32)
-= operation. Read moresource§impl SubAssign for Vec4
impl SubAssign for Vec4
source§fn sub_assign(&mut self, rhs: Vec4)
fn sub_assign(&mut self, rhs: Vec4)
-= operation. Read more