godot-core: builtin: vector: provide component-wise min/max under unambiguous name

Author: yannick-was-taken

godot-core/src/builtin/mod.rs

@@ -212,7 +212,7 @@ mod real_mod {
     /// A 4-dimensional vector from [`glam`]. Using a floating-point format compatible with [`real`].
     pub type RVec4 = glam::Vec4;
 
-    /// A 2x2 column-major matrix from [`glam`]. Using a floating-point format compatible with [`real`].  
+    /// A 2x2 column-major matrix from [`glam`]. Using a floating-point format compatible with [`real`].
     pub type RMat2 = glam::Mat2;
     /// A 3x3 column-major matrix from [`glam`]. Using a floating-point format compatible with [`real`].
     pub type RMat3 = glam::Mat3;
@@ -279,7 +279,7 @@ mod real_mod {
     /// A 4-dimensional vector from [`glam`]. Using a floating-point format compatible with [`real`].
     pub type RVec4 = glam::DVec4;
 
-    /// A 2x2 column-major matrix from [`glam`]. Using a floating-point format compatible with [`real`].  
+    /// A 2x2 column-major matrix from [`glam`]. Using a floating-point format compatible with [`real`].
     pub type RMat2 = glam::DMat2;
     /// A 3x3 column-major matrix from [`glam`]. Using a floating-point format compatible with [`real`].
     pub type RMat3 = glam::DMat3;

godot-core/src/builtin/transform2d.rs

@@ -333,8 +333,8 @@ impl Mul<Rect2> for Transform2D {
         let ya = self.b * rhs.position.y;
         let yb = self.b * rhs.end().y;
 
-        let position = Vector2::min(xa, xb) + Vector2::min(ya, yb) + self.origin;
-        let end = Vector2::max(xa, xb) + Vector2::max(ya, yb) + self.origin;
+        let position = Vector2::coord_min(xa, xb) + Vector2::coord_min(ya, yb) + self.origin;
+        let end = Vector2::coord_max(xa, xb) + Vector2::coord_max(ya, yb) + self.origin;
         Rect2::new(position, end - position)
     }
 }

godot-core/src/builtin/transform3d.rs

@@ -311,9 +311,14 @@ impl Mul<Aabb> for Transform3D {
         let za = self.basis.col_c() * rhs.position.z;
         let zb = self.basis.col_c() * rhs.end().z;
 
-        let position =
-            Vector3::min(xa, xb) + Vector3::min(ya, yb) + Vector3::min(za, zb) + self.origin;
-        let end = Vector3::max(xa, xb) + Vector3::max(ya, yb) + Vector3::max(za, zb) + self.origin;
+        let position = Vector3::coord_min(xa, xb)
+            + Vector3::coord_min(ya, yb)
+            + Vector3::coord_min(za, zb)
+            + self.origin;
+        let end = Vector3::coord_max(xa, xb)
+            + Vector3::coord_max(ya, yb)
+            + Vector3::coord_max(za, zb)
+            + self.origin;
         Aabb::new(position, end - position)
     }
 }

godot-core/src/builtin/vector2.rs

@@ -305,7 +305,7 @@ impl fmt::Display for Vector2 {
     }
 }
 
-impl_common_vector_fns!(Vector2, real);
+impl_common_vector_fns!(Vector2, real, (x, y));
 impl_float_vector_fns!(Vector2, real);
 impl_vector_operators!(Vector2, real, (x, y));
 impl_vector_index!(Vector2, real, (x, y), Vector2Axis, (X, Y));

godot-core/src/builtin/vector2i.rs

@@ -84,7 +84,7 @@ impl fmt::Display for Vector2i {
     }
 }
 
-impl_common_vector_fns!(Vector2i, i32);
+impl_common_vector_fns!(Vector2i, i32, (x, y));
 impl_vector_operators!(Vector2i, i32, (x, y));
 impl_vector_index!(Vector2i, i32, (x, y), Vector2iAxis, (X, Y));
 

godot-core/src/builtin/vector3.rs

@@ -315,7 +315,7 @@ impl fmt::Display for Vector3 {
     }
 }
 
