Inline more

Author: Jondolf

crates/bevy_math/src/primitives/dim2.rs

@@ -233,6 +233,7 @@ impl Primitive2d for Segment2d {}
 
 impl Segment2d {
     /// Create a new `Segment2d` from a direction and full length of the segment
+    #[inline(always)]
     pub fn new(direction: Direction2d, length: f32) -> Self {
         Self {
             direction,
@@ -245,6 +246,7 @@ impl Segment2d {
     /// # Panics
     ///
     /// Panics if `point1 == point2`
+    #[inline(always)]
     pub fn from_points(point1: Vec2, point2: Vec2) -> (Self, Vec2) {
         let diff = point2 - point1;
         let length = diff.length();
@@ -257,11 +259,13 @@ impl Segment2d {
     }
 
     /// Get the position of the first point on the line segment
+    #[inline(always)]
     pub fn point1(&self) -> Vec2 {
         *self.direction * -self.half_length
     }
 
     /// Get the position of the second point on the line segment
+    #[inline(always)]
     pub fn point2(&self) -> Vec2 {
         *self.direction * self.half_length
     }
@@ -332,19 +336,22 @@ impl Primitive2d for Triangle2d {}
 
 impl Triangle2d {
     /// Create a new `Triangle2d` from points `a`, `b`, and `c`
+    #[inline(always)]
     pub fn new(a: Vec2, b: Vec2, c: Vec2) -> Self {
         Self {
             vertices: [a, b, c],
         }
     }
 
     /// Get the area of the triangle
+    #[inline(always)]
     pub fn area(&self) -> f32 {
         let [a, b, c] = self.vertices;
         (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)).abs() / 2.0
     }
 
     /// Get the perimeter of the triangle
+    #[inline(always)]
     pub fn perimeter(&self) -> f32 {
         let [a, b, c] = self.vertices;
 
@@ -356,6 +363,7 @@ impl Triangle2d {
     }
 
     /// Get the [`WindingOrder`] of the triangle
+    #[inline(always)]
     #[doc(alias = "orientation")]
     pub fn winding_order(&self) -> WindingOrder {
         let [a, b, c] = self.vertices;
@@ -406,6 +414,7 @@ impl Triangle2d {
 
     /// Reverse the [`WindingOrder`] of the triangle
     /// by swapping the second and third vertices
+    #[inline(always)]
     pub fn reverse(&mut self) {
         self.vertices.swap(1, 2);
     }
@@ -421,35 +430,41 @@ pub struct Rectangle {
 
 impl Rectangle {
     /// Create a new `Rectangle` from a full width and height
+    #[inline(always)]
     pub fn new(width: f32, height: f32) -> Self {
         Self::from_size(Vec2::new(width, height))
     }
 
     /// Create a new `Rectangle` from a given full size
+    #[inline(always)]
     pub fn from_size(size: Vec2) -> Self {
         Self {
             half_size: size / 2.0,
         }
     }
 
     /// Create a new `Rectangle` from two corner points
+    #[inline(always)]
     pub fn from_corners(point1: Vec2, point2: Vec2) -> Self {
         Self {
             half_size: (point2 - point1).abs() / 2.0,
         }
     }
 
     /// Get the size of the rectangle
+    #[inline(always)]
     pub fn size(&self) -> Vec2 {
         2.0 * self.half_size
     }
 
     /// Get the area of the rectangle
+    #[inline(always)]
     pub fn area(&self) -> f32 {
         4.0 * self.half_size.x * self.half_size.y
     }
 
     /// Get the perimeter of the rectangle
+    #[inline(always)]
     pub fn perimeter(&self) -> f32 {
         4.0 * (self.half_size.x + self.half_size.y)
     }
@@ -537,6 +552,7 @@ impl RegularPolygon {
     /// # Panics
     ///
     /// Panics if `circumradius` is non-positive
+    #[inline(always)]
     pub fn new(circumradius: f32, sides: usize) -> Self {
         assert!(circumradius > 0.0, "polygon has a non-positive radius");
         assert!(sides > 2, "polygon has less than 3 sides");
@@ -551,31 +567,36 @@ impl RegularPolygon {
 
     /// Get the radius of the circumcircle on which all vertices
     /// of the regular polygon lie
+    #[inline(always)]
     pub fn circumradius(&self) -> f32 {
         self.circumcircle.radius
     }
 
     /// Get the inradius or apothem of the regular polygon.
     /// This is the radius of the largest circle that can
     /// be drawn within the polygon
+    #[inline(always)]
     #[doc(alias = "apothem")]
     pub fn inradius(&self) -> f32 {
         self.circumradius() * (PI / self.sides as f32).cos()
     }
 
     /// Get the length of one side of the regular polygon
+    #[inline(always)]
     pub fn side_length(&self) -> f32 {
         2.0 * self.circumradius() * (PI / self.sides as f32).sin()
     }
 
     /// Get the area of the regular polygon
+    #[inline(always)]
     pub fn area(&self) -> f32 {
         let angle: f32 = 2.0 * PI / (self.sides as f32);
         (self.sides as f32) * self.circumradius().powi(2) * angle.sin() / 2.0
     }
 
     /// Get the perimeter of the regular polygon.
     /// This is the sum of its sides
+    #[inline(always)]
     pub fn perimeter(&self) -> f32 {
         self.sides as f32 * self.side_length()
     }
@@ -584,6 +605,7 @@ impl RegularPolygon {
     ///
     /// This is the angle formed by two adjacent sides with points
     /// within the angle being in the interior of the polygon
+    #[inline(always)]
     pub fn internal_angle_degrees(&self) -> f32 {
         (self.sides - 2) as f32 / self.sides as f32 * 180.0
     }
@@ -592,6 +614,7 @@ impl RegularPolygon {
     ///
     /// This is the angle formed by two adjacent sides with points
     /// within the angle being in the interior of the polygon
+    #[inline(always)]
     pub fn internal_angle_radians(&self) -> f32 {
         (self.sides - 2) as f32 * PI / self.sides as f32
     }
@@ -600,6 +623,7 @@ impl RegularPolygon {
     ///
     /// This is the angle formed by two adjacent sides with points
     /// within the angle being in the exterior of the polygon
+    #[inline(always)]
     pub fn external_angle_degrees(&self) -> f32 {
         360.0 / self.sides as f32
     }
@@ -608,6 +632,7 @@ impl RegularPolygon {
     ///
     /// This is the angle formed by two adjacent sides with points
     /// within the angle being in the exterior of the polygon
+    #[inline(always)]
     pub fn external_angle_radians(&self) -> f32 {
         2.0 * PI / self.sides as f32
     }