Struct Rot2 

#[repr(C)]
pub struct Rot2 {
    pub re: f32,
    pub im: f32,
}

A 2D rotation represented as a unit complex number (f32 precision).

The rotation is stored as re + im * i where re = cos(angle) and im = sin(angle).

Fields

re: f32

Real part (cosine of the angle).

im: f32

Imaginary part (sine of the angle).

Implementations

impl Rot2

pub const IDENTITY: Rot2

The identity rotation (no rotation).

pub const fn from_cos_sin_unchecked(re: f32, im: f32) -> Rot2

Creates a new unit complex from cosine and sine values.

The caller must ensure that re*re + im*im = 1.

pub fn from_matrix_unchecked(mat: Mat2) -> Rot2

Creates a rotation from a rotation matrix (without normalization).

pub fn identity() -> Rot2

Creates the identity rotation.

pub fn new(angle: f32) -> Rot2

Creates a rotation from an angle in radians.

pub fn from_angle(angle: f32) -> Rot2

Creates a rotation from an angle in radians.

pub fn angle(&self) -> f32

Returns the rotation angle in radians.

pub fn cos(&self) -> f32

Returns the cosine of the rotation angle (the real part).

pub fn sin(&self) -> f32

Returns the sine of the rotation angle (the imaginary part).

pub fn inverse(self) -> Rot2

Returns the inverse rotation.

pub fn length(&self) -> f32

Computes the length (magnitude) of self.

For a valid unit rotation, this should always be 1.0.

pub fn length_squared(&self) -> f32

Computes the squared length of self.

This is faster than length() as it avoids a square root. For a valid unit rotation, this should always be 1.0.

pub fn length_recip(&self) -> f32

Computes 1.0 / length().

pub fn normalize(&self) -> Rot2

Returns self normalized to length 1.0.

For valid unit rotations this should be a no-op.

pub fn is_finite(&self) -> bool

Returns true if, and only if, all elements are finite.

pub fn is_nan(&self) -> bool

Returns true if any element is NaN.

pub fn is_normalized(&self) -> bool

Returns whether self is of length 1.0 or not.

Uses a precision threshold of approximately 1e-4.

pub fn transform_vector(&self, v: Vec2) -> Vec2

Rotates a 2D vector by this rotation.

pub fn inverse_transform_vector(&self, v: Vec2) -> Vec2

Transforms a 2D vector by the inverse of this rotation.

pub fn to_mat(&self) -> Mat2

Returns the rotation matrix equivalent to this rotation.

pub fn from_mat(mat: Mat2) -> Rot2

Creates a rotation from a 2x2 rotation matrix.

The matrix should be a valid rotation matrix (orthogonal with determinant 1).

pub fn from_mat_unchecked(mat: Mat2) -> Rot2

Creates a rotation from a 2x2 matrix without normalization.

Alias for from_matrix_unchecked.

pub fn from_rotation_arc(from: Vec2, to: Vec2) -> Rot2

Gets the minimal rotation for transforming from to to.

Both vectors must be normalized. The rotation is in the plane spanned by the two vectors.

pub fn slerp(&self, other: &Rot2, t: f32) -> Rot2

Spherical linear interpolation between two rotations.

pub fn powf(&self, n: f32) -> Rot2

Raises this rotation to a power.

For example, powf(2.0) will return a rotation with double the angle.

pub fn rotate_towards(&self, rhs: &Rot2, max_angle: f32) -> Rot2

Rotates self towards rhs up to max_angle (in radians).

When max_angle is 0.0, the result will be equal to self. When max_angle is equal to self.angle_between(rhs), the result will be equal to rhs. If max_angle is negative, rotates towards the exact opposite of rhs. Will not go past the target.

pub fn angle_between(&self, rhs: &Rot2) -> f32

Returns the angle (in radians) between self and rhs.

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

Computes the dot product of self and rhs.

The dot product is equal to the cosine of the angle between two rotations.

pub fn lerp(&self, rhs: Rot2, s: f32) -> Rot2

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. For rotations, slerp is usually preferred over lerp.

pub fn normalize_mut(&mut self)

Normalizes self in place.

Does nothing if self is already normalized or zero length.

Trait Implementations

impl AbsDiffEq for Rot2

type Epsilon = f32

Used for specifying relative comparisons.

fn default_epsilon() -> <Rot2 as AbsDiffEq>::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq( &self, other: &Rot2, epsilon: <Rot2 as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl Clone for Rot2

fn clone(&self) -> Rot2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rot2

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

Formats the value using the given formatter.

impl Default for Rot2

fn default() -> Rot2

Returns the “default value” for a type.

impl From<DRot2> for Rot2

fn from(r: DRot2) -> Rot2

Converts to this type from the input type.

impl From<Rot2> for Pose2

fn from(rotation: Rot2) -> Pose2

Converts to this type from the input type.

impl Mul<Pose2> for Rot2

type Output = Pose2

The resulting type after applying the * operator.

fn mul(self, rhs: Pose2) -> <Rot2 as Mul<Pose2>>::Output

Performs the * operation.

impl Mul<Rot2> for &Rot2

type Output = Rot2

The resulting type after applying the * operator.

fn mul(self, rhs: Rot2) -> <&Rot2 as Mul<Rot2>>::Output

Performs the * operation.

impl Mul<Rot2> for Pose2

type Output = Pose2

The resulting type after applying the * operator.

fn mul(self, rhs: Rot2) -> <Pose2 as Mul<Rot2>>::Output

Performs the * operation.

impl Mul<Vec2> for Rot2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2) -> <Rot2 as Mul<Vec2>>::Output

Performs the * operation.

impl Mul for Rot2

type Output = Rot2

The resulting type after applying the * operator.

fn mul(self, rhs: Rot2) -> <Rot2 as Mul>::Output

Performs the * operation.

impl MulAssign<Rot2> for Pose2

fn mul_assign(&mut self, rhs: Rot2)

Performs the *= operation.

impl MulAssign for Rot2

fn mul_assign(&mut self, rhs: Rot2)

Performs the *= operation.

impl PartialEq for Rot2

fn eq(&self, other: &Rot2) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl RelativeEq for Rot2

fn default_max_relative() -> <Rot2 as AbsDiffEq>::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Rot2, epsilon: <Rot2 as AbsDiffEq>::Epsilon, max_relative: <Rot2 as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl UlpsEq for Rot2

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq( &self, other: &Rot2, epsilon: <Rot2 as AbsDiffEq>::Epsilon, max_ulps: u32, ) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl Copy for Rot2

impl StructuralPartialEq for Rot2