Struct nannou::math::Euler

#[repr(C)]
pub struct Euler<A> {
    pub x: A,
    pub y: A,
    pub z: A,
}

A set of Euler angles representing a rotation in three-dimensional space.

This type is marked as #[repr(C)].

The axis rotation sequence is XYZ. That is, the rotation is first around the X axis, then the Y axis, and lastly the Z axis (using intrinsic rotations). Since all three rotation axes are used, the angles are Tait–Bryan angles rather than proper Euler angles.

Ranges

• x: [-pi, pi]
• y: [-pi/2, pi/2]
• z: [-pi, pi]

Defining rotations using Euler angles

Note that while Euler angles are intuitive to define, they are prone to gimbal lock and are challenging to interpolate between. Instead we recommend that you convert them to a more robust representation, such as a quaternion or a rotation matrix. To this end, From<Euler<A>> conversions are provided for the following types:

• Basis3
• Matrix3
• Matrix4
• Quaternion

For example, to define a quaternion that applies the following:

1. a 90° rotation around the x axis
2. a 45° rotation around the y axis
3. a 15° rotation around the z axis

you can use the following code:

use cgmath::{Deg, Euler, Quaternion};

let rotation = Quaternion::from(Euler {
    x: Deg(90.0),
    y: Deg(45.0),
    z: Deg(15.0),
});

Fields

x: A

The angle to apply around the x axis. Also known at the pitch.

y: A

The angle to apply around the y axis. Also known at the yaw.

z: A

The angle to apply around the z axis. Also known at the roll.

Methods

impl<A> Euler<A>

pub const fn new(x: A, y: A, z: A) -> Euler<A>

Construct a set of euler angles.

Arguments

• x - The angle to apply around the x axis. Also known at the pitch.
• y - The angle to apply around the y axis. Also known at the yaw.
• z - The angle to apply around the z axis. Also known at the roll.

Trait Implementations

impl<A> AbsDiffEq<Euler<A>> for Euler<A> where
    A: Angle, 

type Epsilon = <A as AbsDiffEq<A>>::Epsilon

Used for specifying relative comparisons.

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

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

fn abs_diff_eq(
    &self,
    other: &Euler<A>,
    epsilon: <A as AbsDiffEq<A>>::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 ApproxEq::abs_diff_eq.

impl<A> Clone for Euler<A> where
    A: Clone, 

fn clone(&self) -> Euler<A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A> Copy for Euler<A> where
    A: Copy, 

impl<A> Debug for Euler<A> where
    A: Debug, 

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

Formats the value using the given formatter.

impl<'de, A> Deserialize<'de> for Euler<A> where
    A: Deserialize<'de>, 

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Euler<A>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<A> Eq for Euler<A> where
    A: Eq, 

impl<A> From<Euler<A>> for Basis3<<A as Angle>::Unitless> where
    A: Angle + Into<Rad<<A as Angle>::Unitless>>, 

fn from(src: Euler<A>) -> Basis3<<A as Angle>::Unitless>

Create a three-dimensional rotation matrix from a set of euler angles.

impl<A> From<Euler<A>> for Matrix4<<A as Angle>::Unitless> where
    A: Angle + Into<Rad<<A as Angle>::Unitless>>, 

fn from(src: Euler<A>) -> Matrix4<<A as Angle>::Unitless>

Performs the conversion.

impl<A> From<Euler<A>> for Matrix3<<A as Angle>::Unitless> where
    A: Angle + Into<Rad<<A as Angle>::Unitless>>, 

fn from(src: Euler<A>) -> Matrix3<<A as Angle>::Unitless>

Performs the conversion.

impl<A> From<Euler<A>> for Quaternion<<A as Angle>::Unitless> where
    A: Angle + Into<Rad<<A as Angle>::Unitless>>, 

fn from(src: Euler<A>) -> Quaternion<<A as Angle>::Unitless>

Performs the conversion.

impl<S> From<Quaternion<S>> for Euler<Rad<S>> where
    S: BaseFloat, 

fn from(src: Quaternion<S>) -> Euler<Rad<S>>

Performs the conversion.

impl<A> PartialEq<Euler<A>> for Euler<A> where
    A: PartialEq<A>, 

fn eq(&self, other: &Euler<A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Euler<A>) -> bool

This method tests for !=.

impl<A> RelativeEq<Euler<A>> for Euler<A> where
    A: Angle, 

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

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

fn relative_eq(
    &self,
    other: &Euler<A>,
    epsilon: <A as AbsDiffEq<A>>::Epsilon,
    max_relative: <A as AbsDiffEq<A>>::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 ApproxEq::relative_eq.

impl<A> Serialize for Euler<A> where
    A: Serialize, 

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<A> StructuralEq for Euler<A>

impl<A> StructuralPartialEq for Euler<A>

impl<A> UlpsEq<Euler<A>> for Euler<A> where
    A: Angle, 

fn default_max_ulps() -> u32

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

fn ulps_eq(
    &self,
    other: &Euler<A>,
    epsilon: <A as AbsDiffEq<A>>::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 ApproxEq::ulps_eq.