Merge pull request #1418 from godot-rust/perf/vector2i-no-ffi

 Fix `Vector2i` using FFI; add functions to `Vector3i`/`Vector4i`

Author: Bromeon

godot-codegen/src/special_cases/special_cases.rs

@@ -676,14 +676,6 @@ pub fn is_builtin_method_exposed(builtin_ty: &TyName, godot_method_name: &str) -
         | ("PackedByteArray", "get_string_from_wchar")
         | ("PackedByteArray", "hex_encode")
 
-        // Vector2i
-        | ("Vector2i", "clampi")
-        | ("Vector2i", "distance_squared_to")
-        | ("Vector2i", "distance_to")
-        | ("Vector2i", "maxi")
-        | ("Vector2i", "mini")
-        | ("Vector2i", "snappedi")
-
         => true, _ => false
     }
 }

godot-core/src/builtin/vectors/vector2i.rs

@@ -124,6 +124,7 @@ impl GlamConv for Vector2i {
 #[cfg(test)]
 mod test {
     use super::*;
+    use crate::assert_eq_approx;
 
     #[test]
     fn coord_min_max() {
@@ -161,4 +162,29 @@ mod test {
         assert_eq!(Vector2i::new(15, 15).max_axis(), None);
         assert_eq!(Vector2i::new(15, 15).min_axis(), None);
     }
+
+    #[test]
+    fn distance() {
+        let a = Vector2i::new(1, 2);
+        let b = Vector2i::new(4, 6);
+
+        assert_eq!(a.distance_squared_to(b), 25);
+        assert_eq_approx!(a.distance_to(b), 5.0);
+    }
+
+    #[test]
+    fn mini_maxi_clampi() {
+        let v = Vector2i::new(10, -5);
+
+        assert_eq!(v.mini(3), Vector2i::new(3, -5));
+        assert_eq!(v.maxi(-2), Vector2i::new(10, -2));
+        assert_eq!(v.clampi(-3, 7), Vector2i::new(7, -3));
+    }
+
+    #[test]
+    fn snappedi() {
+        let v = Vector2i::new(13, -8);
+
+        assert_eq!(v.snappedi(5), Vector2i::new(15, -10));
+    }
 }

godot-core/src/builtin/vectors/vector_macros.rs

@@ -538,6 +538,56 @@ macro_rules! inline_impl_integer_vector_fns {
         // Names of the components, for example `x, y`.
         $($comp:ident),*
     ) => {
+        /// Returns the distance between this vector and `to`.
+        ///
+        /// Where possible, prefer [`distance_squared_to()`][Self::distance_squared_to] for precision and performance.
+        #[inline]
+        pub fn distance_to(self, to: Self) -> real {
+            (to - self).length()
+        }
+
+        /// Returns the squared distance between this vector and `to`.
+        ///
+        /// Faster than [`distance_to()`][Self::distance_to], so prefer it if you need to compare distances, or need the squared distance
+        /// in a formula.
+        #[inline]
+        pub fn distance_squared_to(self, to: Self) -> i32 {
+            (to - self).length_squared() as i32
+        }
+
+        /// Returns `self` with each component limited to a range defined by `min` and `max`.
+        ///
+        /// # Panics
+        /// If `min > max` on any axis.
+        #[inline]
+        pub fn clampi(self, min: i32, max: i32) -> Self {
+            Self::new(
+                $(
+                    self.$comp.clamp(min, max)
+                ),*
+            )
+        }
+
+        /// Returns a new vector with each component set to the minimum of `self` and `with`.
+        #[inline]
+        pub fn mini(self, with: i32) -> Self {
+            Self::new(
+                $(
+                    self.$comp.min(with)
+                ),*
+            )
+        }
+
+        /// Returns a new vector with each component set to the maximum of `self` and `with`.
+        #[inline]
+        pub fn maxi(self, with: i32) -> Self {
+            Self::new(
+                $(
+                    self.$comp.max(with)
+                ),*
+            )
+        }
+
         /// A new vector with each component snapped to the closest multiple of the corresponding
         /// component in `step`.
         ///
@@ -556,6 +606,15 @@ macro_rules! inline_impl_integer_vector_fns {
             )
         }
 
+        /// A new vector with each component snapped to the closest multiple of `step`.
+        ///
+        /// # Panics
+        /// On under- or overflow (see [`snapped()`][Self::snapped] for details).
+        #[inline]
+        pub fn snappedi(self, step: i32) -> Self {
+            self.snapped(Self::splat(step))
+        }
+
         /// Converts to a vector with floating-point [`real`](type.real.html) components, using `as` casts.
         #[inline]
         pub const fn cast_float(self) -> $VectorFloat {
@@ -654,13 +713,16 @@ macro_rules! impl_float_vector_fns {
 
             /// Returns the squared distance between this vector and `to`.
             ///
-            /// This method runs faster than [`Self::distance_to`], so prefer it if you need to compare vectors or need the squared distance for some formula.
+            /// Faster than [`distance_to()`][Self::distance_to], so prefer it if you need to compare distances, or need the squared distance
+            /// in a formula.
             #[inline]
             pub fn distance_squared_to(self, to: Self) -> real {
                 (to - self).length_squared()
             }
 
             /// Returns the distance between this vector and `to`.
+            ///
+            /// Where possible, prefer [`distance_squared_to()`][Self::distance_squared_to] for performance reasons.
             #[inline]
             pub fn distance_to(self, to: Self) -> real {
                 (to - self).length()