Rect2, Aabb: pass self by value (they are Copy; also consistency with Quat, Plane etc.)

Author: Bromeon

gdnative-core/src/core_types/geom/aabb.rs

@@ -28,7 +28,7 @@ impl Aabb {
 
     /// Ending corner. This is calculated as `position + size`.
     #[inline]
-    pub fn end(&self) -> Vector3 {
+    pub fn end(self) -> Vector3 {
         self.position + self.size
     }
 
@@ -41,7 +41,7 @@ impl Aabb {
     /// Returns an `Aabb` with equivalent position and area, modified so that the most-negative
     /// corner is the origin and the size is positive.
     #[inline]
-    pub fn abs(&self) -> Self {
+    pub fn abs(self) -> Self {
         let position = self.position + Vector3::gd(self.size.glam().min(glam::Vec3A::ZERO));
         let size = self.size.abs();
 
@@ -54,7 +54,7 @@ impl Aabb {
     ///
     /// [get_area]: https://docs.godotengine.org/en/stable/classes/class_aabb.html#class-aabb-method-get-area
     #[inline]
-    pub fn get_volume(&self) -> f32 {
+    pub fn get_volume(self) -> f32 {
         self.size.x * self.size.y * self.size.z
     }
 
@@ -68,13 +68,13 @@ impl Aabb {
     ///
     /// [`has_no_area`]: https://docs.godotengine.org/en/stable/classes/class_aabb.html#class-aabb-method-has-no-area
     #[inline]
-    pub fn has_no_volume(&self) -> bool {
+    pub fn has_no_volume(self) -> bool {
         self.size.x <= 0.0 || self.size.y <= 0.0 || self.size.z <= 0.0
     }
 
     /// Returns true if the bounding box is empty or all of its dimensions are negative.
     #[inline]
-    pub fn has_no_surface(&self) -> bool {
+    pub fn has_no_surface(self) -> bool {
         self.size.x <= 0.0 && self.size.y <= 0.0 && self.size.z <= 0.0
     }
 
@@ -84,7 +84,7 @@ impl Aabb {
     /// Note: This method is not reliable for bounding boxes with a negative size. Use
     /// [`abs`][Self::abs] to get a positive sized equivalent box to check for contained points.
     #[inline]
-    pub fn contains_point(&self, point: Vector3) -> bool {
+    pub fn contains_point(self, point: Vector3) -> bool {
         let point = point - self.position;
 
         point.abs() == point
@@ -96,15 +96,15 @@ impl Aabb {
     /// Returns true if this bounding box and `b` are approximately equal, by calling
     /// [`is_equal_approx`](Vector3::is_equal_approx) on each component.
     #[inline]
-    pub fn is_equal_approx(&self, b: Self) -> bool {
+    pub fn is_equal_approx(self, b: Self) -> bool {
         self.position.is_equal_approx(b.position) && self.size.is_equal_approx(b.size)
     }
 
     /// Gets the position of the 8 endpoints of the bounding box in space.
     ///
     /// The index returns an arbitrary point, but all points are guaranteed to be unique.
     #[inline]
-    pub fn get_endpoint(&self, index: usize) -> Option<Vector3> {
+    pub fn get_endpoint(self, index: usize) -> Option<Vector3> {
         match index {
             0 => Some(self.position),
             1 => Some(self.position + Vector3::new(0.0, 0.0, self.size.z)),
@@ -120,42 +120,42 @@ impl Aabb {
 
     /// Returns the normalized longest axis of the bounding box.
     #[inline]
-    pub fn get_longest_axis(&self) -> Vector3 {
+    pub fn get_longest_axis(self) -> Vector3 {
         self.size.max_axis().to_unit_vector()
     }
 
     /// Returns the index of the longest axis of the bounding box.
     ///
     /// If multiple axes have the same length, then the first in order X, Y, Z is returned.
     #[inline]
-    pub fn get_longest_axis_index(&self) -> Axis {
+    pub fn get_longest_axis_index(self) -> Axis {
         self.size.max_axis()
     }
 
     /// Returns the scalar length of the longest axis of the bounding box.
     #[inline]
-    pub fn get_longest_axis_size(&self) -> f32 {
+    pub fn get_longest_axis_size(self) -> f32 {
         let Vector3 { x, y, z } = self.size;
         x.max(y).max(z)
     }
 
     /// Returns the normalized shortest axis of the bounding box.
     #[inline]
-    pub fn get_shortest_axis(&self) -> Vector3 {
+    pub fn get_shortest_axis(self) -> Vector3 {
         self.size.min_axis().to_unit_vector()
     }
 
     /// Returns the index of the shortest axis of the bounding box.
     ///
     /// If multiple axes have the same length, then the first in order X, Y, Z is returned.
     #[inline]
-    pub fn get_shortest_axis_index(&self) -> Axis {
+    pub fn get_shortest_axis_index(self) -> Axis {
         self.size.min_axis()
     }
 
     /// Returns the scalar length of the shortest axis of the bounding box.
     #[inline]
-    pub fn get_shortest_axis_size(&self) -> f32 {
+    pub fn get_shortest_axis_size(self) -> f32 {
         let Vector3 { x, y, z } = self.size;
         x.min(y).min(z)
     }
@@ -173,7 +173,7 @@ impl Aabb {
     /// [1]: https://ncollide.org/geometric_representations/#support-mappings
     /// [2]: https://www.toptal.com/game/video-game-physics-part-ii-collision-detection-for-solid-objects
     #[inline]
-    pub fn get_support(&self, dir: Vector3) -> Vector3 {
+    pub fn get_support(self, dir: Vector3) -> Vector3 {
         self.position
             + Vector3::new(
                 if dir.x > 0.0 { 0.0 } else { self.size.x },
@@ -187,7 +187,7 @@ impl Aabb {
     /// It is possible to specify a negative amount to shrink the AABB (note that this can invert the AABB).
     #[inline]
     #[must_use]
-    pub fn grow(&self, by: f32) -> Self {
+    pub fn grow(self, by: f32) -> Self {
         let position = self.position - Vector3::new(by, by, by);
         let size = self.size + Vector3::new(by, by, by) * 2.0;
 
@@ -198,7 +198,7 @@ impl Aabb {
     ///
     /// This **excludes** borders; if the intersection has no volume, `false` is returned.
     #[inline]
-    pub fn intersects(&self, b: Self) -> bool {
+    pub fn intersects(self, b: Self) -> bool {
         self.position.x < b.position.x + b.size.x
             && self.position.x + self.size.x > b.position.x
             && self.position.y < b.position.y + b.size.y
@@ -209,7 +209,7 @@ impl Aabb {
 
     /// Returns true if the bounding box is on both sides of a plane.
     #[inline]
-    pub fn intersects_plane(&self, plane: Plane) -> bool {
+    pub fn intersects_plane(self, plane: Plane) -> bool {
         let mut corners = [Vector3::ZERO; 8];
         for (i, corner) in corners.iter_mut().enumerate() {
             *corner = self.get_endpoint(i).unwrap();
@@ -230,7 +230,7 @@ impl Aabb {
 
     /// Returns true if the bounding box intersects the line segment between `from` and `to`.
     #[inline]
-    pub fn intersects_segment(&self, from: Vector3, to: Vector3) -> bool {
+    pub fn intersects_segment(self, from: Vector3, to: Vector3) -> bool {
         let mut min: f32 = 0.0;
         let mut max: f32 = 1.0;
 
@@ -283,7 +283,7 @@ impl Aabb {
     /// This **excludes** borders; if the intersection has no volume, `None` is returned.
     #[inline]
     #[must_use]
-    pub fn intersection(&self, b: Self) -> Option<Self> {
+    pub fn intersection(self, b: Self) -> Option<Self> {
         if !self.intersects(b) {
             return None;
         }
@@ -306,7 +306,7 @@ impl Aabb {
     /// Returns a larger bounding box that contains both this `Aabb` and `b`.
     #[inline]
     #[must_use]
-    pub fn merge(&self, b: Self) -> Self {
+    pub fn merge(self, b: Self) -> Self {
         let position = Vector3::new(
             self.position.x.min(b.position.x),
             self.position.y.min(b.position.y),

gdnative-core/src/core_types/geom/rect2.rs

@@ -35,7 +35,7 @@ impl Rect2 {
 
     /// Ending corner. This is calculated as `position + size`.
     #[inline]
-    pub fn end(&self) -> Vector2 {
+    pub fn end(self) -> Vector2 {
         self.position + self.size
     }
 
@@ -48,7 +48,7 @@ impl Rect2 {
     /// Returns a rectangle with equivalent position and area, modified so that the top-left corner
     /// is the origin and `width` and `height` are positive.
     #[inline]
-    pub fn abs(&self) -> Self {
+    pub fn abs(self) -> Self {
         let position = self.position + Vector2::new(self.size.x.min(0.0), self.size.y.min(0.0));
         let size = self.size.abs();
 
@@ -57,7 +57,7 @@ impl Rect2 {
 
     /// Returns the area of the rectangle. See also [`has_no_area`][Self::has_no_area].
     #[inline]
-    pub fn get_area(&self) -> f32 {
+    pub fn get_area(self) -> f32 {
         self.size.x * self.size.y
     }
 
@@ -80,7 +80,7 @@ impl Rect2 {
     /// # }
     /// ```
     #[inline]
-    pub fn has_no_area(&self) -> bool {
+    pub fn has_no_area(self) -> bool {
         self.size.x <= 0.0 || self.size.y <= 0.0
     }
 
@@ -90,7 +90,7 @@ 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 to check for contained points.
     #[inline]
-    pub fn contains_point(&self, point: Vector2) -> bool {
+    pub fn contains_point(self, point: Vector2) -> bool {
         let point = point - self.position;
 
         point.abs() == point && point.x < self.size.x && point.y < self.size.y
@@ -99,7 +99,7 @@ impl Rect2 {
     /// Returns true if this rectangle and `b` are approximately equal, by calling
     /// [`is_equal_approx`](Vector2::is_equal_approx) on each component.
     #[inline]
-    pub fn is_equal_approx(&self, b: Self) -> bool {
+    pub fn is_equal_approx(self, b: Self) -> bool {
         self.position.is_equal_approx(b.position) && self.size.is_equal_approx(b.size)
     }
 
@@ -111,7 +111,7 @@ 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 to check for intersections.
     #[inline]
-    pub fn intersects(&self, b: Self) -> bool {
+    pub fn intersects(self, b: Self) -> bool {
         self.position.x < b.position.x + b.size.x
             && self.position.x + self.size.x > b.position.x
             && self.position.y < b.position.y + b.size.y
@@ -126,7 +126,7 @@ 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 to check for intersections.
     #[inline]
-    pub fn intersects_including_borders(&self, b: Self) -> bool {
+    pub fn intersects_including_borders(self, b: Self) -> bool {
         self.position.x <= b.position.x + b.size.x
             && self.position.x + self.size.x >= b.position.x
             && self.position.y <= b.position.y + b.size.y
@@ -137,7 +137,7 @@ impl Rect2 {
     ///
     /// This is true when `self` covers all the area of `b`, and possibly (but not necessarily) more.
     #[inline]
-    pub fn encloses(&self, b: Self) -> bool {
+    pub fn encloses(self, b: Self) -> bool {
         b.position.x >= self.position.x
             && b.position.y >= self.position.y
             && b.position.x + b.size.x <= self.position.x + self.size.x
@@ -153,7 +153,7 @@ impl Rect2 {
     /// to get a positive sized equivalent rectangle for clipping.
     #[inline]
     #[must_use]
-    pub fn intersection(&self, b: Self) -> Option<Self> {
+    pub fn intersection(self, b: Self) -> Option<Self> {
         if !self.intersects(b) {
             return None;
         }
@@ -177,7 +177,7 @@ impl Rect2 {
     /// to get a positive sized equivalent rectangle for merging.
     #[inline]
     #[must_use]
-    pub fn merge(&self, b: Self) -> Self {
+    pub fn merge(self, b: Self) -> Self {
         let position = Vector2::new(
             self.position.x.min(b.position.x),
             self.position.y.min(b.position.y),
@@ -214,14 +214,14 @@ impl Rect2 {
     /// ```
     #[inline]
     #[must_use]
-    pub fn expand(&self, to: Vector2) -> Self {
+    pub fn expand(self, to: Vector2) -> Self {
         self.merge(Self::new(to, Vector2::ZERO))
     }
 
     /// Returns a copy of this rectangle grown by a given amount of units on all the sides.
     #[inline]
     #[must_use]
-    pub fn grow(&self, by: f32) -> Self {
+    pub fn grow(self, by: f32) -> Self {
         let position = self.position - Vector2::new(by, by);
         let size = self.size + Vector2::new(by, by) * 2.0;
 
@@ -232,22 +232,20 @@ impl Rect2 {
     /// individually.
     #[inline]
     #[must_use]
-    pub fn grow_individual(&self, left: f32, top: f32, right: f32, bottom: f32) -> Self {
-        let mut rect = *self;
+    pub fn grow_individual(mut self, left: f32, top: f32, right: f32, bottom: f32) -> Self {
+        self.position.x -= left;
+        self.position.y -= top;
+        self.size.x += left + right;
+        self.size.y += top + bottom;
 
-        rect.position.x -= left;
-        rect.position.y -= top;
-        rect.size.x += left + right;
-        rect.size.y += top + bottom;
-
-        rect
+        self
     }
 
     /// Returns a copy of this rectangle grown by a given amount of units towards the [`Margin`]
     /// direction.
     #[inline]
     #[must_use]
-    pub fn grow_margin(&self, margin: Margin, amount: f32) -> Self {
+    pub fn grow_margin(self, margin: Margin, amount: f32) -> Self {
         let left = if margin == Margin::Left { amount } else { 0.0 };
         let top = if margin == Margin::Top { amount } else { 0.0 };
         let right = if margin == Margin::Right { amount } else { 0.0 };