Struct Angle 

pub struct Angle { /* private fields */ }

A struct for working with angles in different units (radians, degrees, or rotations).

Angles are stored internally as radians.

let angle_deg = Angle::from_degrees(90.0);
let angle_rad = Angle::from_rad(std::f32::consts::PI / 2.0);
let angle_rot = Angle::from_rotations(0.25);
assert_eq!(angle_deg, angle_rad);
assert_eq!(angle_deg, angle_rot);

Implementations

impl Angle

pub fn zero() -> Self

Creates a zero angle.

pub fn from_rad(rad: f32) -> Self

Creates a new angle from radians.

pub fn from_degrees(degree: f32) -> Self

Creates a new angle from degrees.

pub fn from_rotations(rotations: f32) -> Self

Creates a new angle from number of rotations.

let angle = Angle::from_rotations(0.25);
assert_eq!(angle.to_degree(), 90.0);

pub fn rand() -> Self

Creates a random angle between 0 and 2π (0° and 360°).

pub fn quarter_rotation() -> Self

Returns an angle representing a quarter rotation (90°).

pub fn half_rotation() -> Self

Returns an angle representing a half rotation (180°).

pub fn full_rotation() -> Self

Returns an angle representing a full rotation (360°).

pub fn right_cc() -> Self

Returns an angle representing a direction to the right. Equivalent to Angle::zero(). see also crate::V2::right()

pub fn right_cw() -> Self

Returns an angle representing a direction to the right. Equivalent to Angle::zero(). see also crate::V2::right()

pub fn up_cc() -> Self

Returns an angle representing a direction upwards, counter clockwise (left / positive) from Angle::zero(). see also crate::V2::up()

pub fn up_cw() -> Self

Returns an angle representing a direction upwards, clockwise (right / negative) from Angle::zero(). see also crate::V2::up()

pub fn left_cc() -> Self

Returns an angle representing a direction to the left, counter clockwise (left / positive) from Angle::zero(). see also crate::V2::left()

pub fn left_cw() -> Self

Returns an angle representing a direction to the left, clockwise (right / negative) from Angle::zero(). see also crate::V2::left()

pub fn down_cc() -> Self

Returns an angle representing a direction downwards, counter clockwise (left / positive) from Angle::zero(). see also crate::V2::down()

pub fn down_cw() -> Self

Returns an angle representing a direction downwards, clockwise (right / negative) from Angle::zero(). see also crate::V2::down()

pub fn golden_ratio() -> Self

Creates an angle with the golden ratio number of rotations. See GR.

pub fn golden_ratio_inverse() -> Self

Creates an angle with 1.0 / golden ratio number of rotations. See GR.

pub fn root_two() -> Self

Creates an angle with √2 number of rotations.

pub fn root_two_inverse() -> Self

Creates an angle with 1.0 / √2 number of rotations.

pub fn to_rad(&self) -> f32

Gets the angle in radians.

pub fn to_degree(&self) -> f32

Gets the angle in degrees.

pub fn to_rotations(&self) -> f32

Gets the angle as a number of rotations.

pub fn rad_sin_cos(&self) -> (f32, f32)

Gets both sine and cosine of this angle in radians: (self.to_rad().sin(), self.to_rad().cos()).

pub fn mod_one_rotation(&self) -> Self

Returns a new angle modulo 2π (360°), resulting in a positive angle between 0 and 2π.

pub fn modulo(&self, other: Angle) -> Self

Returns a new angle modulo other, resulting in a positive angle between Angle::zero and other.

pub fn positive(&self) -> Self

Returns a new angle with the same direction but positive value.

let angle = Angle::from_degrees(-90.0);
assert_eq!(angle.positive().to_degree(), 270.0);

pub fn abs(&self) -> Self

Returns the absolute value of the angle.

pub fn flip_sign(&self) -> Self

Returns a new angle with flipped sign: self * -1.0.

pub fn normal_right(&self) -> Self

Returns a new angle orthogonal to this one (to the right). Equivalent to self + Angle::quarter_rotation().

pub fn lerp(&self, end: Angle, t: f32) -> Angle

Interpolates between self and other with t as the interpolation factor.

A value of t = 0.0 returns self, a value of t = 1.0 returns other. Values between 0.0 and 1.0 return points between self and other.

Example

let a1 = Angle::zero();
let a2 = Angle::from_degrees(180.0);
assert_eq!(a1.lerp(a2, 0.5), Angle::from_degrees(90.0));

pub fn lerp_iter_fixed(&self, end: Angle, steps: usize) -> AngleInterpolator

