Struct Rotation2D 

pub struct Rotation2D<T, Src, Dst> {
    pub angle: T,
    /* private fields */
}

Available on crate feature geometry only.

A transform that can represent rotations in 2d, represented as an angle in radians.

Fields

angle: T

Angle in radians

Implementations

impl<T, Src, Dst> Rotation2D<T, Src, Dst>

pub fn new(angle: Angle<T>) -> Rotation2D<T, Src, Dst>

Available on crate feature canvas only.

Creates a rotation from an angle in radians.

pub fn radians(angle: T) -> Rotation2D<T, Src, Dst>

Available on crate feature canvas only.

Creates a rotation from an angle in radians.

pub fn identity() -> Rotation2D<T, Src, Dst>

where T: Zero,

Available on crate feature canvas only.

Creates the identity rotation.

impl<T, Src, Dst> Rotation2D<T, Src, Dst>

where T: Copy,

pub fn cast_unit<Src2, Dst2>(&self) -> Rotation2D<T, Src2, Dst2>

Available on crate feature canvas only.

Cast the unit, preserving the numeric value.

Example

enum Local {}
enum World {}

enum Local2 {}
enum World2 {}

let to_world: Rotation2D<_, Local, World> = Rotation2D::radians(42);

assert_eq!(to_world.angle, to_world.cast_unit::<Local2, World2>().angle);

pub fn to_untyped(&self) -> Rotation2D<T, UnknownUnit, UnknownUnit>

Available on crate feature canvas only.

Drop the units, preserving only the numeric value.

Example

enum Local {}
enum World {}

let to_world: Rotation2D<_, Local, World> = Rotation2D::radians(42);

assert_eq!(to_world.angle, to_world.to_untyped().angle);

pub fn from_untyped( r: &Rotation2D<T, UnknownUnit, UnknownUnit>, ) -> Rotation2D<T, Src, Dst>

Available on crate feature canvas only.

Tag a unitless value with units.

Example

use euclid::UnknownUnit;
enum Local {}
enum World {}

let rot: Rotation2D<_, UnknownUnit, UnknownUnit> = Rotation2D::radians(42);

assert_eq!(rot.angle, Rotation2D::<_, Local, World>::from_untyped(&rot).angle);

impl<T, Src, Dst> Rotation2D<T, Src, Dst>

where T: Copy,

pub fn get_angle(&self) -> Angle<T>

Available on crate feature canvas only.

Returns self.angle as a strongly typed Angle<T>.

impl<T, Src, Dst> Rotation2D<T, Src, Dst>

where T: Real,

pub fn to_3d(&self) -> Rotation3D<T, Src, Dst>

Available on crate feature canvas only.

Creates a 3d rotation (around the z axis) from this 2d rotation.

pub fn inverse(&self) -> Rotation2D<T, Dst, Src>

Available on crate feature canvas only.

Returns the inverse of this rotation.

pub fn then<NewSrc>( &self, other: &Rotation2D<T, NewSrc, Src>, ) -> Rotation2D<T, NewSrc, Dst>

Available on crate feature canvas only.

Returns a rotation representing the other rotation followed by this rotation.

pub fn transform_point(&self, point: Point2D<T, Src>) -> Point2D<T, Dst>

Available on crate feature canvas only.

Returns the given 2d point transformed by this rotation.

The input point must be use the unit Src, and the returned point has the unit Dst.

pub fn transform_vector(&self, vector: Vector2D<T, Src>) -> Vector2D<T, Dst>

Available on crate feature canvas only.

Returns the given 2d vector transformed by this rotation.

The input point must be use the unit Src, and the returned point has the unit Dst.

impl<T, Src, Dst> Rotation2D<T, Src, Dst>

where T: Copy + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Zero + Trig,

pub fn to_transform(&self) -> Transform2D<T, Src, Dst>

Available on crate feature canvas only.

Returns the matrix representation of this rotation.

Trait Implementations

impl<T, Src, Dst> ApproxEq<T> for Rotation2D<T, Src, Dst>

where T: Copy + Neg<Output = T> + ApproxEq<T>,

fn approx_epsilon() -> T

Default epsilon value

fn approx_eq_eps(&self, other: &Rotation2D<T, Src, Dst>, eps: &T) -> bool

Returns true if this object is approximately equal to the other one, using a provided epsilon value.

fn approx_eq(&self, other: &Self) -> bool

Returns true if this object is approximately equal to the other one, using the approx_epsilon epsilon value.

impl<T, Src, Dst> Clone for Rotation2D<T, Src, Dst>

where T: Clone,

fn clone(&self) -> Rotation2D<T, Src, Dst>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, Src, Dst> Debug for Rotation2D<T, Src, Dst>

where T: Debug,

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

Formats the value using the given formatter.

impl<T, Src, Dst> From<Rotation2D<T, Src, Dst>> for Transform2D<T, Src, Dst>

where T: Copy + Add<Output = T> + Sub<Output = T> + Mul<Output = T> + Zero + Trig,

fn from(r: Rotation2D<T, Src, Dst>) -> Transform2D<T, Src, Dst>

Converts to this type from the input type.

impl<T, Src, Dst> Hash for Rotation2D<T, Src, Dst>

where T: Hash,

fn hash<H>(&self, h: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, Src, Dst> PartialEq for Rotation2D<T, Src, Dst>

where T: PartialEq,

fn eq(&self, other: &Rotation2D<T, Src, Dst>) -> 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<S> Transformation<S> for Rotation2D<S, UnknownUnit, UnknownUnit>

where S: Scalar,

fn transform_point(&self, p: Point2D<S, UnknownUnit>) -> Point2D<S, UnknownUnit>

fn transform_vector( &self, v: Vector2D<S, UnknownUnit>, ) -> Vector2D<S, UnknownUnit>

impl<T, Src, Dst> Copy for Rotation2D<T, Src, Dst>

where T: Copy,

impl<T, Src, Dst> Eq for Rotation2D<T, Src, Dst>

where T: Eq,