Struct bevy::math::Rotation2d
pub struct Rotation2d {
pub cos: f32,
pub sin: f32,
}
Expand description
A counterclockwise 2D rotation in radians.
The rotation angle is wrapped to be within the (-pi, pi]
range.
§Example
use std::f32::consts::PI;
// Create rotations from radians or degrees
let rotation1 = Rotation2d::radians(PI / 2.0);
let rotation2 = Rotation2d::degrees(45.0);
// Get the angle back as radians or degrees
assert_eq!(rotation1.as_degrees(), 90.0);
assert_eq!(rotation2.as_radians(), PI / 4.0);
// "Add" rotations together using `*`
assert_relative_eq!(rotation1 * rotation2, Rotation2d::degrees(135.0));
// Rotate vectors
assert_relative_eq!(rotation1 * Vec2::X, Vec2::Y);
Fields§
§cos: f32
The cosine of the rotation angle in radians.
This is the real part of the unit complex number representing the rotation.
sin: f32
The sine of the rotation angle in radians.
This is the imaginary part of the unit complex number representing the rotation.
Implementations§
§impl Rotation2d
impl Rotation2d
pub const IDENTITY: Rotation2d = _
pub const IDENTITY: Rotation2d = _
No rotation.
pub const PI: Rotation2d = _
pub const PI: Rotation2d = _
A rotation of π radians.
pub const FRAC_PI_2: Rotation2d = _
pub const FRAC_PI_2: Rotation2d = _
A counterclockwise rotation of π/2 radians.
pub const FRAC_PI_3: Rotation2d = _
pub const FRAC_PI_3: Rotation2d = _
A counterclockwise rotation of π/3 radians.
pub const FRAC_PI_4: Rotation2d = _
pub const FRAC_PI_4: Rotation2d = _
A counterclockwise rotation of π/4 radians.
pub const FRAC_PI_6: Rotation2d = _
pub const FRAC_PI_6: Rotation2d = _
A counterclockwise rotation of π/6 radians.
pub const FRAC_PI_8: Rotation2d = _
pub const FRAC_PI_8: Rotation2d = _
A counterclockwise rotation of π/8 radians.
pub fn radians(radians: f32) -> Rotation2d
pub fn radians(radians: f32) -> Rotation2d
Creates a Rotation2d
from a counterclockwise angle in radians.
pub fn degrees(degrees: f32) -> Rotation2d
pub fn degrees(degrees: f32) -> Rotation2d
Creates a Rotation2d
from a counterclockwise angle in degrees.
pub fn from_sin_cos(sin: f32, cos: f32) -> Rotation2d
pub fn from_sin_cos(sin: f32, cos: f32) -> Rotation2d
Creates a Rotation2d
from the sine and cosine of an angle in radians.
The rotation is only valid if sin * sin + cos * cos == 1.0
.
§Panics
Panics if sin * sin + cos * cos != 1.0
when the glam_assert
feature is enabled.
pub fn as_radians(self) -> f32
pub fn as_radians(self) -> f32
Returns the rotation in radians in the (-pi, pi]
range.
pub fn as_degrees(self) -> f32
pub fn as_degrees(self) -> f32
Returns the rotation in degrees in the (-180, 180]
range.
pub const fn sin_cos(self) -> (f32, f32)
pub const fn sin_cos(self) -> (f32, f32)
Returns the sine and cosine of the rotation angle in radians.
pub fn length(self) -> f32
pub fn length(self) -> f32
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) -> f32
pub fn length_squared(self) -> f32
Computes the squared length or norm of the complex number used to represent the rotation.
This is generally faster than Rotation2d::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) -> f32
pub fn length_recip(self) -> f32
Computes 1.0 / self.length()
.
For valid results, self
must not have a length of zero.
pub fn try_normalize(self) -> Option<Rotation2d>
pub fn try_normalize(self) -> Option<Rotation2d>
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 Rotation2d
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) -> Rotation2d
pub fn normalize(self) -> Rotation2d
Returns self
with a length of 1.0
.
Note that Rotation2d
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 is_normalized(self) -> bool
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
pub fn is_near_identity(self) -> bool
Returns true
if the rotation is near Rotation2d::IDENTITY
.
pub fn angle_between(self, other: Rotation2d) -> f32
pub fn angle_between(self, other: Rotation2d) -> f32
Returns the angle in radians needed to make self
and other
coincide.
pub fn inverse(self) -> Rotation2d
pub fn inverse(self) -> Rotation2d
Returns the inverse of the rotation. This is also the conjugate of the unit complex number representing the rotation.
pub fn nlerp(self, end: Rotation2d, s: f32) -> Rotation2d
pub fn nlerp(self, end: Rotation2d, s: f32) -> Rotation2d
Performs a linear interpolation between self
and rhs
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 rhs
.
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 rhs
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 rhs
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.
§Example
let rot1 = Rotation2d::IDENTITY;
let rot2 = Rotation2d::degrees(135.0);
let result1 = rot1.nlerp(rot2, 1.0 / 3.0);
assert_eq!(result1.as_degrees(), 28.675055);
let result2 = rot1.nlerp(rot2, 0.5);
assert_eq!(result2.as_degrees(), 67.5);
pub fn slerp(self, end: Rotation2d, s: f32) -> Rotation2d
pub fn slerp(self, end: Rotation2d, s: f32) -> Rotation2d
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 rhs
.
If you would like the rotation to have a kind of ease-in-out effect, consider
using the slightly more efficient nlerp
instead.
§Example
let rot1 = Rotation2d::IDENTITY;
let rot2 = Rotation2d::degrees(135.0);
let result1 = rot1.slerp(rot2, 1.0 / 3.0);
assert_eq!(result1.as_degrees(), 45.0);
let result2 = rot1.slerp(rot2, 0.5);
assert_eq!(result2.as_degrees(), 67.5);
Trait Implementations§
§impl Clone for Rotation2d
impl Clone for Rotation2d
§fn clone(&self) -> Rotation2d
fn clone(&self) -> Rotation2d
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more§impl Debug for Rotation2d
impl Debug for Rotation2d
§impl Default for Rotation2d
impl Default for Rotation2d
§fn default() -> Rotation2d
fn default() -> Rotation2d
§impl<'de> Deserialize<'de> for Rotation2d
impl<'de> Deserialize<'de> for Rotation2d
§fn deserialize<__D>(
__deserializer: __D
) -> Result<Rotation2d, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(
__deserializer: __D
) -> Result<Rotation2d, <__D as Deserializer<'de>>::Error>where
__D: Deserializer<'de>,
§impl From<Rotation2d> for Mat2
impl From<Rotation2d> for Mat2
§fn from(rot: Rotation2d) -> Mat2
fn from(rot: Rotation2d) -> Mat2
Creates a Mat2
rotation matrix from a Rotation2d
.
§impl From<f32> for Rotation2d
impl From<f32> for Rotation2d
§fn from(rotation: f32) -> Rotation2d
fn from(rotation: f32) -> Rotation2d
Creates a Rotation2d
from a counterclockwise angle in radians.
§impl FromReflect for Rotation2d
impl FromReflect for Rotation2d
§fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Rotation2d>
fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<Rotation2d>
Self
from a reflected value.§fn take_from_reflect(
reflect: Box<dyn Reflect>
) -> Result<Self, Box<dyn Reflect>>
fn take_from_reflect( reflect: Box<dyn Reflect> ) -> Result<Self, Box<dyn Reflect>>
Self
using,
constructing the value using from_reflect
if that fails. Read more§impl GetTypeRegistration for Rotation2d
impl GetTypeRegistration for Rotation2d
§fn get_type_registration() -> TypeRegistration
fn get_type_registration() -> TypeRegistration
TypeRegistration
for this type.§fn register_type_dependencies(registry: &mut TypeRegistry)
fn register_type_dependencies(registry: &mut TypeRegistry)
§impl Mul<Dir2> for Rotation2d
impl Mul<Dir2> for Rotation2d
§impl Mul<Vec2> for Rotation2d
impl Mul<Vec2> for Rotation2d
§impl Mul for Rotation2d
impl Mul for Rotation2d
§type Output = Rotation2d
type Output = Rotation2d
*
operator.§fn mul(self, rhs: Rotation2d) -> <Rotation2d as Mul>::Output
fn mul(self, rhs: Rotation2d) -> <Rotation2d as Mul>::Output
*
operation. Read more§impl MulAssign for Rotation2d
impl MulAssign for Rotation2d
§fn mul_assign(&mut self, rhs: Rotation2d)
fn mul_assign(&mut self, rhs: Rotation2d)
*=
operation. Read more§impl PartialEq for Rotation2d
impl PartialEq for Rotation2d
§fn eq(&self, other: &Rotation2d) -> bool
fn eq(&self, other: &Rotation2d) -> bool
self
and other
values to be equal, and is used
by ==
.§impl Reflect for Rotation2d
impl Reflect for Rotation2d
§fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
fn get_represented_type_info(&self) -> Option<&'static TypeInfo>
§fn into_any(self: Box<Rotation2d>) -> Box<dyn Any>
fn into_any(self: Box<Rotation2d>) -> Box<dyn Any>
Box<dyn Any>
.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut dyn Any
.§fn into_reflect(self: Box<Rotation2d>) -> Box<dyn Reflect>
fn into_reflect(self: Box<Rotation2d>) -> Box<dyn Reflect>
§fn as_reflect(&self) -> &(dyn Reflect + 'static)
fn as_reflect(&self) -> &(dyn Reflect + 'static)
§fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)
§fn clone_value(&self) -> Box<dyn Reflect>
fn clone_value(&self) -> Box<dyn Reflect>
Reflect
trait object. Read more§fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>
§fn apply(&mut self, value: &(dyn Reflect + 'static))
fn apply(&mut self, value: &(dyn Reflect + 'static))
§fn reflect_kind(&self) -> ReflectKind
fn reflect_kind(&self) -> ReflectKind
§fn reflect_ref(&self) -> ReflectRef<'_>
fn reflect_ref(&self) -> ReflectRef<'_>
§fn reflect_mut(&mut self) -> ReflectMut<'_>
fn reflect_mut(&mut self) -> ReflectMut<'_>
§fn reflect_owned(self: Box<Rotation2d>) -> ReflectOwned
fn reflect_owned(self: Box<Rotation2d>) -> ReflectOwned
§fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>
fn reflect_partial_eq(&self, value: &(dyn Reflect + 'static)) -> Option<bool>
§fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
fn debug(&self, f: &mut Formatter<'_>) -> Result<(), Error>
§fn reflect_hash(&self) -> Option<u64>
fn reflect_hash(&self) -> Option<u64>
§fn serializable(&self) -> Option<Serializable<'_>>
fn serializable(&self) -> Option<Serializable<'_>>
§fn is_dynamic(&self) -> bool
fn is_dynamic(&self) -> bool
§impl Serialize for Rotation2d
impl Serialize for Rotation2d
§fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
__S: Serializer,
§impl Struct for Rotation2d
impl Struct for Rotation2d
§fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>
fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>
name
as a &dyn Reflect
.§fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>
fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>
name
as a
&mut dyn Reflect
.§fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>
index
as a
&dyn Reflect
.§fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>
fn field_at_mut(&mut self, index: usize) -> Option<&mut (dyn Reflect + 'static)>
index
as a &mut dyn Reflect
.§fn iter_fields(&self) -> FieldIter<'_> ⓘ
fn iter_fields(&self) -> FieldIter<'_> ⓘ
§fn clone_dynamic(&self) -> DynamicStruct
fn clone_dynamic(&self) -> DynamicStruct
DynamicStruct
.§impl TypePath for Rotation2d
impl TypePath for Rotation2d
§fn short_type_path() -> &'static str
fn short_type_path() -> &'static str
§fn type_ident() -> Option<&'static str>
fn type_ident() -> Option<&'static str>
§fn crate_name() -> Option<&'static str>
fn crate_name() -> Option<&'static str>
§impl Typed for Rotation2d
impl Typed for Rotation2d
impl Copy for Rotation2d
impl StructuralPartialEq for Rotation2d
Auto Trait Implementations§
impl Freeze for Rotation2d
impl RefUnwindSafe for Rotation2d
impl Send for Rotation2d
impl Sync for Rotation2d
impl Unpin for Rotation2d
impl UnwindSafe for Rotation2d
Blanket Implementations§
§impl<T, U> AsBindGroupShaderType<U> for T
impl<T, U> AsBindGroupShaderType<U> for T
§fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U
T
ShaderType
for self
. When used in AsBindGroup
derives, it is safe to assume that all images in self
exist.source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Downcast for Twhere
T: Any,
impl<T> Downcast for Twhere
T: Any,
§fn into_any(self: Box<T>) -> Box<dyn Any>
fn into_any(self: Box<T>) -> Box<dyn Any>
Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
.§fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
.§fn as_any(&self) -> &(dyn Any + 'static)
fn as_any(&self) -> &(dyn Any + 'static)
&Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s.§fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)
&mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s.§impl<T> DowncastSync for T
impl<T> DowncastSync for T
§impl<T> DynamicTypePath for Twhere
T: TypePath,
impl<T> DynamicTypePath for Twhere
T: TypePath,
§fn reflect_type_path(&self) -> &str
fn reflect_type_path(&self) -> &str
TypePath::type_path
.§fn reflect_short_type_path(&self) -> &str
fn reflect_short_type_path(&self) -> &str
§fn reflect_type_ident(&self) -> Option<&str>
fn reflect_type_ident(&self) -> Option<&str>
TypePath::type_ident
.§fn reflect_crate_name(&self) -> Option<&str>
fn reflect_crate_name(&self) -> Option<&str>
TypePath::crate_name
.§fn reflect_module_path(&self) -> Option<&str>
fn reflect_module_path(&self) -> Option<&str>
§impl<S> FromSample<S> for S
impl<S> FromSample<S> for S
fn from_sample_(s: S) -> S
§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
§fn from_world(_world: &mut World) -> T
fn from_world(_world: &mut World) -> T
Self
using data from the given World
.§impl<T> GetPath for T
impl<T> GetPath for T
§fn reflect_path<'p>(
&self,
path: impl ReflectPath<'p>
) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path<'p>( &self, path: impl ReflectPath<'p> ) -> Result<&(dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read more§fn reflect_path_mut<'p>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
fn reflect_path_mut<'p>( &mut self, path: impl ReflectPath<'p> ) -> Result<&mut (dyn Reflect + 'static), ReflectPathError<'p>>
path
. Read more§fn path<'p, T>(
&self,
path: impl ReflectPath<'p>
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
fn path<'p, T>(
&self,
path: impl ReflectPath<'p>
) -> Result<&T, ReflectPathError<'p>>where
T: Reflect,
path
. Read more§fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
fn path_mut<'p, T>(
&mut self,
path: impl ReflectPath<'p>
) -> Result<&mut T, ReflectPathError<'p>>where
T: Reflect,
path
. Read more§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more§impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
fn into_sample(self) -> T
§impl<T> NoneValue for Twhere
T: Default,
impl<T> NoneValue for Twhere
T: Default,
type NoneType = T
§fn null_value() -> T
fn null_value() -> T
§impl<T> Pointable for T
impl<T> Pointable for T
source§impl<R, P> ReadPrimitive<R> for P
impl<R, P> ReadPrimitive<R> for P
source§fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
fn read_from_little_endian(read: &mut R) -> Result<Self, Error>
ReadEndian::read_from_little_endian()
.