Returns an iterator to interpolate from self to end in steps number of steps.

The iterator will return steps + 1 angles, including both self and end.

Example

let a1 = Angle::zero();
let a2 = Angle::from_degrees(90.0);
for angle in a1.lerp_iter_fixed(a2, 9) {
    println!("{:?}", angle);
}

pub fn lerp_iter( &self, end: Angle, sample_settings: SampleSettings, radius: f32, ) -> AngleInterpolator

Returns an iterator to interpolate from self to end.

The number of steps is determined by sample_settings.points_per_unit and the given radius. The arc length of the arc with radius radius is used as the distance between self and end.

Example

let a1 = Angle::zero();
let a2 = Angle::from_degrees(90.0);
for angle in a1.lerp_iter(a2, SampleSettings::new(10.0), 1.0) {
    println!("{:?}", angle);
}

pub fn with_smallest_rotation_to(&self, other: Angle) -> Angle

Returns a new angle that represents the smallest rotation to other.

pub fn dist_mod_one_rotation(&self, other: Angle) -> Angle

Returns the smallest angular difference between two angles, accounting for wrapping around a full rotation.

pub fn min(&self, other: Angle) -> Angle

Returns the smaller of self and other.

pub fn max(&self, other: Angle) -> Angle

Returns the larger of self and other.

Trait Implementations

impl Add for Angle

type Output = Angle

The resulting type after applying the + operator.

fn add(self, _rhs: Angle) -> Angle

Performs the + operation.

impl Add<&Angle> for Angle

type Output = Angle

The resulting type after applying the + operator.

fn add(self, _rhs: &Angle) -> Angle

Performs the + operation.

impl Add<&Angle> for &Angle

type Output = Angle

The resulting type after applying the + operator.

fn add(self, _rhs: &Angle) -> Angle

Performs the + operation.

impl Add<Angle> for &Angle

type Output = Angle

The resulting type after applying the + operator.

fn add(self, _rhs: Angle) -> Angle

Performs the + operation.

impl AddAssign for Angle

fn add_assign(&mut self, rhs: Angle)

Performs the += operation.

impl AddAssign<&Angle> for Angle

fn add_assign(&mut self, rhs: &Angle)

Performs the += operation.

impl Clone for Angle

fn clone(&self) -> Angle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Angle

impl Debug for Angle

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Angle

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<f32> for Angle

type Output = Angle

The resulting type after applying the / operator.

fn div(self, _rhs: f32) -> Angle

Performs the / operation.

impl Div<f32> for &Angle

type Output = Angle

The resulting type after applying the / operator.

fn div(self, _rhs: f32) -> Angle

Performs the / operation.

impl DivAssign<f32> for Angle

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl From<Angle> for f32

fn from(angle: Angle) -> Self

Converts to this type from the input type.

impl From<f32> for Angle

fn from(rad: f32) -> Self

Converts to this type from the input type.

impl Mul<f32> for Angle

type Output = Angle

The resulting type after applying the * operator.

fn mul(self, _rhs: f32) -> Angle

Performs the * operation.

impl Mul<f32> for &Angle

type Output = Angle

The resulting type after applying the * operator.

fn mul(self, _rhs: f32) -> Angle

Performs the * operation.

impl MulAssign<f32> for Angle

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl PartialEq for Angle

fn eq(&self, rhs: &Angle) -> 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 PartialEq<&Angle> for Angle

fn eq(&self, rhs: &&Angle) -> 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 PartialEq<Angle> for &Angle

fn eq(&self, rhs: &Angle) -> 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 PartialOrd for Angle

fn partial_cmp(&self, other: &Angle) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Angle

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Angle

type Output = Angle

The resulting type after applying the - operator.

fn sub(self, _rhs: Angle) -> Angle

Performs the - operation.

impl Sub<&Angle> for Angle

type Output = Angle

The resulting type after applying the - operator.

fn sub(self, _rhs: &Angle) -> Angle

Performs the - operation.

impl Sub<&Angle> for &Angle

type Output = Angle

The resulting type after applying the - operator.

fn sub(self, _rhs: &Angle) -> Angle

Performs the - operation.

impl Sub<Angle> for &Angle

type Output = Angle

The resulting type after applying the - operator.

fn sub(self, _rhs: Angle) -> Angle

Performs the - operation.

impl SubAssign for Angle

fn sub_assign(&mut self, rhs: Angle)

Performs the -= operation.

impl SubAssign<&Angle> for Angle

fn sub_assign(&mut self, rhs: &Angle)

Performs the -= operation.