Add CircularSegment primitve as well.

Author: spectria-limina

crates/bevy_math/src/bounding/bounded2d/primitive_impls.rs

@@ -36,13 +36,13 @@ impl Bounded2d for Arc {
             self.radius * -Vec2::X,
             self.radius * -Vec2::Y,
         ];
-        if self.angle.is_sign_negative() {
+        if self.half_angle.is_sign_negative() {
             // If we have a negative angle, we are going the opposite direction, so negate the Y-axis points.
             circle_bounds[2] = -circle_bounds[2];
             circle_bounds[4] = -circle_bounds[4];
         }
         // The number of quarter turns tells us how many extra points to include, between 0 and 3.
-        let quarter_turns = f32::floor(self.angle.abs() / (PI / 2.0)).min(3.0) as usize;
+        let quarter_turns = f32::floor(self.angle().abs() / (PI / 2.0)).min(3.0) as usize;
         Aabb2d::from_point_cloud(
             translation,
             rotation,
@@ -59,10 +59,8 @@ impl Bounded2d for Arc {
         } else {
             // Otherwise, the widest distance between two points is the chord,
             // so a circle of that diameter around the midpoint will contain the entire arc.
-            let angle = self.angle + rotation;
-            let center =
-                Vec2::new(self.chord_midpoint_radius(), 0.0).rotate(Vec2::from_angle(angle));
-            BoundingCircle::new(center, self.half_chord_length())
+            let center = self.chord_midpoint().rotate(Vec2::from_angle(rotation));
+            BoundingCircle::new(center + translation, self.half_chord_len())
         }
     }
 }
