Struct DRot2 

pub struct DRot2 {
    pub cos: f64,
    pub sin: f64,
}

A double-precision version of Rot2.

Fields

cos: f64

The cosine of the rotation angle.

This is the real part of the unit complex number representing the rotation.

sin: f64

The sine of the rotation angle.

This is the imaginary part of the unit complex number representing the rotation.

Implementations

impl DRot2

pub const IDENTITY: Self

The identity rotation.

pub const PI: Self

A rotation of π radians. Corresponds to a half-turn.

pub const FRAC_PI_2: Self

A counterclockwise rotation of π/2 radians. Corresponds to a counterclockwise quarter-turn.

pub const FRAC_PI_3: Self

A counterclockwise rotation of π/3 radians. Corresponds to a counterclockwise turn by 60°.

pub const FRAC_PI_4: Self

A counterclockwise rotation of π/4 radians. Corresponds to a counterclockwise turn by 45°.

pub const FRAC_PI_6: Self

A counterclockwise rotation of π/6 radians. Corresponds to a counterclockwise turn by 30°.

pub const FRAC_PI_8: Self

A counterclockwise rotation of π/8 radians. Corresponds to a counterclockwise turn by 22.5°.

pub fn radians(radians: f64) -> Self

Creates a DRot2 from a counterclockwise angle in radians. A negative argument corresponds to a clockwise rotation.

Note

Angles larger than or equal to 2π (in either direction) loop around to smaller rotations, since a full rotation returns an object to its starting orientation.

pub fn degrees(degrees: f64) -> Self

Creates a DRot2 from a counterclockwise angle in degrees. A negative argument corresponds to a clockwise rotation.

Note

Angles larger than or equal to 360° (in either direction) loop around to smaller rotations, since a full rotation returns an object to its starting orientation.

pub fn turn_fraction(fraction: f64) -> Self

Creates a DRot2 from a counterclockwise fraction of a full turn of 360 degrees. A negative argument corresponds to a clockwise rotation.

Note

Angles larger than or equal to 1 turn (in either direction) loop around to smaller rotations, since a full rotation returns an object to its starting orientation.

pub fn from_sin_cos(sin: f64, cos: f64) -> Self

Creates a DRot2 from the sine and cosine of an angle.

The rotation is only valid if sin * sin + cos * cos == 1.0.

Panics

Panics if sin * sin + cos * cos != 1.0 with debug assertions enabled.

pub fn as_radians(self) -> f64

Returns a corresponding rotation angle in radians in the (-pi, pi] range.

pub fn as_degrees(self) -> f64

Returns a corresponding rotation angle in degrees in the (-180, 180] range.

pub fn as_turn_fraction(self) -> f64

Returns a corresponding rotation angle as a fraction of a full 360 degree turn in the (-0.5, 0.5] range.

pub const fn sin_cos(self) -> (f64, f64)

Returns the sine and cosine of the rotation angle.

pub fn length(self) -> f64

Computes the length or norm of the complex number used to represent the rotation.

The length is typically expected to be 1.0. Unexpectedly denormalized rotations can be a result of incorrect construction or floating point error caused by successive operations.

pub fn length_squared(self) -> f64

Computes the squared length or norm of the complex number used to represent the rotation.

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

The length is typically expected to be 1.0. Unexpectedly denormalized rotations can be a result of incorrect construction or floating point error caused by successive operations.

pub fn length_recip(self) -> f64

Computes 1.0 / self.length().

For valid results, self must not have a length of zero.

pub fn try_normalize(self) -> Option<Self>

Returns self with a length of 1.0 if possible, and None otherwise.

None will be returned if the sine and cosine of self are both zero (or very close to zero), or if either of them is NaN or infinite.

Note that DRot2 should typically already be normalized by design. Manual normalization is only needed when successive operations result in accumulated floating point error, or if the rotation was constructed with invalid values.

pub fn normalize(self) -> Self

Returns self with a length of 1.0.

Note that DRot2 should typically already be normalized by design. Manual normalization is only needed when successive operations result in accumulated floating point error, or if the rotation was constructed with invalid values.

Panics

