Follow-up fixes

Author: Bromeon

godot-core/src/builtin/aabb.rs

@@ -38,14 +38,12 @@ impl Aabb {
     /// Create a new `Aabb` with the first corner at `position` and opposite corner at `end`.
     #[inline]
     pub fn from_corners(position: Vector3, end: Vector3) -> Self {
-        Self {
-            position,
-            size: position + end,
-        }
+        // Cannot use floating point arithmetic in const functions.
+        Self::new(position, end - position)
     }
 
-    /// Returns an AABB with equivalent position and size,
-    /// modified so that the most-negative corner is the origin and the size is positive.
+    /// Returns an AABB with the same geometry, with most-negative corner as `position` and non-negative `size`.
+    #[inline]
     pub fn abs(&self) -> Self {
         Aabb {
             position: self.position + self.size.coord_min(Vector3::ZERO),
@@ -141,6 +139,7 @@ impl Aabb {
     }
 
     /// Returns true if the AABB has a volume, and false if the AABB is flat, linear, empty, or has a negative size.
+    #[inline]
     pub fn has_volume(&self) -> bool {
         self.size.x > 0.0 && self.size.y > 0.0 && self.size.z > 0.0
     }
@@ -168,6 +167,7 @@ impl Aabb {
     }
 
     /// Returns `true` if this AABB is finite, by calling `@GlobalScope.is_finite` on each component.
+    #[inline]
     pub fn is_finite(&self) -> bool {
         self.position.is_finite() && self.size.is_finite()
     }
@@ -187,6 +187,7 @@ impl Aabb {
     }
 
     /// Returns the normalized longest axis of the AABB.
+    #[inline]
     pub fn longest_axis(&self) -> Vector3 {
         match self.longest_axis_index() {
             Vector3Axis::X => Vector3::RIGHT,
@@ -196,16 +197,19 @@ impl Aabb {
     }
 
     /// Returns the index of the longest axis of the AABB (according to Vector3's AXIS_* constants).
+    #[inline]
     pub fn longest_axis_index(&self) -> Vector3Axis {
         self.size.max_axis_index()
     }
 
     /// Returns the scalar length of the longest axis of the AABB.
+    #[inline]
     pub fn longest_axis_size(&self) -> real {
         self.size.x.max(self.size.y.max(self.size.z))
     }
 
     /// Returns the normalized shortest axis of the AABB.
+    #[inline]
     pub fn shortest_axis(&self) -> Vector3 {
         match self.shortest_axis_index() {
             Vector3Axis::X => Vector3::RIGHT,
@@ -215,16 +219,19 @@ impl Aabb {
     }
 
     /// Returns the index of the shortest axis of the AABB (according to Vector3::AXIS* enum).
+    #[inline]
     pub fn shortest_axis_index(&self) -> Vector3Axis {
         self.size.min_axis_index()
     }
 
     /// Returns the scalar length of the shortest axis of the AABB.
+    #[inline]
     pub fn shortest_axis_size(&self) -> real {
         self.size.x.min(self.size.y.min(self.size.z))
     }
 
     /// Returns the support point in a given direction. This is useful for collision detection algorithms.
+    #[inline]
     pub fn support(&self, dir: Vector3) -> Vector3 {
         let half_extents = self.size * 0.5;
         let relative_center_point = self.position + half_extents;
@@ -238,9 +245,12 @@ impl Aabb {
         half_extents * signs + relative_center_point
     }
 
-    /// Returns `true` if the AABB overlaps with `b` (i.e. they have at least one point in common).
+    /// Checks whether two AABBs have at least one point in common.
     ///
-    /// _Godot equivalent: `AABB.intersects(AABB b, bool include_borders = false)`_
+    /// Also returns `true` if the AABBs only touch each other (share a point/edge/face).
+    /// See [`intersects_exclude_borders`][Self::intersects_exclude_borders] if you want to return `false` in that case.
+    ///
+    /// _Godot equivalent: `AABB.intersects(AABB b, bool include_borders = true)`_
     #[inline]
     pub fn intersects(&self, b: &Aabb) -> bool {
         let end = self.end();
@@ -253,9 +263,13 @@ impl Aabb {
             && self.position.z <= end_b.z
     }
 
-    /// Returns `true` if the AABB overlaps with `b` (i.e. they have at least one inner point in common).
+    /// Checks whether two AABBs have at least one _inner_ point in common (not on the borders).
     ///
-    /// _Godot equivalent: `AABB.intersects(AABB b, bool include_borders = true)`_
+    /// Returns `false` if the AABBs only touch each other (share a point/edge/face).
+    /// See [`intersects`][Self::intersects] if you want to return `true` in that case.
+    ///
+    /// _Godot equivalent: `AABB.intersects(AABB b, bool include_borders = false)`_
+    #[inline]
     pub fn intersects_exclude_borders(&self, &b: &Aabb) -> bool {
         let end = self.end();
         let end_b = b.end();
@@ -269,6 +283,7 @@ impl Aabb {
     }
 
     /// Returns `true` if the AABB is on both sides of a plane.
+    #[inline]
     pub fn intersects_plane(&self, plane: &Plane) -> bool {
         // The set of the edges of the AABB.
         let points = [
@@ -301,6 +316,7 @@ impl Aabb {
     ///
     /// # Panics
     /// If `self.size` is negative.
+    #[inline]
     pub fn intersects_ray(&self, from: Vector3, dir: Vector3) -> bool {
         self.assert_nonnegative();
 
@@ -320,6 +336,7 @@ impl Aabb {
     ///
     /// # Panics
     /// If `self.size` is negative.
+    #[inline]
     pub fn intersects_segment(&self, from: Vector3, to: Vector3) -> bool {
         self.assert_nonnegative();
 

godot-core/src/builtin/rect2.rs

@@ -35,6 +35,13 @@ impl Rect2 {
         Self { position, size }
     }
 
+    /// Create a new `Rect2` with the first corner at `position` and the opposite corner at `end`.
+    #[inline]
+    pub fn from_corners(position: Vector2, end: Vector2) -> Self {
+        // Cannot use floating point arithmetic in const functions.
+        Self::new(position, end - position)
+    }
+
     /// Create a new `Rect2` from four reals representing position `(x,y)` and size `(width,height)`.
     ///
     /// _Godot equivalent: `Rect2(float x, float y, float width, float height)`_
@@ -46,9 +53,18 @@ impl Rect2 {
         }
     }
 
-    /// Returns a rectangle with the same geometry, with top-left corner as `position` and non-negative size.
+    /// Create a new `Rect2` from a `Rect2i`, using `as` for `i32` to `real` conversions.
     ///
-    /// _Godot equivalent: `Rect2.abs()`_
+    /// _Godot equivalent: `Rect2(Rect2i from)`_
+    #[inline]
+    pub const fn from_rect2i(rect: Rect2i) -> Self {
+        Self {
+            position: Vector2::from_vector2i(rect.position),
+            size: Vector2::from_vector2i(rect.size),
+        }
+    }
+
+    /// Returns a rectangle with the same geometry, with top-left corner as `position` and non-negative size.
     #[inline]
     pub fn abs(&self) -> Self {
         Self {
@@ -58,8 +74,6 @@ impl Rect2 {
     }
 
     /// Whether `self` covers at least the entire area of `b` (and possibly more).
-    ///
-    /// _Godot equivalent: `Rect2.encloses(Rect2 b)`_
     #[inline]
     pub fn encloses(&self, b: Rect2) -> bool {
         let end = self.end();
@@ -75,8 +89,6 @@ impl Rect2 {
     ///
     /// Note: This method is not reliable for `Rect2` with a negative size. Use [`abs`][Self::abs]
     /// to get a positive sized equivalent rectangle for expanding.
-    ///
-    /// _Godot equivalent: `Rect2.expand(Vector2 to)`_
     #[inline]
     pub fn expand(&self, to: Vector2) -> Self {
         self.merge(Rect2::new(to, Vector2::ZERO))
@@ -86,8 +98,6 @@ impl Rect2 {
     ///
     /// Note: This method is not reliable for `Rect2` with a negative size. Use [`abs`][Self::abs]
     /// to get a positive sized equivalent rectangle for merging.
-    ///
-    /// _Godot equivalent: `Rect2.merge(Rect2 b)`_
     #[inline]
     pub fn merge(&self, b: Self) -> Self {
         let position = self.position.coord_min(b.position);
@@ -97,26 +107,18 @@ impl Rect2 {
     }
 
     /// Returns the area of the rectangle.
-    ///
-    /// _Godot equivalent: `Rect2.get_area()`_
-    #[doc(alias = "get_area")]
     #[inline]
     pub fn area(&self) -> real {
         self.size.x * self.size.y
     }
 
     /// Returns the center of the Rect2, which is equal to `position + (size / 2)`.
-    ///
-    /// _Godot equivalent: `Rect2.get_center()`_
-    #[doc(alias = "get_center")]
     #[inline]
     pub fn center(&self) -> Vector2 {
         self.position + (self.size / 2.0)
     }
 
     /// Returns a copy of the Rect2 grown by the specified `amount` on all sides.
-    ///
-    /// _Godot equivalent: `Rect2.grow(float amount)`_
     #[inline]
     #[must_use]
     pub fn grow(&self, amount: real) -> Self {
@@ -127,8 +129,6 @@ impl Rect2 {
     }
 
     /// Returns a copy of the Rect2 grown by the specified amount on each side individually.
-    ///
-    /// _Godot equivalent: `Rect2.grow_individual(float left, float top, float right, float bottom)`_
     #[inline]
     pub fn grow_individual(&self, left: real, top: real, right: real, bottom: real) -> Self {
         Self::from_components(
@@ -143,8 +143,6 @@ impl Rect2 {
     ///
     /// `amount` may be negative, but care must be taken: If the resulting `size` has
     /// negative components the computation may be incorrect.
-    ///
-    /// _Godot equivalent: `Rect2.grow_side(int side, float amount)`_
     #[inline]
     pub fn grow_side(&self, side: RectSide, amount: real) -> Self {
         match side {
@@ -156,8 +154,6 @@ impl Rect2 {
     }
 
     /// Returns `true` if the Rect2 has area, and `false` if the Rect2 is linear, empty, or has a negative size. See also `get_area`.
-    ///
-    /// _Godot equivalent: `Rect2.has_area()`_
     #[inline]
     pub fn has_area(&self) -> bool {
         self.size.x > 0.0 && self.size.y > 0.0
@@ -166,8 +162,6 @@ impl Rect2 {
     /// Returns `true` if the Rect2 contains a point. By convention, the right and bottom edges of the Rect2 are considered exclusive, so points on these edges are not included.
     ///
     /// Note: This method is not reliable for Rect2 with a negative size. Use `abs` to get a positive sized equivalent rectangle to check for contained points.
-    ///
-    /// _Godot equivalent: `Rect2.has_area()`_
     #[inline]
     pub fn has_point(&self, point: Vector2) -> bool {
         let point = point - self.position;
@@ -176,11 +170,9 @@ impl Rect2 {
     }
 
     /// Returns the intersection of this Rect2 and `b`. If the rectangles do not intersect, an empty Rect2 is returned.
-    ///
-    /// _Godot equivalent: `Rect2.intersection(Rect2 b)`_
     #[inline]
     pub fn intersection(&self, b: Self) -> Option<Self> {
-        if !self.intersects(b, true) {
+        if !self.intersects(b) {
             return None;
         }
 
@@ -194,68 +186,53 @@ impl Rect2 {
         Some(rect)
     }
 
-    /// Returns `true` if the Rect2 overlaps with `b` (i.e. they have at least one point in common).
+    /// Checks whether two rectangles have at least one point in common.
     ///
-    /// If `include_borders` is `true`, they will also be considered overlapping if their borders touch, even without intersection.
+    /// Also returns `true` if the rects only touch each other (share a point/edge).
+    /// See [`intersects_exclude_borders`][Self::intersects_exclude_borders] if you want to return `false` in that case.
     ///
-    /// _Godot equivalent: `Rect2.intersects(Rect2 b, bool include_borders)`_
+    /// _Godot equivalent: `Rect2.intersects(Rect2 b, bool include_borders = true)`_
     #[inline]
-    pub fn intersects(&self, b: Self, include_borders: bool) -> bool {
+    pub fn intersects(&self, b: Self) -> bool {
         let end = self.end();
         let end_b = b.end();
 
-        if include_borders {
-            self.position.x <= end_b.x
-                && end.x >= b.position.x
-                && self.position.y <= end_b.y
-                && end.y >= b.position.y
-        } else {
-            self.position.x < end_b.x
-                && end.x > b.position.x
-                && self.position.y < end_b.y
-                && end.y > b.position.y
-        }
+        self.position.x <= end_b.x
+            && end.x >= b.position.x
+            && self.position.y <= end_b.y
+            && end.y >= b.position.y
     }
 
-    /// Returns `true` if this Rect2 is finite, by calling `@GlobalScope.is_finite` on each component.
+    /// Checks whether two rectangles have at least one _inner_ point in common (not on the borders).
     ///
-    /// _Godot equivalent: `Rect2.is_finite()`_
-    pub fn is_finite(&self) -> bool {
-        self.position.is_finite() && self.size.is_finite()
-    }
-
-    /// Create a new `Rect2` from a `Rect2i`, using `as` for `i32` to `real` conversions.
+    /// Returns `false` if the rects only touch each other (share a point/edge).
+    /// See [`intersects`][Self::intersects] if you want to return `true` in that case.
     ///
-    /// _Godot equivalent: `Rect2(Rect2i from)`_
+    /// _Godot equivalent: `Rect2.intersects(AABB b, bool include_borders = false)`_
     #[inline]
-    pub const fn from_rect2i(rect: Rect2i) -> Self {
-        Self {
-            position: Vector2::from_vector2i(rect.position),
-            size: Vector2::from_vector2i(rect.size),
-        }
+    pub fn intersects_exclude_borders(&self, b: Self) -> bool {
+        let end = self.end();
+        let end_b = b.end();
+
+        self.position.x < end_b.x
+            && end.x > b.position.x
+            && self.position.y < end_b.y
+            && end.y > b.position.y
     }
 
-    /// Create a new `Rect2` with the first corner at `position` and the opposite corner at `end`.
+    /// Returns `true` if this Rect2 is finite, by calling `@GlobalScope.is_finite` on each component.
     #[inline]
-    pub fn from_corners(position: Vector2, end: Vector2) -> Self {
-        Self {
-            position,
-            size: end - position,
-        }
+    pub fn is_finite(&self) -> bool {
+        self.position.is_finite() && self.size.is_finite()
     }
 
     /// The end of the `Rect2` calculated as `position + size`.
-    ///
-    /// _Godot equivalent: `Rect2.size` property_
-    #[doc(alias = "size")]
     #[inline]
     pub fn end(&self) -> Vector2 {
         self.position + self.size
     }
 
     /// Set size based on desired end-point.
-    ///
-    /// _Godot equivalent: `Rect2.size` property_
     #[inline]
     pub fn set_end(&mut self, end: Vector2) {
         self.size = end - self.position