Implement bounding volumes for primitive shapes (#11336)

# Objective

Closes #10570.

#10946 added bounding volume types and traits, but didn't use them for
anything yet. This PR implements `Bounded2d` and `Bounded3d` for Bevy's
primitive shapes.

## Solution

Implement `Bounded2d` and `Bounded3d` for primitive shapes. This allows
computing AABBs and bounding circles/spheres for them.

For most shapes, there are several ways of implementing bounding
volumes. I took inspiration from [Parry's bounding
volumes](https://github.com/dimforge/parry/tree/master/src/bounding_volume),
[Inigo Quilez](http://iquilezles.org/articles/diskbbox/), and figured
out the rest myself using geometry. I tried to comment all slightly
non-trivial or unclear math to make it understandable.

Parry uses support mapping (finding the farthest point in some direction
for convex shapes) for some AABBs like cones, cylinders, and line
segments. This involves several quat operations and normalizations, so I
opted for the simpler and more efficient geometric approaches shown in
[Quilez's article](http://iquilezles.org/articles/diskbbox/).

Below you can see some of the bounding volumes working in 2D and 3D.
Note that I can't conveniently add these examples yet because they use
primitive shape meshing, which is still WIP.


https://github.com/bevyengine/bevy/assets/57632562/4465cbc6-285b-4c71-b62d-a2b3ee16f8b4


https://github.com/bevyengine/bevy/assets/57632562/94b4ac84-a092-46d7-b438-ce2e971496a4

---

## Changelog

- Implemented `Bounded2d`/`Bounded3d` for primitive shapes
- Added `from_point_cloud` method for bounding volumes (used by many
bounding implementations)
- Added `point_cloud_2d/3d_center` and `rotate_vec2` utility functions
- Added `RegularPolygon::vertices` method (used in regular polygon AABB
construction)
- Added `Triangle::circumcenter` method (used in triangle bounding
circle construction)
- Added bounding circle/sphere creation from AABBs and vice versa

## Extra

Do we want to implement `Bounded2d` for some "3D-ish" shapes too? For
example, capsules are sort of dimension-agnostic and useful for 2D, so I
think that would be good to implement. But a cylinder in 2D is just a
rectangle, and a cone is a triangle, so they wouldn't make as much sense
to me. A conical frustum would be an isosceles trapezoid, which could be
useful, but I'm not sure if computing the 2D AABB of a 3D frustum makes
semantic sense.

Author: Jondolf

crates/bevy_math/src/bounding/bounded2d.rs renamed to crates/bevy_math/src/bounding/bounded2d/mod.rs

@@ -1,6 +1,22 @@
+mod primitive_impls;
+
+use glam::Mat2;
+
 use super::BoundingVolume;
 use crate::prelude::Vec2;
 
+/// Computes the geometric center of the given set of points.
+#[inline(always)]
+fn point_cloud_2d_center(points: &[Vec2]) -> Vec2 {
+    assert!(
+        !points.is_empty(),
+        "cannot compute the center of an empty set of points"
+    );
+
+    let denom = 1.0 / points.len() as f32;
+    points.iter().fold(Vec2::ZERO, |acc, point| acc + *point) * denom
+}
+
 /// A trait with methods that return 2D bounded volumes for a shape
 pub trait Bounded2d {
     /// Get an axis-aligned bounding box for the shape with the given translation and rotation.
@@ -21,6 +37,41 @@ pub struct Aabb2d {
     pub max: Vec2,
 }
 
+impl Aabb2d {
+    /// Computes the smallest [`Aabb2d`] containing the given set of points,
+    /// transformed by `translation` and `rotation`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given set of points is empty.
+    #[inline(always)]
+    pub fn from_point_cloud(translation: Vec2, rotation: f32, points: &[Vec2]) -> Aabb2d {
+        // Transform all points by rotation
+        let rotation_mat = Mat2::from_angle(rotation);
+        let mut iter = points.iter().map(|point| rotation_mat * *point);
+
+        let first = iter
+            .next()
+            .expect("point cloud must contain at least one point for Aabb2d construction");
+
+        let (min, max) = iter.fold((first, first), |(prev_min, prev_max), point| {
+            (point.min(prev_min), point.max(prev_max))
+        });
+
+        Aabb2d {
+            min: min + translation,
+            max: max + translation,
+        }
+    }
+
+    /// Computes the smallest [`BoundingCircle`] containing this [`Aabb2d`].
+    #[inline(always)]
+    pub fn bounding_circle(&self) -> BoundingCircle {
+        let radius = self.min.distance(self.max) / 2.0;
+        BoundingCircle::new(self.center(), radius)
+    }
+}
+
 impl BoundingVolume for Aabb2d {
     type Position = Vec2;
     type HalfSize = Vec2;
@@ -207,11 +258,43 @@ impl BoundingCircle {
         }
     }
 
+    /// Computes a [`BoundingCircle`] containing the given set of points,
+    /// transformed by `translation` and `rotation`.
+    ///
+    /// The bounding circle is not guaranteed to be the smallest possible.
+    #[inline(always)]
+    pub fn from_point_cloud(translation: Vec2, rotation: f32, points: &[Vec2]) -> BoundingCircle {
+        let center = point_cloud_2d_center(points);
+        let mut radius_squared = 0.0;
+
+        for point in points {
+            // Get squared version to avoid unnecessary sqrt calls
+            let distance_squared = point.distance_squared(center);
+            if distance_squared > radius_squared {
+                radius_squared = distance_squared;
+            }
+        }
+
+        BoundingCircle::new(
+            Mat2::from_angle(rotation) * center + translation,
+            radius_squared.sqrt(),
+        )
+    }
+
     /// Get the radius of the bounding circle
     #[inline(always)]
     pub fn radius(&self) -> f32 {
         self.circle.radius
     }
+
+    /// Computes the smallest [`Aabb2d`] containing this [`BoundingCircle`].
+    #[inline(always)]
+    pub fn aabb_2d(&self) -> Aabb2d {
+        Aabb2d {
+            min: self.center - Vec2::splat(self.radius()),
+            max: self.center + Vec2::splat(self.radius()),
+        }
+    }
 }
 
 impl BoundingVolume for BoundingCircle {