@@ -75,19 +73,19 @@ impl Bounded2d for CircularSector {
         // See comments above for discussion.
         let mut circle_bounds = [
             Vec2::ZERO,
-            self.arc().end(),
-            self.radius * Vec2::X,
-            self.radius * Vec2::Y,
-            self.radius * -Vec2::X,
-            self.radius * -Vec2::Y,
+            self.arc.end(),
+            self.arc.radius * Vec2::X,
+            self.arc.radius * Vec2::Y,
+            self.arc.radius * -Vec2::X,
+            self.arc.radius * -Vec2::Y,
         ];
-        if self.angle.is_sign_negative() {
+        if self.arc.angle().is_sign_negative() {
             // If we have a negative angle, we are going the opposite direction, so negate the Y-axis points.
             circle_bounds[3] = -circle_bounds[3];
             circle_bounds[5] = -circle_bounds[5];
         }
         // The number of quarter turns tells us how many extra points to include, between 0 and 3.
-        let quarter_turns = f32::floor(self.angle.abs() / (PI / 2.0)).min(3.0) as usize;
+        let quarter_turns = f32::floor(self.arc.angle().abs() / (PI / 2.0)).min(3.0) as usize;
         Aabb2d::from_point_cloud(
             translation,
             rotation,
@@ -97,22 +95,22 @@ impl Bounded2d for CircularSector {
 
     fn bounding_circle(&self, translation: Vec2, rotation: f32) -> BoundingCircle {
         // There are three possibilities for the bounding circle.
-        if self.arc().is_major() {
+        if self.arc.is_major() {
             // If the arc is major, then the widest distance between two points is a diameter of the arc's circle;
             // therefore, that circle is the bounding radius.
-            BoundingCircle::new(translation, self.radius)
-        } else if self.arc().chord_length() < self.radius {
+            BoundingCircle::new(translation, self.arc.radius)
+        } else if self.arc.chord_len() < self.arc.radius {
             // If the chord length is smaller than the radius, then the radius is the widest distance between two points,
             // so the radius is the diameter of the bounding circle.
-            let angle = Vec2::from_angle(self.angle / 2.0 + rotation);
-            let center = angle * self.radius / 2.0;
-            BoundingCircle::new(center, self.radius / 2.0)
+            let half_radius = self.arc.radius / 2.0;
+            let angle = Vec2::from_angle(self.arc.half_angle + rotation);
+            let center = half_radius * angle;
+            BoundingCircle::new(center + translation, half_radius)
         } else {
             // Otherwise, the widest distance between two points is the chord,
             // so a circle of that diameter around the midpoint will contain the entire arc.
-            let angle = Vec2::from_angle(self.angle / 2.0 + rotation);
-            let center = angle * self.arc().chord_midpoint_radius();
-            BoundingCircle::new(center, self.arc().half_chord_length())
+            let center = self.arc.chord_midpoint().rotate(Vec2::from_angle(rotation));
+            BoundingCircle::new(center + translation, self.arc.half_chord_len())
         }
     }
 }

crates/bevy_math/src/primitives/dim2.rs

@@ -191,8 +191,8 @@ impl Circle {
 pub struct Arc {
     /// The radius of the circle
     pub radius: f32,
-    /// The angle swept out by the arc.
-    pub angle: f32,
+    /// Half the angle swept out by the arc.
+    pub half_angle: f32,
 }
 impl Primitive2d for Arc {}
 
@@ -201,22 +201,31 @@ impl Default for Arc {
     fn default() -> Self {
         Self {
             radius: 0.5,
-            angle: 1.0,
+            half_angle: 0.5,
         }
     }
 }
 
 impl Arc {
     /// Create a new [`Arc`] from a `radius`, and an `angle`
     #[inline(always)]
-    pub const fn new(radius: f32, angle: f32) -> Self {
-        Self { radius, angle }
+    pub fn new(radius: f32, angle: f32) -> Self {
+        Self {
+            radius,
+            half_angle: angle / 2.0,
+        }
+    }
+
+    /// Get the angle of the arc
+    #[inline(always)]
+    pub fn angle(&self) -> f32 {
+        self.half_angle * 2.0
     }
 
     /// Get the length of the arc
     #[inline(always)]
     pub fn length(&self) -> f32 {
-        self.angle * self.radius
+        self.angle() * self.radius
     }
 
     /// Get the start point of the arc
@@ -228,7 +237,7 @@ impl Arc {
     /// Get the end point of the arc
     #[inline(always)]
     pub fn end(&self) -> Vec2 {
-        self.radius * Vec2::from_angle(self.angle)
+        self.radius * Vec2::from_angle(self.angle())
     }
 
     /// Get the endpoints of the arc
@@ -237,34 +246,57 @@ impl Arc {
         [self.start(), self.end()]
     }
 
+    /// Get the midpoint of the arc
+    #[inline]
+    pub fn midpoint(&self) -> Vec2 {
+        self.radius * Vec2::from_angle(self.half_angle)
+    }
+
     /// Get half the length of the chord subtended by the arc
     #[inline(always)]
-    pub fn half_chord_length(&self) -> f32 {
-        self.radius * f32::sin(self.angle / 2.0)
+    pub fn half_chord_len(&self) -> f32 {
+        self.radius * f32::sin(self.half_angle)
     }
 
     /// Get the length of the chord subtended by the arc
     #[inline(always)]
-    pub fn chord_length(&self) -> f32 {
-        2.0 * self.half_chord_length()
+    pub fn chord_len(&self) -> f32 {
+        2.0 * self.half_chord_len()
     }
 
-    /// Get the distance from the center of the circle to the midpoint of the chord.
+    /// Get the midpoint of the chord
     #[inline(always)]
-    pub fn chord_midpoint_radius(&self) -> f32 {
-        f32::sqrt(self.radius.powi(2) - self.half_chord_length().powi(2))
+    pub fn chord_midpoint(&self) -> Vec2 {
+        self.apothem_len() * Vec2::from_angle(self.half_angle)
     }
 
-    /// Get the midpoint of the chord
+    /// Get the length of the apothem of this arc, that is,
+    /// the distance from the center of the circle to the midpoint of the chord.
+    /// Equivalently, the height of the triangle whose base is the chord and whose apex is the center of the circle.
     #[inline(always)]
-    pub fn chord_midpoint(&self) -> Vec2 {
-        Vec2::new(self.chord_midpoint_radius(), 0.0).rotate(Vec2::from_angle(self.angle))
+    pub fn apothem_len(&self) -> f32 {
+        f32::sqrt(self.radius.powi(2) - self.half_chord_len().powi(2))
+    }
+
+    /// Get the legnth of the sagitta of this arc, that is,
+    /// the length of the line between the midpoints of the arc and its chord.
+    /// Equivalently, the height of the triangle whose base is the chord and whose apex is the midpoint of the arc.
+    ///
+    /// If the arc is minor, i.e. less than half the circle, the this will be the difference of the [radius](Self::radius) and the [apothem](Self::apothem).
+    /// If it is [major](Self::major), it will be their sum.
+    #[inline(always)]
+    pub fn sagitta_len(&self) -> f32 {
+        if self.is_major() {
+            self.radius + self.apothem_len()
+        } else {
+            self.radius - self.apothem_len()
+        }
     }
 
     /// Produces true if the arc is at least half a circle.
     #[inline(always)]
     pub fn is_major(&self) -> bool {
-        self.angle >= PI
+        self.angle() >= PI
     }
 }
 
@@ -276,40 +308,80 @@ impl Arc {
 #[derive(Clone, Copy, Debug, PartialEq)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 pub struct CircularSector {
-    /// The radius of the circle
-    pub radius: f32,
-    /// The angle swept out by the sector.
-    pub angle: f32,
+    /// The arc from which this sector is contructed.
+    #[cfg_attr(feature = "seriealize", serde(flatten))]
+    pub arc: Arc,
 }
 impl Primitive2d for CircularSector {}
 
 impl Default for CircularSector {
     // Returns the default [`CircularSector`] with radius `0.5` and angle `1.0`.
     fn default() -> Self {
-        Self {
-            radius: 0.5,
-            angle: 1.0,
-        }
+        Arc::default().into()
+    }
+}
+
+impl From<Arc> for CircularSector {
+    fn from(arc: Arc) -> Self {
+        Self { arc }
     }
 }
 
 impl CircularSector {
-    /// Create a new [`CircularSector`] from a `radius`, and an `angle`
+    /// Create a new [CircularSector] from a `radius`, and an `angle`
     #[inline(always)]
-    pub const fn new(radius: f32, angle: f32) -> Self {
-        Self { radius, angle }
+    pub fn new(radius: f32, angle: f32) -> Self {
+        Arc::new(radius, angle).into()
     }
 
-    /// Produces the arc of this sector
+    /// Returns the area of this sector
     #[inline(always)]
-    pub fn arc(&self) -> Arc {
-        Arc::new(self.radius, self.angle)
+    pub fn area(&self) -> f32 {
+        self.arc.radius.powi(2) * self.arc.half_angle
     }
+}
 
-    /// Returns the area of this sector
+/// A primitive representing a circular segment:
+/// the area enclosed by the arc of a circle and its chord (the line between its endpoints).
+///
+/// The segment is drawn starting from [Vec2::X], going counterclockwise.
+/// To orient the segment differently, apply a rotation.
+/// The segment is drawn with the center of its circle at the origin (0, 0).
+/// When positioning the segment, the [apothem_len](Self::apothem) and [sagitta_len](Sagitta) functions
+/// may be particularly useful.
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+pub struct CircularSegment {
+    /// The arc from which this segment is contructed.
+    #[cfg_attr(feature = "seriealize", serde(flatten))]
+    pub arc: Arc,
+}
+impl Primitive2d for CircularSegment {}
+
+impl Default for CircularSegment {
+    // Returns the default [CircularSegment] with radius `0.5` and angle `1.0`.
+    fn default() -> Self {
+        Arc::default().into()
+    }
+}
+
+impl From<Arc> for CircularSegment {
+    fn from(arc: Arc) -> Self {
+        Self { arc }
+    }
+}
+
+impl CircularSegment {
+    /// Create a new [CircularSegment] from a `radius`, and an `angle`
+    #[inline(always)]
+    pub fn new(radius: f32, angle: f32) -> Self {
+        Arc::new(radius, angle).into()
+    }
+
+    /// Returns the area of this segment
     #[inline(always)]
     pub fn area(&self) -> f32 {
-        self.radius.powi(2) * self.angle / 2.0
+        self.arc.radius.powi(2) * (self.arc.half_angle - self.arc.angle().sin())
     }
 }