Struct Angle

#[repr(C)]
pub struct Angle<F>(/* private fields */);

A type for representing an angle, without needing to remember if it is denominated in Radians, Degrees, or otherwise.

Implementations

impl<F: FullFloat> Angle<F>

pub fn new_radians(radians: F) -> Angle<F>

Create an angle from radians

pub fn from_radians(radians: F) -> Angle<F>

Create an angle from radians

pub fn as_radians(&self) -> F

Get the value of the angle as radians

pub fn new_degrees(degrees: F) -> Angle<F>

Create an angle from degrees

pub fn from_degrees(degrees: F) -> Angle<F>

Create an angle from degrees

pub fn as_degrees(&self) -> F

Get the value of the angle as degrees

pub fn new_cycles(cycles: F) -> Angle<F>

Create an angle from cycles (1 cycle is a full circle)

pub fn from_cycles(cycles: F) -> Angle<F>

Create an angle from cycles (1 cycle is a full circle)

pub fn as_cycles(&self) -> F

Get the value of the angle as number of cycles (full circles)

pub fn of_vector(vec: &Vec2<F>) -> Angle<F>

Get the angle that a given vector points in relative to the x-axis and going counterclockwise. This ranges from -PI to PI, and all 4 quadrants are properly handled.

Trait Implementations

impl<F: FullFloat> Add for Angle<F>

type Output = Angle<F>

The resulting type after applying the + operator.

fn add(self, rhs: Angle<F>) -> Angle<F>

Performs the + operation.

impl<F: FullFloat> ApproxEq for Angle<F>

type Flt = F

fn approx_eq( &self, other: &Self, epsilon: <F as ApproxEq>::Flt, ulps: <<F as ApproxEq>::Flt as Ulps>::U, ) -> bool

This method tests for self and other values to be approximately equal using two methods: epsilon and ulps. If the values differ by less than the given epsilon, they will be considered equal. If the values differ by more than epsilon, but by less than the given ulps, they will also be considered equal. Otherwise they are unequal.

fn approx_ne( &self, other: &Self, epsilon: Self::Flt, ulps: <Self::Flt as Ulps>::U, ) -> bool

This method tests for self and other values to be not approximately equal using two methods: epsilon and ulps. If the values differ by less than the given epsilon, they will be considered equal. If the values differ by more than epsilon, but by less than the given ulps, they will also be considered equal. Otherwise they are unequal.

impl<F: Clone> Clone for Angle<F>

fn clone(&self) -> Angle<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for Angle<F>

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

Formats the value using the given formatter.

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

where F: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F: FullFloat> Div<F> for Angle<F>

type Output = Angle<F>

The resulting type after applying the / operator.

fn div(self, rhs: F) -> Angle<F>

Performs the / operation.

impl<F: Hash> Hash for Angle<F>

fn hash<__H: Hasher>(&self, state: &mut __H)

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<F: FullFloat> Mul<F> for Angle<F>

type Output = Angle<F>

The resulting type after applying the * operator.

fn mul(self, rhs: F) -> Angle<F>

Performs the * operation.

impl<F: FullFloat> Neg for Angle<F>

type Output = Angle<F>

The resulting type after applying the - operator.

fn neg(self) -> Angle<F>

Performs the unary - operation.

impl<F: Ord> Ord for Angle<F>

fn cmp(&self, other: &Angle<F>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<F: PartialEq> PartialEq for Angle<F>

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

fn partial_cmp(&self, other: &Angle<F>) -> 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<F> Serialize for Angle<F>

where F: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F: FullFloat> Sub for Angle<F>

type Output = Angle<F>

The resulting type after applying the - operator.

fn sub(self, rhs: Angle<F>) -> Angle<F>

Performs the - operation.

impl<F: Copy> Copy for Angle<F>

impl<F: Eq> Eq for Angle<F>

impl<F> StructuralPartialEq for Angle<F>