Add and impl Primitives

crates/bevy_math/src/primitives/dim2.rs

@@ -34,6 +34,30 @@ pub struct Circle {
 }
 impl Primitive2d for Circle {}
 
+impl Circle {
+    /// Create a `Circle` from a radius
+    pub fn new(radius: f32) -> Self {
+        Self { radius }
+    }
+}
+
+/// An ellipse primitive
+#[derive(Clone, Copy, Debug)]
+pub struct Ellipse {
+    /// The "width" of the ellipse
+    pub width: f32,
+    /// The "height" of the ellipse
+    pub height: f32,
+}
+impl Primitive2d for Ellipse {}
+
+impl Ellipse {
+    /// Create a new `Ellipse` from a "width" and a "height"
+    pub fn new(width: f32, height: f32) -> Self {
+        Self { width, height }
+    }
+}
+
 /// An unbounded plane in 2D space. It forms a separating surface through the origin,
 /// stretching infinitely far
 #[derive(Clone, Copy, Debug)]
@@ -43,6 +67,13 @@ pub struct Plane2d {
 }
 impl Primitive2d for Plane2d {}
 
+impl Plane2d {
+    /// Create a new `Plane2d` from the normal of the plane
+    pub fn new(normal: Direction2d) -> Self {
+        Self { normal }
+    }
+}
+
 /// An infinite line along a direction in 2D space.
 ///
 /// For a finite line: [`Segment2d`]
@@ -108,6 +139,13 @@ pub struct Polyline2d<const N: usize> {
 }
 impl<const N: usize> Primitive2d for Polyline2d<N> {}
 
+impl<const N: usize> Polyline2d<N> {
+    /// Create a new `Polyline2d` from an array of vertices
+    pub fn new(vertices: [Vec2; N]) -> Self {
+        Self { vertices }
+    }
+}
+
 /// A series of connected line segments in 2D space, allocated on the heap
 /// in a `Box<[Vec2]>`.
 ///
@@ -119,6 +157,13 @@ pub struct BoxedPolyline2d {
 }
 impl Primitive2d for BoxedPolyline2d {}
 