Panics if self has a length of zero, NaN, or infinity when debug assertions are enabled.

pub fn fast_renormalize(self) -> Self

Returns self after an approximate normalization, assuming the value is already nearly normalized. Useful for preventing numerical error accumulation.

pub const fn is_finite(self) -> bool

Returns true if the rotation is neither infinite nor NaN.

pub const fn is_nan(self) -> bool

Returns true if the rotation is NaN.

pub fn is_normalized(self) -> bool

Returns whether self has a length of 1.0 or not.

Uses a precision threshold of approximately 1e-4.

pub fn is_near_identity(self) -> bool

Returns true if the rotation is near DRot2::IDENTITY.

pub fn angle_to(self, other: Self) -> f64

Returns the angle in radians needed to make self and other coincide.

pub const fn inverse(self) -> Self

Returns the inverse of the rotation. This is also the conjugate of the unit complex number representing the rotation.

pub fn nlerp(self, end: Self, s: f64) -> Self

Performs a linear interpolation between self and end based on the value s, and normalizes the rotation afterwards.

When s == 0.0, the result will be equal to self. When s == 1.0, the result will be equal to end.

This is slightly more efficient than slerp, and produces a similar result when the difference between the two rotations is small. At larger differences, the result resembles a kind of ease-in-out effect.

If you would like the angular velocity to remain constant, consider using slerp instead.

Details

nlerp corresponds to computing an angle for a point at position s on a line drawn between the endpoints of the arc formed by self and end on a unit circle, and normalizing the result afterwards.

Note that if the angles are opposite like 0 and π, the line will pass through the origin, and the resulting angle will always be either self or end depending on s. If s happens to be 0.5 in this case, a valid rotation cannot be computed, and self will be returned as a fallback.

pub fn slerp(self, end: Self, s: f64) -> Self

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

This corresponds to interpolating between the two angles at a constant angular velocity.

When s == 0.0, the result will be equal to self. When s == 1.0, the result will be equal to end.

If you would like the rotation to have a kind of ease-in-out effect, consider using the slightly more efficient nlerp instead.

Trait Implementations

impl Clone for DRot2

fn clone(&self) -> DRot2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DRot2

impl Debug for DRot2

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

Formats the value using the given formatter.

impl Default for DRot2

fn default() -> Self

Returns the “default value” for a type.

impl From<DRot2> for DMat2

fn from(rot: DRot2) -> Self

Creates a DMat2 rotation matrix from a DRot2.

impl From<f64> for DRot2

fn from(rotation: f64) -> Self

Creates a DRot2 from a counterclockwise angle in radians.

impl FromReflect for DRot2

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for DRot2

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Mul for DRot2

type Output = DRot2

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl Mul<DVec2> for DRot2

fn mul(self, rhs: DVec2) -> Self::Output

Rotates a DVec2 by a DRot2.

type Output = DVec2

The resulting type after applying the * operator.

impl MulAssign for DRot2

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl PartialEq for DRot2

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

Equality operator ==.

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

Inequality operator !=.

impl PartialReflect for DRot2

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_partial_cmp(&self, value: &dyn PartialReflect) -> Option<Ordering>

Returns a “partial comparison” result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Result<Box<dyn PartialReflect>, ReflectCloneError>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for DRot2

fn into_any(self: Box<Self>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Struct for DRot2

fn field(&self, name: &str) -> Option<&dyn PartialReflect>

Gets a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut(&mut self, name: &str) -> Option<&mut dyn PartialReflect>

Gets a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&dyn PartialReflect>

Gets a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect>

Gets a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> Result<DynamicStruct, ReflectCloneError>

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl StructuralPartialEq for DRot2

impl ToF32Precision for DRot2

type F32 = Rot2

The math type with the precision adjusted to f32.

fn f32(&self) -> Self::F32

Adjusts the precision of self to f32.

impl ToRealPrecision for DRot2

type Adjusted = Rot2

The math type with the precision adjusted to Real.

fn real(&self) -> Self::Adjusted

Adjusts the precision of self to the Real number precision.

impl TypePath for DRot2

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for DRot2

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.