-impl_common_vector_fns!(Vector3, real);
+impl_common_vector_fns!(Vector3, real, (x, y, z));
 impl_float_vector_fns!(Vector3, real);
 impl_vector_operators!(Vector3, real, (x, y, z));
 impl_vector_index!(Vector3, real, (x, y, z), Vector3Axis, (X, Y, Z));

godot-core/src/builtin/vector3i.rs

@@ -93,7 +93,7 @@ impl fmt::Display for Vector3i {
     }
 }
 
-impl_common_vector_fns!(Vector3i, i32);
+impl_common_vector_fns!(Vector3i, i32, (x, y, z));
 impl_vector_operators!(Vector3i, i32, (x, y, z));
 impl_vector_index!(Vector3i, i32, (x, y, z), Vector3iAxis, (X, Y, Z));
 

godot-core/src/builtin/vector4.rs

@@ -38,7 +38,7 @@ pub struct Vector4 {
 
 impl_vector_operators!(Vector4, real, (x, y, z, w));
 impl_vector_index!(Vector4, real, (x, y, z, w), Vector4Axis, (X, Y, Z, W));
-impl_common_vector_fns!(Vector4, real);
+impl_common_vector_fns!(Vector4, real, (x, y, z, w));
 impl_float_vector_fns!(Vector4, real);
 
 impl Vector4 {

godot-core/src/builtin/vector4i.rs

@@ -34,7 +34,7 @@ pub struct Vector4i {
 
 impl_vector_operators!(Vector4i, i32, (x, y, z, w));
 impl_vector_index!(Vector4i, i32, (x, y, z, w), Vector4iAxis, (X, Y, Z, W));
-impl_common_vector_fns!(Vector4i, i32);
+impl_common_vector_fns!(Vector4i, i32, (x, y, z, w));
 
 impl Vector4i {
     /// Returns a `Vector4i` with the given components.

godot-core/src/builtin/vector_macros.rs

@@ -229,7 +229,9 @@ macro_rules! impl_common_vector_fns {
         // Name of the vector type.
         $Vector:ty,
         // Type of target component, for example `real`.
-        $Scalar:ty
+        $Scalar:ty,
+        // Names of the components, with parentheses, for example `(x, y)`.
+        ($($components:ident),*)
     ) => {
         impl $Vector {
             /// Returns a new vector with all components in absolute values (i.e. positive or
@@ -238,6 +240,31 @@ macro_rules! impl_common_vector_fns {
             pub fn abs(self) -> Self {
                 Self::from_glam(self.to_glam().abs())
             }
+
+            /// Returns a new vector containing the minimum of the two vectors, component-wise.
+            #[inline]
+            pub fn coord_min(self, other: Self) -> Self {
+                self.coord_operation(other, <$Scalar>::min)
+            }
+
+            /// Returns a new vector containing the maximum of the two vectors, component-wise.
+            #[inline]
+            pub fn coord_max(self, other: Self) -> Self {
+                self.coord_operation(other, <$Scalar>::max)
+            }
+
+            /// Applies a component-wise internal binary operation to the two vectors.
+            #[inline]
+            fn coord_operation<F>(self, other: Self, f: F) -> Self
+            where
+                F: Fn($Scalar, $Scalar) -> $Scalar
+            {
+                Self {
+                    $(
+                        $components: f(self.$components, other.$components)
+                    ),+
+                }
+            }
         }
     };
 }
@@ -266,18 +293,6 @@ macro_rules! impl_float_vector_fns {
             pub fn normalized(self) -> Self {
                 Self::from_glam(self.to_glam().normalize_or_zero())
             }
-
-            /// Returns a vector containing the minimum values for each element of `self` and `other`.
-            #[inline]
-            pub fn min(self, other: Self) -> Self {
-                self.glam2(&other, |a, b| a.min(b))
-            }
-
-            /// Returns a vector containing the maximum values for each element of `self` and `other`.
-            #[inline]
-            pub fn max(self, other: Self) -> Self {
-                self.glam2(&other, |a, b| a.max(b))
-            }
         }
     };
 }