Change the orientation of arc primitives to vertically symmetrical.

Author: spectria-limina

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

@@ -1,12 +1,11 @@
 //! Contains [`Bounded2d`] implementations for [geometric primitives](crate::primitives).
 
-use std::f32::consts::PI;
-
 use glam::{Mat2, Vec2};
 
 use crate::primitives::{
-    Arc2d, BoxedPolygon, BoxedPolyline2d, Capsule2d, Circle, CircularSector, Direction2d, Ellipse,
-    Line2d, Plane2d, Polygon, Polyline2d, Rectangle, RegularPolygon, Segment2d, Triangle2d,
+    Arc2d, BoxedPolygon, BoxedPolyline2d, Capsule2d, Circle, CircularSector, CircularSegment,
+    Direction2d, Ellipse, Line2d, Plane2d, Polygon, Polyline2d, Rectangle, RegularPolygon,
+    Segment2d, Triangle2d,
 };
 
 use super::{Aabb2d, Bounded2d, BoundingCircle};
@@ -23,31 +22,23 @@ impl Bounded2d for Circle {
 
 impl Bounded2d for Arc2d {
     fn aabb_2d(&self, translation: Vec2, rotation: f32) -> Aabb2d {
-        // For a sufficiently wide arc, the bounding points in a given direction will be the outer
-        // limits of a circle centered at the origin.
-        // For smaller arcs, the two endpoints of the arc could also be bounding points,
-        // but the start point is always axis-aligned so it's included as one of the circular limits.
+        // Because our arcs are always symmetrical around Vec::Y, the uppermost point and the two endpoints will always be extrema.
+        // For an arc that is greater than a semicircle, radii to the left and right will also be bounding points.
         // This gives five possible bounding points, so we will lay them out in an array and then
         // select the appropriate slice to compute the bounding box of.
-        let mut circle_bounds = [
-            self.end(),
-            self.radius * Vec2::X,
+        let all_bounds = [
+            self.left_endpoint(),
+            self.right_endpoint(),
             self.radius * Vec2::Y,
+            self.radius * Vec2::X,
             self.radius * -Vec2::X,
-            self.radius * -Vec2::Y,
         ];
-        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;
-        Aabb2d::from_point_cloud(
-            translation,
-            rotation,
-            &circle_bounds[0..(2 + quarter_turns)],
-        )
+        let bounds = if self.is_major() {
+            &all_bounds[0..5]
+        } else {
+            &all_bounds[0..3]
+        };
+        Aabb2d::from_point_cloud(translation, rotation, bounds)
     }
 
     fn bounding_circle(&self, translation: Vec2, rotation: f32) -> BoundingCircle {
@@ -68,29 +59,23 @@ impl Bounded2d for Arc2d {
 impl Bounded2d for CircularSector {
     fn aabb_2d(&self, translation: Vec2, rotation: f32) -> Aabb2d {
         // This is identical to the implementation for Arc2d, above, with the additional possibility of the
-        // origin point, the center of the arc, acting as a bounding point.
+        // origin point, the center of the arc, acting as a bounding point when the arc is minor.
         //
-        // See comments above for discussion.
-        let mut circle_bounds = [
+        // See comments above for an explanation of the logic.
+        let all_bounds = [
             Vec2::ZERO,
-            self.arc.end(),
-            self.arc.radius * Vec2::X,
+            self.arc.left_endpoint(),
+            self.arc.right_endpoint(),
             self.arc.radius * Vec2::Y,
+            self.arc.radius * Vec2::X,
             self.arc.radius * -Vec2::X,
-            self.arc.radius * -Vec2::Y,
         ];
-        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.arc.angle().abs() / (PI / 2.0)).min(3.0) as usize;
-        Aabb2d::from_point_cloud(
-            translation,
-            rotation,
-            &circle_bounds[0..(3 + quarter_turns)],
-        )
+        let bounds = if self.arc.is_major() {
+            &all_bounds[1..6]
+        } else {
+            &all_bounds[0..4]
+        };
+        Aabb2d::from_point_cloud(translation, rotation, bounds)
     }
 
     fn bounding_circle(&self, translation: Vec2, rotation: f32) -> BoundingCircle {
@@ -101,10 +86,9 @@ impl Bounded2d for CircularSector {
             BoundingCircle::new(translation, self.arc.radius)
         } else if self.arc.chord_length() < 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.
+            // so the bounding circle is centered on the midpoint of the radius.
             let half_radius = self.arc.radius / 2.0;
-            let angle = Vec2::from_angle(self.arc.half_angle + rotation);
-            let center = half_radius * angle;
+            let center = half_radius * Vec2::Y;
             BoundingCircle::new(center + translation, half_radius)
         } else {
             // Otherwise, the widest distance between two points is the chord,
@@ -115,6 +99,16 @@ impl Bounded2d for CircularSector {
     }
 }
 
+impl Bounded2d for CircularSegment {
+    fn aabb_2d(&self, translation: Vec2, rotation: f32) -> Aabb2d {
+        self.arc.aabb_2d(translation, rotation)
+    }
+
+    fn bounding_circle(&self, translation: Vec2, rotation: f32) -> BoundingCircle {
+        self.arc.bounding_circle(translation, rotation)
+    }
+}
+
 impl Bounded2d for Ellipse {
     fn aabb_2d(&self, translation: Vec2, rotation: f32) -> Aabb2d {
         //           V = (hh * cos(beta), hh * sin(beta))

crates/bevy_math/src/primitives/dim2.rs

@@ -186,10 +186,9 @@ const HALF_PI: f32 = PI / 2.0;
 /// If you want to include only the space inside the convex hull of the arc,
 /// use [`CircularSegment`].
 ///
-/// The arc is drawn starting from [`Vec2::X`], going counterclockwise.
-/// To orient the arc differently, apply a rotation.
-/// The arc is drawn with the center of its circle at the origin (0, 0),
-/// meaning that the center may not be inside its convex hull.
+/// The arc is drawn starting from [`Vec2::Y`], extending by `half_angle` radians on
+/// either side. The center of the circle is the origin [`Vec2::ZERO`]. Note that this
+/// means that the origin may not be within the `Arc2d`'s convex hull.
 #[derive(Clone, Copy, Debug, PartialEq)]
 #[doc(alias("CircularArc", "CircleArc"))]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
@@ -259,28 +258,28 @@ impl Arc2d {
         self.angle() * self.radius
     }
 
-    /// Get the start point of the arc
+    /// Get the right-hand end point of the arc
     #[inline(always)]
-    pub fn start(&self) -> Vec2 {
-        Vec2::new(self.radius, 0.0)
+    pub fn right_endpoint(&self) -> Vec2 {
+        self.radius * Vec2::from_angle(HALF_PI - self.half_angle)
     }
 
-    /// Get the end point of the arc
+    /// Get the left-hand end point of the arc
     #[inline(always)]
-    pub fn end(&self) -> Vec2 {
-        self.radius * Vec2::from_angle(self.angle())
+    pub fn left_endpoint(&self) -> Vec2 {
+        self.radius * Vec2::from_angle(HALF_PI + self.half_angle)
     }
 
     /// Get the endpoints of the arc
     #[inline(always)]
     pub fn endpoints(&self) -> [Vec2; 2] {
-        [self.start(), self.end()]
+        [self.left_endpoint(), self.right_endpoint()]
     }
 
     /// Get the midpoint of the arc
     #[inline]
     pub fn midpoint(&self) -> Vec2 {
-        self.radius * Vec2::from_angle(self.half_angle)
+        self.radius * Vec2::Y
     }
 
     /// Get half the length of the chord subtended by the arc
@@ -298,7 +297,7 @@ impl Arc2d {
     /// Get the midpoint of the chord subtended by the arc
     #[inline(always)]
     pub fn chord_midpoint(&self) -> Vec2 {
-        self.apothem() * Vec2::from_angle(self.half_angle)
+        self.apothem() * Vec2::Y
     }
 
     /// Get the length of the apothem of this arc, that is,
@@ -347,7 +346,7 @@ impl Arc2d {
 
 /// A primitive representing a circular sector: a pie slice of a circle.
 ///
-/// The sector is drawn starting from [`Vec2::X`], going counterclockwise.
+/// The segment is drawn starting from [`Vec2::Y`], extending equally on either side.
 /// To orient the sector differently, apply a rotation.
 /// The sector is drawn with the center of its circle at the origin [`Vec2::ZERO`].
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -409,7 +408,7 @@ impl CircularSector {
 /// 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.
+/// The segment is drawn starting from [`Vec2::Y`], extending equally on either side.
 /// To orient the segment differently, apply a rotation.
 /// The segment is drawn with the center of its circle at the origin [`Vec2::ZERO`].
 /// When positioning a segment, the [`apothem`](Arc2d::apothem) function may be particularly useful,

crates/bevy_render/src/mesh/primitives/dim2.rs

@@ -1,3 +1,5 @@
+use std::f32::consts::PI;
+
 use crate::{
     mesh::{Indices, Mesh},
     render_asset::RenderAssetUsages,
@@ -81,6 +83,9 @@ impl From<CircleMeshBuilder> for Mesh {
 }
 
 /// A builder used for creating a [`Mesh`] with a [`CircularSector`] shape.
+///
+/// The resulting mesh will have a UV-map such that the center of the circle is
+/// at the centure of the texture.
 #[derive(Clone, Copy, Debug)]
 pub struct CircularSectorMeshBuilder {
     /// The sector shape.
@@ -129,10 +134,12 @@ impl CircularSectorMeshBuilder {
         positions.push([0.0; 3]);
         uvs.push([0.5; 2]);
 
-        let last = (self.resolution - 1) as f32;
+        let first_angle = PI / 2.0 - self.sector.arc.half_angle;
+        let last_angle = PI / 2.0 + self.sector.arc.half_angle;
+        let last_i = (self.resolution - 1) as f32;
         for i in 0..self.resolution {
             // Compute vertex position at angle theta
-            let angle = Vec2::from_angle(f32::lerp(0.0, self.sector.arc.angle(), i as f32 / last));
+            let angle = Vec2::from_angle(f32::lerp(first_angle, last_angle, i as f32 / last_i));
 
             positions.push([
                 angle.x * self.sector.arc.radius,
@@ -170,6 +177,9 @@ impl Meshable for CircularSector {
 }
 
 impl From<CircularSector> for Mesh {
+    /// Converts this sector into a [`Mesh`] using a default [`CircularSectorMeshBuilder`].
+    ///
+    /// See the documentation of [`CircularSectorMeshBuilder`] for more details.
     fn from(sector: CircularSector) -> Self {
         sector.mesh().build()
     }
@@ -182,6 +192,9 @@ impl From<CircularSectorMeshBuilder> for Mesh {
 }
 
 /// A builder used for creating a [`Mesh`] with a [`CircularSegment`] shape.
+///
+/// The resulting mesh will have a UV-map such that the center of the circle is
+/// at the centure of the texture.
 #[derive(Clone, Copy, Debug)]
 pub struct CircularSegmentMeshBuilder {
     /// The segment shape.
@@ -231,10 +244,12 @@ impl CircularSegmentMeshBuilder {
         positions.push([chord_midpoint.x, chord_midpoint.y, 0.0]);
         uvs.push([0.5 + chord_midpoint.x * 0.5, 0.5 + chord_midpoint.y * 0.5]);
 
-        let last = (self.resolution - 1) as f32;
+        let first_angle = PI / 2.0 - self.segment.arc.half_angle;
+        let last_angle = PI / 2.0 + self.segment.arc.half_angle;
+        let last_i = (self.resolution - 1) as f32;
         for i in 0..self.resolution {
             // Compute vertex position at angle theta
-            let angle = Vec2::from_angle(f32::lerp(0.0, self.segment.arc.angle(), i as f32 / last));
+            let angle = Vec2::from_angle(f32::lerp(first_angle, last_angle, i as f32 / last_i));
 
             positions.push([
                 angle.x * self.segment.arc.radius,
@@ -272,6 +287,9 @@ impl Meshable for CircularSegment {
 }
 
 impl From<CircularSegment> for Mesh {
+    /// Converts this sector into a [`Mesh`] using a default [`CircularSegmentMeshBuilder`].
+    ///
+    /// See the documentation of [`CircularSegmentMeshBuilder`] for more details.
     fn from(segment: CircularSegment) -> Self {
         segment.mesh().build()
     }

examples/2d/2d_shapes.rs

@@ -29,10 +29,9 @@ fn setup(
     // Circular sector
     let sector = CircularSector::from_radians(50.0, 5.0);
     let mut sector_transform = Transform::from_translation(Vec3::new(-275.0, 0.0, 0.0));
-    // A sector is drawn counterclockwise from the right.
-    // To make it face left, rotate by negative half its angle.
-    // To make it face right, rotate by an additional PI radians.
-    sector_transform.rotate_z(-sector.arc.half_angle + PI);
+    // A sector is drawn symmetrically from the top.
+    // To make it face right, we must rotate it to the left by 90 degrees.
+    sector_transform.rotate_z(PI / 2.0);
     commands.spawn(MaterialMesh2dBundle {
         mesh: meshes.add(sector).into(),
         material: materials.add(Color::YELLOW),
@@ -51,15 +50,11 @@ fn setup(
     });
 
     // Circular segment
-    let segment = CircularSegment::from_radians(50.0, 2.5);
-    let mut segment_transform = Transform::from_translation(Vec3::new(-150.0, 0.0, 0.0));
-    // A segment is drawn counterclockwise from the right.
-    // To make it symmetrical about the X axis, rotate by negative half its angle.
-    // To make it symmetrical about the Y axis, rotate by an additional PI/2 radians.
-    segment_transform.rotate_z(-segment.arc.half_angle + PI / 2.0);
+    let segment = CircularSegment::from_degrees(50.0, 135.0);
     // The segment is drawn with the center as the center of the circle.
     // By subtracting the apothem, we move the segment down so that it touches the line x = 0.
-    segment_transform.translation.y -= segment.arc.apothem();
+    let segment_transform =
+        Transform::from_translation(Vec3::new(-150.0, -segment.arc.apothem(), 0.0));
     commands.spawn(MaterialMesh2dBundle {
         mesh: meshes.add(segment).into(),
         material: materials.add(Color::MIDNIGHT_BLUE),