euclid/
angle.rs

Help
1// Copyright 2013 The Servo Project Developers. See the COPYRIGHT
2// file at the top-level directory of this distribution.
3//
4// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
5// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
7// option. This file may not be copied, modified, or distributed
8// except according to those terms.
9
10use crate::approxeq::ApproxEq;
11use crate::trig::Trig;
12use core::cmp::{Eq, PartialEq};
13use core::hash::Hash;
14use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, Sub, SubAssign};
15use num_traits::{Float, FloatConst, NumCast, One, Zero};
16#[cfg(feature = "serde")]
17use serde::{Deserialize, Serialize};
18
19/// An angle in radians
20#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Hash)]
21#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
22pub struct Angle<T> {
23    pub radians: T,
24}
25
26impl<T> Angle<T> {
27    #[inline]
28    pub fn radians(radians: T) -> Self {
29        Angle { radians }
30    }
31
32    #[inline]
33    pub fn get(self) -> T {
34        self.radians
35    }
36}
37
38impl<T> Angle<T>
39where
40    T: Trig,
41{
42    #[inline]
43    pub fn degrees(deg: T) -> Self {
44        Angle {
45            radians: T::degrees_to_radians(deg),
46        }
47    }
48
49    #[inline]
50    pub fn to_degrees(self) -> T {
51        T::radians_to_degrees(self.radians)
52    }
53}
54
55impl<T> Angle<T>
56where
57    T: Rem<Output = T> + Sub<Output = T> + Add<Output = T> + Zero + FloatConst + PartialOrd + Copy,
58{
59    /// Returns this angle in the [0..2*PI[ range.
60    pub fn positive(&self) -> Self {
61        let two_pi = T::PI() + T::PI();
62        let mut a = self.radians % two_pi;
63        if a < T::zero() {
64            a = a + two_pi;
65        }
66        Angle::radians(a)
67    }
68
69    /// Returns this angle in the ]-PI..PI] range.
70    pub fn signed(&self) -> Self {
71        Angle::pi() - (Angle::pi() - *self).positive()
72    }
73}
74
75impl<T> Angle<T>
76where
77    T: Rem<Output = T>
78        + Mul<Output = T>
79        + Sub<Output = T>
80        + Add<Output = T>
81        + One
82        + FloatConst
83        + Copy,
84{
85    /// Returns the shortest signed angle between two angles.
86    ///
87    /// Takes wrapping and signs into account.
88    pub fn angle_to(&self, to: Self) -> Self {
89        let two = T::one() + T::one();
90        let max = T::PI() * two;
91        let d = (to.radians - self.radians) % max;
92
93        Angle::radians(two * d % max - d)
94    }
95
96    /// Linear interpolation between two angles, using the shortest path.
97    pub fn lerp(&self, other: Self, t: T) -> Self {
98        *self + self.angle_to(other) * t
99    }
100}
101
102impl<T> Angle<T>
103where
104    T: Float,
105{
106    /// Returns (sin(self), cos(self)).
107    pub fn sin_cos(self) -> (T, T) {
108        self.radians.sin_cos()
109    }
110}
111
112impl<T> Angle<T>
113where
114    T: Zero,
115{
116    pub fn zero() -> Self {
117        Angle::radians(T::zero())
118    }
119}
120
121impl<T> Angle<T>
122where
123    T: FloatConst + Add<Output = T>,
124{
125    pub fn pi() -> Self {
126        Angle::radians(T::PI())
127    }
128
129    pub fn two_pi() -> Self {
130        Angle::radians(T::PI() + T::PI())
131    }
132
133    pub fn frac_pi_2() -> Self {
134        Angle::radians(T::FRAC_PI_2())
135    }
136
137    pub fn frac_pi_3() -> Self {
138        Angle::radians(T::FRAC_PI_3())
139    }
140
141    pub fn frac_pi_4() -> Self {
142        Angle::radians(T::FRAC_PI_4())
143    }
144}
145
146impl<T> Angle<T>
147where
148    T: NumCast + Copy,
149{
150    /// Cast from one numeric representation to another.
151    #[inline]
152    pub fn cast<NewT: NumCast>(&self) -> Angle<NewT> {
153        self.try_cast().unwrap()
154    }
155
156    /// Fallible cast from one numeric representation to another.
157    pub fn try_cast<NewT: NumCast>(&self) -> Option<Angle<NewT>> {
158        NumCast::from(self.radians).map(|radians| Angle { radians })
159    }
160
161    // Convenience functions for common casts.
162
163    /// Cast angle to `f32`.
164    #[inline]
165    pub fn to_f32(&self) -> Angle<f32> {
166        self.cast()
167    }
168
169    /// Cast angle `f64`.
170    #[inline]
171    pub fn to_f64(&self) -> Angle<f64> {
172        self.cast()
173    }
174}
175
176impl<T: Add<T, Output = T>> Add for Angle<T> {
177    type Output = Angle<T>;
178    fn add(self, other: Angle<T>) -> Angle<T> {
179        Angle::radians(self.radians + other.radians)
180    }
181}
182
183impl<T: AddAssign<T>> AddAssign for Angle<T> {
184    fn add_assign(&mut self, other: Angle<T>) {
185        self.radians += other.radians;
186    }
187}
188
189impl<T: Sub<T, Output = T>> Sub<Angle<T>> for Angle<T> {
190    type Output = Angle<T>;
191    fn sub(self, other: Angle<T>) -> <Self as Sub>::Output {
192        Angle::radians(self.radians - other.radians)
193    }
194}
195
196impl<T: SubAssign<T>> SubAssign for Angle<T> {
197    fn sub_assign(&mut self, other: Angle<T>) {
198        self.radians -= other.radians;
199    }
200}
201
202impl<T: Div<T, Output = T>> Div<Angle<T>> for Angle<T> {
203    type Output = T;
204    #[inline]
205    fn div(self, other: Angle<T>) -> T {
206        self.radians / other.radians
207    }
208}
209
210impl<T: Div<T, Output = T>> Div<T> for Angle<T> {
211    type Output = Angle<T>;
212    #[inline]
213    fn div(self, factor: T) -> Angle<T> {
214        Angle::radians(self.radians / factor)
215    }
216}
217
218impl<T: DivAssign<T>> DivAssign<T> for Angle<T> {
219    fn div_assign(&mut self, factor: T) {
220        self.radians /= factor;
221    }
222}
223
224impl<T: Mul<T, Output = T>> Mul<T> for Angle<T> {
225    type Output = Angle<T>;
226    #[inline]
227    fn mul(self, factor: T) -> Angle<T> {
228        Angle::radians(self.radians * factor)
229    }
230}
231
232impl<T: MulAssign<T>> MulAssign<T> for Angle<T> {
233    fn mul_assign(&mut self, factor: T) {
234        self.radians *= factor;
235    }
236}
237
238impl<T: Neg<Output = T>> Neg for Angle<T> {
239    type Output = Self;
240    fn neg(self) -> Self {
241        Angle::radians(-self.radians)
242    }
243}
244
245impl<T: ApproxEq<T>> ApproxEq<T> for Angle<T> {
246    #[inline]
247    fn approx_epsilon() -> T {
248        T::approx_epsilon()
249    }
250
251    #[inline]
252    fn approx_eq_eps(&self, other: &Angle<T>, approx_epsilon: &T) -> bool {
253        self.radians.approx_eq_eps(&other.radians, approx_epsilon)
254    }
255}
256
257#[test]
258fn wrap_angles() {
259    use core::f32::consts::{FRAC_PI_2, PI};
260
261    assert!(Angle::radians(0.0).positive().approx_eq(&Angle::zero()));
262    assert!(Angle::radians(FRAC_PI_2)
263        .positive()
264        .approx_eq(&Angle::frac_pi_2()));
265    assert!(Angle::radians(-FRAC_PI_2)
266        .positive()
267        .approx_eq(&Angle::radians(3.0 * FRAC_PI_2)));
268    assert!(Angle::radians(3.0 * FRAC_PI_2)
269        .positive()
270        .approx_eq(&Angle::radians(3.0 * FRAC_PI_2)));
271    assert!(Angle::radians(5.0 * FRAC_PI_2)
272        .positive()
273        .approx_eq(&Angle::frac_pi_2()));
274    assert!(Angle::radians(2.0 * PI)
275        .positive()
276        .approx_eq(&Angle::zero()));
277    assert!(Angle::radians(-2.0 * PI)
278        .positive()
279        .approx_eq(&Angle::zero()));
280    assert!(Angle::radians(PI).positive().approx_eq(&Angle::pi()));
281    assert!(Angle::radians(-PI).positive().approx_eq(&Angle::pi()));
282
283    assert!(Angle::radians(FRAC_PI_2)
284        .signed()
285        .approx_eq(&Angle::frac_pi_2()));
286    assert!(Angle::radians(3.0 * FRAC_PI_2)
287        .signed()
288        .approx_eq(&-Angle::frac_pi_2()));
289    assert!(Angle::radians(5.0 * FRAC_PI_2)
290        .signed()
291        .approx_eq(&Angle::frac_pi_2()));
292    assert!(Angle::radians(2.0 * PI).signed().approx_eq(&Angle::zero()));
293    assert!(Angle::radians(-2.0 * PI).signed().approx_eq(&Angle::zero()));
294    assert!(Angle::radians(-PI).signed().approx_eq(&Angle::pi()));
295    assert!(Angle::radians(PI).signed().approx_eq(&Angle::pi()));
296}
297
298#[test]
299fn lerp() {
300    type A = Angle<f32>;
301
302    let a = A::radians(1.0);
303    let b = A::radians(2.0);
304    assert!(a.lerp(b, 0.25).approx_eq(&Angle::radians(1.25)));
305    assert!(a.lerp(b, 0.5).approx_eq(&Angle::radians(1.5)));
306    assert!(a.lerp(b, 0.75).approx_eq(&Angle::radians(1.75)));
307    assert!(a
308        .lerp(b + A::two_pi(), 0.75)
309        .approx_eq(&Angle::radians(1.75)));
310    assert!(a
311        .lerp(b - A::two_pi(), 0.75)
312        .approx_eq(&Angle::radians(1.75)));
313    assert!(a
314        .lerp(b + A::two_pi() * 5.0, 0.75)
315        .approx_eq(&Angle::radians(1.75)));
316}
euclid/angle.rs

euclid/
angle.rs