+impl BoxedPolyline2d {
+    /// Create a new `Polyline2d` from an array of vertices
+    pub fn new(vertices: Box<[Vec2]>) -> Self {
+        Self { vertices }
+    }
+}
+
 /// A triangle in 2D space
 #[derive(Clone, Debug)]
 pub struct Triangle2d {
@@ -127,6 +172,13 @@ pub struct Triangle2d {
 }
 impl Primitive2d for Triangle2d {}
 
+impl Triangle2d {
+    /// Create a new `Triangle2d` from a list of Vertices
+    pub fn new(vertices: [Vec2; 3]) -> Self {
+        Self { vertices }
+    }
+}
+
 /// A rectangle primitive
 #[doc(alias = "Quad")]
 #[derive(Clone, Copy, Debug)]
@@ -158,22 +210,36 @@ impl Rectangle {
 /// For a version without generics: [`BoxedPolygon`]
 #[derive(Clone, Debug)]
 pub struct Polygon<const N: usize> {
-    /// The vertices of the polygon
+    /// The vertices of the `Polygon`
     pub vertices: [Vec2; N],
 }
 impl<const N: usize> Primitive2d for Polygon<N> {}
 
+impl<const N: usize> Polygon<N> {
+    /// Create a new `Polygon` from an array of vertices
+    pub fn new(vertices: [Vec2; N]) -> Self {
+        Self { vertices }
+    }
+}
+
 /// A polygon with a variable number of vertices, allocated on the heap
 /// in a `Box<[Vec2]>`.
 ///
 /// For a version without alloc: [`Polygon`]
 #[derive(Clone, Debug)]
 pub struct BoxedPolygon {
-    /// The vertices of the polygon
+    /// The vertices of the `BoxedPolygon`
     pub vertices: Box<[Vec2]>,
 }
 impl Primitive2d for BoxedPolygon {}
 
+impl BoxedPolygon {
+    /// Create a new `BoxedPolygon` from an array of vertices
+    pub fn new(vertices: Box<[Vec2]>) -> Self {
+        Self { vertices }
+    }
+}
+
 /// A polygon where all vertices lie on a circle, equally far apart
 #[derive(Clone, Copy, Debug)]
 pub struct RegularPolygon {
@@ -183,3 +249,14 @@ pub struct RegularPolygon {
     pub sides: usize,
 }
 impl Primitive2d for RegularPolygon {}
+
+impl RegularPolygon {
+    /// Create a new `RegularPolygon`
+    /// from a circumcircle and number of sides
+    pub fn new(circumcircle: Circle, sides: usize) -> Self {
+        Self {
+            circumcircle,
+            sides,
+        }
+    }
+}

crates/bevy_math/src/primitives/dim3.rs

@@ -34,6 +34,13 @@ pub struct Sphere {
 }
 impl Primitive3d for Sphere {}
 
+impl Sphere {
+    /// Create a new `Sphere` from a radius
+    pub fn new(radius: f32) -> Self {
+        Self { radius }
+    }
+}
+
 /// An unbounded plane in 3D space. It forms a separating surface through the origin,
 /// stretching infinitely far
 #[derive(Clone, Copy, Debug)]
@@ -43,6 +50,13 @@ pub struct Plane3d {
 }
 impl Primitive3d for Plane3d {}
 
+impl Plane3d {
+    /// Create a new `Plane3d` from the normal of the plane
+    pub fn new(normal: Direction3d) -> Self {
+        Self { normal }
+    }
+}
+
 /// An infinite line along a direction in 3D space.
 ///
 /// For a finite line: [`Segment3d`]
@@ -53,6 +67,13 @@ pub struct Line3d {
 }
 impl Primitive3d for Line3d {}
 
+impl Line3d {
+    /// Create a new `Line3d` from the direction of the line
+    pub fn new(direction: Direction3d) -> Self {
+        Self { direction }
+    }
+}
+
 /// A segment of a line along a direction in 3D space.
 #[doc(alias = "LineSegment3d")]
 #[derive(Clone, Debug)]
@@ -107,6 +128,13 @@ pub struct Polyline3d<const N: usize> {
 }
 impl<const N: usize> Primitive3d for Polyline3d<N> {}
 
+impl<const N: usize> Polyline3d<N> {
+    /// Create a new `Polyline3d` from a list of vertices
+    pub fn new(vertices: [Vec3; N]) -> Self {
+        Self { vertices }
+    }
+}
+
 /// A series of connected line segments in 3D space, allocated on the heap
 /// in a `Box<[Vec3]>`.
 ///
@@ -118,6 +146,13 @@ pub struct BoxedPolyline3d {
 }
 impl Primitive3d for BoxedPolyline3d {}
 
+impl BoxedPolyline3d {
+    /// Create a new `BoxedPolyline3d` from a list of vertices
+    pub fn new(vertices: Box<[Vec3]>) -> Self {
+        Self { vertices }
+    }
+}
+
 /// A cuboid primitive, more commonly known as a box.
 #[derive(Clone, Copy, Debug)]
 pub struct Cuboid {
@@ -171,3 +206,76 @@ pub struct Capsule {
 }
 impl super::Primitive2d for Capsule {}
 impl Primitive3d for Capsule {}
+
+impl Capsule {
+    /// Create a new `Capsule` from a radius and half-length
+    pub fn new(radius: f32, half_length: f32) -> Self {
+        Self {
+            radius,
+            half_length,
+        }
+    }
+}
+
+/// A cone primitive.
+#[derive(Clone, Copy, Debug)]
+pub struct Cone {
+    /// radius of the base
+    pub radius: f32,
+    /// height of the cone
+    pub height: f32,
+}
+impl Primitive3d for Cone {}
+
+impl Cone {
+    /// Create a new `Cone` from a radius and height
+    pub fn new(radius: f32, height: f32) -> Self {
+        Self { radius, height }
+    }
+}
+
+/// A conical frustum primitive.
+/// A conical frustum can be created
+/// by slicing off a section of a cone.
+#[derive(Clone, Copy, Debug)]
+pub struct ConicalFrustum {
+    /// Radius of the top of the frustum
+    pub radius_top: f32,
+    /// Radius of the base of the frustum
+    pub radius_bottom: f32,
+    /// Height of the frustum
+    pub height: f32,
+}
+impl Primitive3d for ConicalFrustum {}
+
+impl ConicalFrustum {
+    /// Create a new `ConicalFrustum` from a top
+    /// radius, bottom radius, and height
+    pub fn new(radius_top: f32, radius_bottom: f32, height: f32) -> Self {
+        Self {
+            radius_top,
+            radius_bottom,
+            height,
+        }
+    }
+}
+
+/// A torus (AKA donut) primitive.
+#[derive(Clone, Copy, Debug)]
+pub struct Torus {
+    /// The radius of the overall shape
+    pub radius: f32,
+    /// The radius of the ring
+    pub ring_radius: f32,
+}
+impl Primitive3d for Torus {}
+
+impl Torus {
+    /// Create a new `Torus` from a radius and ring radius
+    pub fn new(radius: f32, ring_radius: f32) -> Self {
+        Self {
+            radius,
+            ring_radius,
+        }
+    }
+}