Improve Radians ergonomics

core/src/angle.rs

@@ -13,7 +13,26 @@ pub struct Radians(pub f32);
 
 impl Radians {
     /// The range of radians of a circle.
-    pub const RANGE: RangeInclusive<Radians> = Radians(0.0)..=Radians(2.0 * PI);
+    pub const RANGE: RangeInclusive<Self> = Self(0.0)..=Self(2.0 * PI);
+
+    /// The amount of radians in half a circle.
+    pub const PI: Self = Self(PI);
+
+    /// Calculates the line in which the angle intercepts the `bounds`.
+    pub fn to_distance(&self, bounds: &Rectangle) -> (Point, Point) {
+        let angle = self.0 - FRAC_PI_2;
+        let r = Vector::new(f32::cos(angle), f32::sin(angle));
+
+        let distance_to_rect = f32::max(
+            f32::abs(r.x * bounds.width / 2.0),
+            f32::abs(r.y * bounds.height / 2.0),
+        );
+
+        let start = bounds.center() - r * distance_to_rect;
+        let end = bounds.center() + r * distance_to_rect;
+
+        (start, end)
+    }
 }
 
 impl From<Degrees> for Radians {
@@ -54,64 +73,70 @@ impl num_traits::FromPrimitive for Radians {
     }
 }
 
-impl Radians {
+impl Sub for Radians {
-    /// Calculates the line in which the angle intercepts the `bounds`.
+    type Output = Self;
-    pub fn to_distance(&self, bounds: &Rectangle) -> (Point, Point) {
-        let angle = self.0 - FRAC_PI_2;
-        let r = Vector::new(f32::cos(angle), f32::sin(angle));
 
-        let distance_to_rect = f32::max(
+    fn sub(self, rhs: Self) -> Self::Output {
-            f32::abs(r.x * bounds.width / 2.0),
+        Self(self.0 - rhs.0)
-            f32::abs(r.y * bounds.height / 2.0),
-        );
-
-        let start = bounds.center() - r * distance_to_rect;
-        let end = bounds.center() + r * distance_to_rect;
-
-        (start, end)
     }
 }
 
-impl SubAssign<Radians> for Radians {
+impl SubAssign for Radians {
-    fn sub_assign(&mut self, rhs: Radians) {
+    fn sub_assign(&mut self, rhs: Self) {
         self.0 = self.0 - rhs.0;
     }
 }
 
-impl AddAssign<Radians> for Radians {
+impl Add for Radians {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl AddAssign for Radians {
     fn add_assign(&mut self, rhs: Radians) {
         self.0 = self.0 + rhs.0;
     }
 }
 
-impl Add<Radians> for Radians {
+impl Mul for Radians {
-    type Output = Radians;
+    type Output = Self;
 
-    fn add(self, rhs: Radians) -> Self::Output {
+    fn mul(self, rhs: Radians) -> Self::Output {
-        Radians(self.0 + rhs.0)
+        Radians(self.0 * rhs.0)
-    }
-}
-
-impl Sub<Radians> for Radians {
-    type Output = Radians;
-
-    fn sub(self, rhs: Radians) -> Self::Output {
-        Radians(self.0 - rhs.0)
     }
 }
 
 impl Mul<f32> for Radians {
-    type Output = Radians;
+    type Output = Self;
 
     fn mul(self, rhs: f32) -> Self::Output {
-        Radians(self.0 * rhs)
+        Self(self.0 * rhs)
+    }
+}
+
+impl Mul<Radians> for f32 {
+    type Output = Radians;
+
+    fn mul(self, rhs: Radians) -> Self::Output {
+        Radians(self * rhs.0)
     }
 }
 
 impl Div<f32> for Radians {
-    type Output = Radians;
+    type Output = Self;
 
     fn div(self, rhs: f32) -> Self::Output {
         Radians(self.0 / rhs)
     }
 }
+
+impl Div for Radians {
+    type Output = Self;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        Self(self.0 / rhs.0)
+    }
+}

examples/loading_spinners/src/circular.rs

@@ -8,10 +8,9 @@ use iced::mouse;
 use iced::time::Instant;
 use iced::widget::canvas;
 use iced::window::{self, RedrawRequest};
-use iced::Radians;
 use iced::{
-    Background, Color, Element, Event, Length, Rectangle, Renderer, Size,
+    Background, Color, Element, Event, Length, Radians, Rectangle, Renderer,
-    Vector,
+    Size, Vector,
 };
 
 use super::easing::{self, Easing};
@@ -140,7 +139,8 @@ impl Animation {
                 progress: 0.0,
                 rotation: rotation.wrapping_add(
                     BASE_ROTATION_SPEED.wrapping_add(
-                        ((WRAP_ANGLE.0 / (2.0 * PI)) * u32::MAX as f32) as u32,
+                        (f64::from(WRAP_ANGLE / (2.0 * Radians::PI)) * f64::MAX)
+                            as u32,
                     ),
                 ),
                 last: now,
@@ -319,7 +319,7 @@ where
 
             let mut builder = canvas::path::Builder::new();
 
-            let start = iced::Radians(state.animation.rotation() * 2.0 * PI);
+            let start = Radians(state.animation.rotation() * 2.0 * PI);
 
             match state.animation {
                 Animation::Expanding { progress, .. } => {